opencode-swarm 7.140.3 → 7.140.4

package/dist/cli/{index-q1q8b85k.js → index-a1fjhx4w.js}

@@ -13,16 +13,16 @@ import {
   resolveExecutableFromPath,
   runEvaluation,
   runExternalTool
-} from "./index-1m1ksyqt.js";
+} from "./index-c5kr20nz.js";
 import {
   stableCanonicalStringify
-} from "./index-wf35ka4z.js";
+} from "./index-ysa38bnr.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-xz8f1n1a.js";
+} from "./index-arza4m4j.js";
 import {
   MAX_TRANSIENT_RETRIES,
   archiveEvidence,
@@ -34,6 +34,7 @@ import {
   containsControlChars,
   containsPathTraversal,
   derivePlanMarkdown,
+  detectDefaultRemoteBranch,
   disableEpicMode,
   enableEpicMode,
   ensureTaskCheckpointReceipt,
@@ -67,7 +68,7 @@ import {
   transientBackoff,
   updateTaskCheckpointReceipt,
   validateProjectRoot
-} from "./index-brh827g0.js";
+} from "./index-hz0refz4.js";
 import {
   EvaluationTaskV1Schema,
   GateAuditManifestV1Schema,
@@ -84,7 +85,7 @@ import {
   saveGateAuditResult,
   savePromotionDecision,
   saveTaskSetSnapshot
-} from "./index-yyyk63kk.js";
+} from "./index-w4etfamq.js";
 import {
   canonicalHash,
   canonicalJson,
@@ -122,15 +123,15 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-7kdd75se.js";
+} from "./index-hfjvepk2.js";
 import {
   readRecentEscalations
-} from "./index-jvk119ck.js";
+} from "./index-v1an91bq.js";
 import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   resolveCohortId
-} from "./index-gtbmabws.js";
+} from "./index-mpytsq6k.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
@@ -153,13 +154,13 @@ import {
   listActive,
   subscribe,
   unsubscribe
-} from "./index-jfjnn408.js";
+} from "./index-bn17ycxn.js";
 import {
   MAX_PENDING_SCOPE_BINDINGS,
   clearAllScopes,
   clearScopeBindingFromDisk,
   clearScopeBindings
-} from "./index-adyxbmt5.js";
+} from "./index-ryq97w1x.js";
 import {
   appendLedgerEvent,
   computePlanHash,
@@ -169,7 +170,7 @@ import {
   initLedger,
   readLedgerEvents,
   takeSnapshotEvent
-} from "./index-kbfsp07d.js";
+} from "./index-wk8s1m7b.js";
 import {
   getAllWorktreeMergeFailures,
   initDurableStatusPath
@@ -177,12 +178,7 @@ import {
 import {
   findByBatchId,
   readDelegations
-} from "./index-b9rd29ge.js";
-import {
-  readSwarmFileAsync,
-  safeHook,
-  validateSwarmPath
-} from "./index-k46me75h.js";
+} from "./index-rrb6cz2f.js";
 import {
   parsePorcelainV2Snapshot,
   resolveCommitCountSince,
@@ -212,6 +208,25 @@ import {
   SandboxCapabilityProbe,
   init_capability_probe
 } from "./index-8fwhhayc.js";
+import {
+  MAX_EVENT_LOG_ENTRIES,
+  _internals,
+  effectiveRetrievalOutcomes,
+  queryHistoricalOutcomes,
+  readAuthoritativeKnowledgeCounterRollups,
+  readKnowledgeCounterRollups,
+  readKnowledgeEvents,
+  reconcilePhaseClose,
+  recordHiveKnowledgeEvent,
+  recordKnowledgeEvent,
+  recordPhaseCloseIntent,
+  resolveKnowledgeEventsPath
+} from "./index-2rb3x0fk.js";
+import {
+  readSwarmFileAsync,
+  safeHook,
+  validateSwarmPath
+} from "./index-k46me75h.js";
 import {
   appendUnactionable,
   quarantineEntry,
@@ -222,11 +237,11 @@ import {
   validateActionableFields,
   validateLesson,
   validateSkillPath
-} from "./index-8n4c3vec.js";
+} from "./index-7begd9aq.js";
 import {
   authorizeCuration,
   buildConfigFingerprintInput
-} from "./index-p9dsb0tw.js";
+} from "./index-dtam929z.js";
 import {
   cohortConfigFingerprint
 } from "./index-rtry5xyf.js";
@@ -259,17 +274,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-qksjaxpd.js";
-import {
-  MAX_EVENT_LOG_ENTRIES,
-  _internals,
-  effectiveRetrievalOutcomes,
-  readKnowledgeCounterRollups,
-  readKnowledgeEvents,
-  recordHiveKnowledgeEvent,
-  recordKnowledgeEvent,
-  resolveKnowledgeEventsPath
-} from "./index-n8jncheh.js";
+} from "./index-vrmkg8fm.js";
 import {
   resolveHiveDataDir,
   resolveHiveEventsPath,
@@ -285,10 +290,10 @@ import {
   resolveLinkDir,
   sanitizeLinkId,
   writeLinkPointer
-} from "./index-rs1f1bh0.js";
+} from "./index-mrpfd1jx.js";
 import {
   atomicWriteFile
-} from "./index-h2waehqq.js";
+} from "./index-4hp8nvwb.js";
 import {
   invalidateCachedArtifact,
   resetSwarmArtifactCache
@@ -299,7 +304,7 @@ import {
   isStrictPathDescendant,
   tryAcquireLock,
   withEvidenceLock
-} from "./index-hfvxhk4z.js";
+} from "./index-35qep0v7.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
@@ -313,7 +318,7 @@ import {
   init_loader,
   loadPluginConfig,
   loadPluginConfigWithMeta
-} from "./index-8bnzzv3b.js";
+} from "./index-pp5m7xga.js";
 import {
   RetrospectiveEvidenceSchema
 } from "./index-gprxjmm7.js";
@@ -345,7 +350,7 @@ import {
   package_default,
   resolveAutoReviewConfig,
   stripKnownSwarmPrefix
-} from "./index-7d5jseea.js";
+} from "./index-tj04dj06.js";
 import {
   AGENT_TOOL_MAP,
   ALL_AGENT_NAMES,
@@ -357,7 +362,7 @@ import {
   init_agent_names,
   init_constants,
   init_tool_metadata
-} from "./index-n408rw7n.js";
+} from "./index-hxvkfx6t.js";
 import {
   KNOWLEDGE_SCHEMA_VERSION,
   OUTCOME_BLOCK_THRESHOLD,
@@ -368,7 +373,7 @@ import {
   emit,
   getLastHeartbeat,
   telemetry
-} from "./index-ry0hgg3m.js";
+} from "./index-bfhwtdsw.js";
 import {
   exports_external,
   init_zod
@@ -2245,7 +2250,15 @@ var PrFeedbackStageACheckReceiptSchema = exports_external.object({
   feedbackTargets: exports_external.array(exports_external.object({
     feedbackItemId: exports_external.string().min(1),
     target: exports_external.string().min(1),
-    expectedBehavior: exports_external.string().min(8)
+    expectedBehavior: exports_external.string().min(8),
+    proofKind: exports_external.enum([
+      "defect",
+      "metadata",
+      "source-proof",
+      "conflict",
+      "ci",
+      "user-decision"
+    ]).optional()
   }).strict()).min(1).optional(),
   durationMs: exports_external.number().nonnegative()
 }).strict();
@@ -2379,6 +2392,7 @@ var PrWorkflowGateStateSchema = exports_external.object({
   prFeedbackStageA: PrFeedbackStageARecordSchema.optional(),
   prFeedbackGateBatches: exports_external.array(PrFeedbackGateBatchRecordSchema).max(MAX_WORKFLOW_BATCHES).optional(),
   prFeedbackReadyToPublish: PrFeedbackReadyToPublishRecordSchema.optional(),
+  prFeedbackRebindCount: exports_external.number().int().nonnegative().optional(),
   prFeedbackScopes: exports_external.array(PrFeedbackScopeDeclarationRecordSchema).max(MAX_WORKFLOW_BATCHES).optional()
 }).passthrough();
 function formatCheckoutRecoveryBlock(state) {
@@ -4311,6 +4325,12 @@ var FEEDBACK_CLASSIFICATIONS = new Set([
   "NEEDS_MORE_EVIDENCE",
   "NEEDS_USER_DECISION"
 ]);
+var FEEDBACK_NO_CHANGE_CLASSIFICATIONS = new Set([
+  "DISPROVED",
+  "PRE_EXISTING",
+  "NEEDS_MORE_EVIDENCE",
+  "NEEDS_USER_DECISION"
+]);
 function parseReviewerVerdictFields(text, itemId) {
   const rows = text.split(/\r?\n/).map(pipeFields).filter((fields2) => fields2[0] === "[REVIEWED]" && fields2[1] === itemId);
   if (rows.length !== 1)
@@ -9506,7 +9526,7 @@ function getDisplayBudget() {
 async function rehydratePrSubscriptions(sessionID, directory) {
   const map = new Map;
   try {
-    const { listActive: listActive2 } = await import("./pr-subscriptions-5s59h4dd.js");
+    const { listActive: listActive2 } = await import("./pr-subscriptions-83y1cdwv.js");
     const records = await listActive2(directory);
     for (const record of records) {
       if (record.sessionID !== sessionID)
@@ -20196,11 +20216,13 @@ var OUTPUT_LIMIT_BYTES = 12000;
 var _internals24 = {
   runExternalTool,
   getDefaultBaseBranch,
+  detectDefaultRemoteBranch,
   platform: process.platform,
   osTmpdir: () => os4.tmpdir(),
   fs: {
     existsSync: fs13.existsSync,
-    rmSync: fs13.rmSync
+    rmSync: fs13.rmSync,
+    realpathSync: fs13.realpathSync.native
   }
 };
 async function runGit3(args, cwd, timeoutMs = GIT_TIMEOUT_MS4) {
@@ -20250,10 +20272,11 @@ async function getCurrentBranchOrRef(directory) {
   return hashResult.stdout.trim();
 }
 async function setupWorktree(projectRoot, prRef, baseBranch, onWorktreeCreated) {
-  const worktreeBase = path31.join(_internals24.osTmpdir(), "swarm-ci-simulate");
+  const rawBase = path31.join(_internals24.osTmpdir(), "swarm-ci-simulate");
+  await fsPromises2.mkdir(rawBase, { recursive: true });
+  const worktreeBase = _internals24.fs.realpathSync(rawBase);
   const worktreeName = `pr-${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
   const worktreePath = path31.join(worktreeBase, worktreeName);
-  await fsPromises2.mkdir(worktreeBase, { recursive: true });
   const addResult = await runGit3(["worktree", "add", "--detach", worktreePath, baseBranch], projectRoot);
   if (addResult.exitCode !== 0) {
     throw new Error(`Failed to create worktree: ${addResult.stderr.trim() || addResult.stdout.trim()}`);
@@ -20266,15 +20289,37 @@ async function setupWorktree(projectRoot, prRef, baseBranch, onWorktreeCreated)
   return worktreePath;
 }
 async function cleanupWorktree(worktreePath, projectRoot) {
-  const removeResult = await runGit3(["worktree", "remove", "--force", worktreePath], projectRoot);
-  try {
-    if (_internals24.fs.existsSync(worktreePath)) {
-      _internals24.fs.rmSync(worktreePath, { recursive: true, force: true });
-    }
-  } catch {}
+  const rawBase = path31.resolve(_internals24.osTmpdir(), "swarm-ci-simulate");
+  const worktreeBase = _internals24.fs.existsSync(rawBase) ? _internals24.fs.realpathSync(rawBase) : rawBase;
+  const resolved = _internals24.fs.existsSync(worktreePath) ? _internals24.fs.realpathSync(worktreePath) : path31.resolve(worktreePath);
+  const pathEq = _internals24.platform === "win32" ? (a, b) => a.toLowerCase() === b.toLowerCase() : (a, b) => a === b;
+  const pathStartsWith = _internals24.platform === "win32" ? (a, b) => a.toLowerCase().startsWith(b.toLowerCase()) : (a, b) => a.startsWith(b);
+  if (!pathEq(resolved, worktreeBase) && !pathStartsWith(resolved, `${worktreeBase}${path31.sep}`)) {
+    return `[ci-simulate] refusing to clean up non-contained path ${worktreePath}`;
+  }
+  const listResult = await runGit3(["worktree", "list", "--porcelain"], projectRoot);
+  if (listResult.exitCode !== 0) {
+    return `[ci-simulate] could not verify worktree registration: ${listResult.stderr.trim() || listResult.stdout.trim()}`;
+  }
+  const registered = listResult.stdout.split(/\r?\n/).some((line) => {
+    if (!line.startsWith("worktree "))
+      return false;
+    const raw = line.slice("worktree ".length).trim();
+    const canon = _internals24.fs.existsSync(raw) ? _internals24.fs.realpathSync(raw) : path31.resolve(raw);
+    return pathEq(canon, resolved);
+  });
+  if (!registered) {
+    if (!_internals24.fs.existsSync(resolved))
+      return null;
+    return `[ci-simulate] path ${worktreePath} exists but is not a registered git worktree; remove it manually`;
+  }
+  const removeResult = await runGit3(["worktree", "remove", worktreePath], projectRoot);
   if (removeResult.exitCode !== 0) {
+    await runGit3(["worktree", "prune"], projectRoot);
     log(`[ci-simulate] git worktree remove failed: ${removeResult.stderr.trim() || removeResult.stdout.trim()}`);
+    return `[ci-simulate] worktree removal BLOCKED for ${worktreePath}: ${removeResult.stderr.trim() || removeResult.stdout.trim()}. The directory was left in place intentionally \u2014 resolve the block (dirty files or lock) and remove it manually with 'git worktree remove'.`;
   }
+  return null;
 }
 async function runValidationSuite(worktreePath) {
   const steps = [];
@@ -20334,7 +20379,19 @@ function extractFileLineReferences(output) {
   return Array.from(new Set(lines));
 }
 async function handleCiSimulateCommand(directory, args) {
-  const prRef = args[0] ?? await getCurrentBranchOrRef(directory);
+  const baseFlagIndex = args.findIndex((token) => token === "--base");
+  let explicitBase;
+  let positional;
+  if (baseFlagIndex !== -1) {
+    explicitBase = args[baseFlagIndex + 1];
+    if (!explicitBase || !isSafeGitRef(explicitBase)) {
+      return "CI simulation failed: --base must be followed by a safe git branch or commit reference (e.g. --base origin/release-1.x).";
+    }
+    positional = args.slice(0, baseFlagIndex).concat(args.slice(baseFlagIndex + 2));
+  } else {
+    positional = args;
+  }
+  const prRef = positional[0] ?? await getCurrentBranchOrRef(directory);
   if (!isSafeGitRef(prRef)) {
     return "CI simulation failed: PR ref must be a safe git branch or commit reference.";
   }
@@ -20351,9 +20408,29 @@ async function handleCiSimulateCommand(directory, args) {
     steps: []
   };
   try {
-    const baseBranch = _internals24.getDefaultBaseBranch(directory);
-    if (!isSafeGitRef(baseBranch)) {
-      throw new Error("Detected default branch is not a safe git reference.");
+    const detectedBranch = _internals24.detectDefaultRemoteBranch(directory);
+    let baseBranch = null;
+    if (explicitBase) {
+      const verify = await runGit3(["rev-parse", "--verify", "--quiet", explicitBase], directory);
+      if (verify.exitCode !== 0) {
+        throw new Error(`Explicit --base "${explicitBase}" does not resolve in this repository (git rev-parse --verify failed). Fetch it or correct the ref.`);
+      }
+      baseBranch = explicitBase;
+    }
+    if (!baseBranch) {
+      for (const candidate of [detectedBranch, "main", "master"].filter((branch) => Boolean(branch))) {
+        const candidateRef = `origin/${candidate}`;
+        if (!isSafeGitRef(candidateRef))
+          continue;
+        const verify = await runGit3(["rev-parse", "--verify", "--quiet", candidateRef], directory);
+        if (verify.exitCode === 0) {
+          baseBranch = candidateRef;
+          break;
+        }
+      }
+    }
+    if (!baseBranch) {
+      throw new Error("Could not resolve an existing default remote branch (origin/HEAD, init.defaultBranch, origin/main, origin/master). Fetch first, or pass an explicit validated base with --base <ref>.");
     }
     lines.push("## Setup");
     lines.push("");
@@ -20432,8 +20509,16 @@ ${step.stderr}`);
       lines.push("---");
       lines.push("");
       lines.push("*Cleaning up temporary worktree...*");
-      await cleanupWorktree(worktreePath, directory);
-      lines.push(`Worktree removed: \`${worktreePath}\``);
+      const cleanupError = await cleanupWorktree(worktreePath, directory);
+      if (cleanupError) {
+        lines.push("");
+        lines.push(`## \u26A0\uFE0F WORKTREE CLEANUP BLOCKED`);
+        lines.push("");
+        lines.push(cleanupError);
+        result.success = false;
+      } else {
+        lines.push(`Worktree removed: \`${worktreePath}\``);
+      }
     }
   }
   return lines.join(`
@@ -22270,7 +22355,7 @@ function planMerges(active, threshold, maxComparisons, maxMerges) {
   };
 }
 async function sweepActiveNearDuplicates(directory, options = {}) {
-  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-j1xmren9.js");
+  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hfwzxh3j.js");
   const { config } = loadPluginConfigWithMeta2(directory);
   const sweepConfig = config.learning?.dedup_sweep;
   if (sweepConfig?.enabled === false)
@@ -23354,7 +23439,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-q7c6vadg.js");
+        const skillModule = await import("./skill-generator-n8vm1yhn.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -23814,7 +23899,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-7q59skqg.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-gdjnwszd.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -24633,7 +24718,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push("Failed to collect knowledge summary.");
     }
     try {
-      const { getScanStatus } = await import("./scan-cursor-rc8q12ss.js");
+      const { getScanStatus } = await import("./scan-cursor-j8ytdpam.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.`);
@@ -24805,9 +24890,9 @@ var _internals28 = {
   verifyPostMortemKnowledgeActions,
   repairPostMortemActions,
   loadDefaultKnowledgeConfig: async (directory) => {
-    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-n9eaxp3a.js");
+    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-6xfqtpvn.js");
     try {
-      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-j1xmren9.js");
+      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hfwzxh3j.js");
       const loaded = loadPluginConfigWithMeta2(directory);
       return KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
     } catch {
@@ -24815,11 +24900,11 @@ var _internals28 = {
     }
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig, generation) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-3zpdqt9r.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-04xqq68e.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig, generation);
   },
   checkHivePromotions: async (entries, knowledgeConfig, directory) => {
-    const { checkHivePromotions } = await import("./hive-promoter-af5yaxvt.js");
+    const { checkHivePromotions } = await import("./hive-promoter-z09khawt.js");
     return checkHivePromotions(entries, knowledgeConfig, directory);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -24828,7 +24913,7 @@ var _internals28 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-q7c6vadg.js");
+    } = await import("./skill-generator-n8vm1yhn.js");
     const result = {
       approved: [],
       rejected: [],
@@ -25082,52 +25167,59 @@ var _internals29 = {
 init_knowledge_types();
 
 // src/hooks/promotion-evidence-store.ts
-import {
-  appendFile as appendFile5,
-  mkdir as mkdir9,
-  readFile as readFile11,
-  rename as rename5,
-  writeFile as writeFile7
-} from "fs/promises";
 init_logger();
-function resolvePromotionEvidencePath(directory) {
-  return validateSwarmPath(directory, "knowledge-promotion-evidence.jsonl");
+function terminalHistory(membership) {
+  const compatible = membership;
+  const candidates = [
+    ...compatible.terminal_history ?? [],
+    ...compatible.historical_terminals ?? [],
+    ...membership.terminal ? [membership.terminal] : []
+  ];
+  const seen = new Set;
+  return candidates.filter((terminal) => {
+    if (seen.has(terminal.event_id))
+      return false;
+    seen.add(terminal.event_id);
+    return true;
+  });
 }
-function parseRecord(line) {
+async function loadPromotionEvidenceByEntry(directory, canonicalCohortId) {
   try {
-    const o = JSON.parse(line);
-    if (typeof o.cohort_id === "string" && typeof o.entry_id === "string" && typeof o.retrieval_trace_id === "string" && (o.receipt_outcome === "applied" || o.receipt_outcome === "violated" || o.receipt_outcome === "contradicted") && typeof o.receipt_event_id === "string" && typeof o.timestamp === "string") {
-      return o;
+    const history = await _internals30.queryHistoricalOutcomes(directory);
+    if (!history.ok)
+      return {};
+    const out = {};
+    for (const membership of history.memberships) {
+      if (typeof membership.cohort_id !== "string" || membership.cohort_id.length === 0 || canonicalCohortId !== undefined && membership.cohort_id !== canonicalCohortId) {
+        continue;
+      }
+      for (const terminal of terminalHistory(membership)) {
+        if (terminal.outcome !== "applied" && terminal.outcome !== "violated" && terminal.outcome !== "contradicted") {
+          continue;
+        }
+        const record = {
+          cohort_id: membership.cohort_id,
+          source_link_id: membership.source_link_id,
+          entry_id: membership.entry_id,
+          retrieval_trace_id: membership.trace_id,
+          receipt_outcome: terminal.outcome,
+          receipt_event_id: terminal.event_id,
+          phase: membership.phase,
+          timestamp: terminal.committed_at
+        };
+        const bucket = out[record.entry_id];
+        if (bucket)
+          bucket.push(record);
+        else
+          out[record.entry_id] = [record];
+      }
     }
-  } catch {}
-  return null;
-}
-async function loadPromotionEvidenceByEntry(directory) {
-  const filePath = resolvePromotionEvidencePath(directory);
-  let content;
-  try {
-    content = await readFile11(filePath, "utf-8");
+    return out;
   } catch {
     return {};
   }
-  const out = {};
-  for (const line of content.split(`
-`)) {
-    const trimmed = line.trim();
-    if (!trimmed)
-      continue;
-    const rec = parseRecord(trimmed);
-    if (!rec)
-      continue;
-    const bucket = out[rec.entry_id];
-    if (bucket) {
-      bucket.push(rec);
-    } else {
-      out[rec.entry_id] = [rec];
-    }
-  }
-  return out;
 }
+var _internals30 = { queryHistoricalOutcomes };
 
 // src/hooks/hive-promoter.ts
 function carryActionableFields(source) {
@@ -25236,8 +25328,8 @@ async function checkHivePromotions(swarmEntries, config, directory) {
   if (config.hive_enabled === false) {
     return empty;
   }
-  const sourceCohort = await _internals30.resolveCohortId(directory);
-  const evidence2 = await _internals30.loadPromotionEvidence(directory);
+  const sourceCohort = await _internals31.resolveCohortId(directory);
+  const evidence2 = await _internals31.loadPromotionEvidence(directory, sourceCohort.cohortId);
   const diagnostics = [];
   const activeSwarm = swarmEntries.filter((e) => isActiveStatus(e.status));
   const activeSwarmBigrams = activeSwarm.map((e) => typeof e.lesson === "string" ? wordBigrams(e.lesson) : new Set);
@@ -25257,7 +25349,7 @@ async function checkHivePromotions(swarmEntries, config, directory) {
       diagnostics.push(`skip promote '${swarmEntry.lesson.slice(0, 40)}\u2026': ${decision.reason}`);
       continue;
     }
-    const validationResult = _internals30.validateLesson(swarmEntry.lesson, [], {
+    const validationResult = _internals31.validateLesson(swarmEntry.lesson, [], {
       category: swarmEntry.category,
       scope: swarmEntry.scope,
       confidence: swarmEntry.confidence
@@ -25279,7 +25371,7 @@ async function checkHivePromotions(swarmEntries, config, directory) {
     });
   }
   const hiveDir = resolveHiveDataDir();
-  const result = await _internals30.transactHiveStore(async (ctx) => {
+  const result = await _internals31.transactHiveStore(async (ctx) => {
     let newPromotions = 0;
     let encounters = 0;
     let advancements = 0;
@@ -25505,7 +25597,7 @@ async function authorizeAndRecordHiveMerge(args) {
   let authorized = true;
   let basis = "config-skipped-unlinked";
   try {
-    const decision = await _internals30.authorizeCuration({
+    const decision = await _internals31.authorizeCuration({
       directory: hiveDir,
       action: "merge",
       entryId: survivingEntry.id,
@@ -25535,7 +25627,7 @@ async function authorizeAndRecordHiveMerge(args) {
     authorizationBasis: basis
   });
 }
-var _internals30 = {
+var _internals31 = {
   readSwarmEntries: (directory) => readKnowledge(resolveSwarmKnowledgePath(directory)),
   checkHivePromotions,
   readCuratorSummary,
@@ -25544,20 +25636,20 @@ var _internals30 = {
   transactHiveStore,
   validateLesson,
   authorizeCuration,
-  loadPromotionEvidence: async (directory) => loadPromotionEvidenceByEntry(directory),
+  loadPromotionEvidence: async (directory, canonicalCohortId) => loadPromotionEvidenceByEntry(directory, canonicalCohortId),
   loadDefaultKnowledgeConfig: () => KnowledgeConfigSchema.parse({})
 };
 function createHivePromoterHook(directory, config) {
   const hook = async (_input, _output) => {
-    const swarmEntries = await _internals30.readSwarmEntries(directory);
-    const promotionSummary = await _internals30.checkHivePromotions(swarmEntries, config, directory);
-    const curatorSummary = await _internals30.readCuratorSummary(directory);
+    const swarmEntries = await _internals31.readSwarmEntries(directory);
+    const promotionSummary = await _internals31.checkHivePromotions(swarmEntries, config, directory);
+    const curatorSummary = await _internals31.readCuratorSummary(directory);
     if (!curatorSummary)
       return;
     const hasActivity = promotionSummary.new_promotions > 0 || promotionSummary.encounters_incremented > 0 || promotionSummary.advancements > 0;
     if (!hasActivity)
       return;
-    await _internals30.appendCuratorRecommendation(directory, {
+    await _internals31.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({
@@ -25595,16 +25687,16 @@ function normalizeManualActionability(fields) {
 async function promoteToHive(directory, lesson, category, options, config, actionable) {
   const trimmedLesson = lesson.trim();
   const actionableFields = normalizeManualActionability(actionable);
-  const sourceCohort = await _internals30.resolveCohortId(directory);
-  const policyConfig = config ?? _internals30.loadDefaultKnowledgeConfig();
-  const result = await _internals30.transactHiveStore(async (ctx) => {
+  const sourceCohort = await _internals31.resolveCohortId(directory);
+  const policyConfig = config ?? _internals31.loadDefaultKnowledgeConfig();
+  const result = await _internals31.transactHiveStore(async (ctx) => {
     if (findNearDuplicate(trimmedLesson, ctx.entries, policyConfig.dedup_threshold)) {
       return {
         kind: "noop",
         return: `Lesson already exists in hive (near-duplicate).`
       };
     }
-    const validationResult = _internals30.validateLesson(trimmedLesson, ctx.entries.map((e) => e.lesson), {
+    const validationResult = _internals31.validateLesson(trimmedLesson, ctx.entries.map((e) => e.lesson), {
       category: category || "process",
       scope: "global",
       confidence: 1
@@ -25715,16 +25807,16 @@ async function promoteFromSwarm(directory, lessonId, options, config) {
   if (!swarmEntry) {
     throw new Error(`Lesson ${lessonId} not found in .swarm/knowledge.jsonl`);
   }
-  const sourceCohort = await _internals30.resolveCohortId(directory);
-  const policyConfig = config ?? _internals30.loadDefaultKnowledgeConfig();
-  const result = await _internals30.transactHiveStore(async (ctx) => {
+  const sourceCohort = await _internals31.resolveCohortId(directory);
+  const policyConfig = config ?? _internals31.loadDefaultKnowledgeConfig();
+  const result = await _internals31.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 = _internals30.validateLesson(swarmEntry.lesson, ctx.entries.map((e) => e.lesson), {
+    const validationResult = _internals31.validateLesson(swarmEntry.lesson, ctx.entries.map((e) => e.lesson), {
       category: swarmEntry.category,
       scope: swarmEntry.scope,
       confidence: swarmEntry.confidence
@@ -25815,23 +25907,23 @@ async function promoteFromSwarm(directory, lessonId, options, config) {
 import { createHash as createHash9 } from "crypto";
 import { existsSync as existsSync20 } from "fs";
 import {
-  appendFile as appendFile6,
-  mkdir as mkdir11,
-  readFile as readFile13,
+  appendFile as appendFile5,
+  mkdir as mkdir10,
+  readFile as readFile12,
   realpath as realpath2,
-  writeFile as writeFile9
+  writeFile as writeFile8
 } from "fs/promises";
 import * as path41 from "path";
 
 // src/services/synonym-map.ts
 var import_proper_lockfile5 = __toESM(require_proper_lockfile(), 1);
 import {
-  mkdir as mkdir10,
-  readFile as readFile12,
-  rename as rename6,
+  mkdir as mkdir9,
+  readFile as readFile11,
+  rename as rename5,
   stat as stat4,
   unlink as unlink2,
-  writeFile as writeFile8
+  writeFile as writeFile7
 } from "fs/promises";
 import * as path40 from "path";
 var SYNONYM_MAP_FILENAME = "synonym-map.json";
@@ -25981,18 +26073,18 @@ async function readSynonymMap(directory, maxPairs = DEFAULT_MAX_PAIRS) {
     const st = await stat4(filePath);
     if (st.size > ceiling)
       return emptySynonymMap();
-    const raw = await readFile12(filePath, "utf-8");
+    const raw = await readFile11(filePath, "utf-8");
     return coerceSynonymMap(JSON.parse(raw), maxPairs);
   } catch {
     return emptySynonymMap();
   }
 }
 async function writeSynonymMapAtomic(filePath, map) {
-  await mkdir10(path40.dirname(filePath), { recursive: true });
+  await mkdir9(path40.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   try {
-    await writeFile8(tmp, JSON.stringify(map, null, 2), "utf-8");
-    await rename6(tmp, filePath);
+    await writeFile7(tmp, JSON.stringify(map, null, 2), "utf-8");
+    await rename5(tmp, filePath);
   } finally {
     try {
       await unlink2(tmp);
@@ -26002,7 +26094,7 @@ async function writeSynonymMapAtomic(filePath, map) {
 async function rebuildSynonymMap(directory, entries, maxPairs = DEFAULT_MAX_PAIRS) {
   const filePath = resolveSynonymMapPath(directory);
   const dir = path40.dirname(filePath);
-  await mkdir10(dir, { recursive: true });
+  await mkdir9(dir, { recursive: true });
   let release = null;
   try {
     release = await import_proper_lockfile5.default.lock(dir, {
@@ -26053,9 +26145,9 @@ function hashContent(content) {
   return createHash9("sha1").update(content).digest("hex");
 }
 async function loadConfigForPolicyCurator(directory) {
-  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-n9eaxp3a.js");
+  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-6xfqtpvn.js");
   try {
-    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-j1xmren9.js");
+    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hfwzxh3j.js");
     const { config: loadedConfig } = loadPluginConfigWithMeta2(directory);
     return KnowledgeConfigSchema2.parse(loadedConfig.knowledge ?? {});
   } catch {
@@ -26065,7 +26157,7 @@ async function loadConfigForPolicyCurator(directory) {
 async function canonicalExistingPath(candidate) {
   let resolved = path41.resolve(candidate);
   try {
-    resolved = await _internals31.realpath(resolved);
+    resolved = await _internals32.realpath(resolved);
   } catch {}
   return resolved;
 }
@@ -26534,8 +26626,8 @@ RETRY: your last output was missing ${result.missing.join("; ")}; produce valid
 async function appendCuratorSkippedEvent(directory, record) {
   try {
     const filePath = path41.join(directory, ".swarm", "events.jsonl");
-    await mkdir11(path41.dirname(filePath), { recursive: true });
-    await appendFile6(filePath, `${JSON.stringify({
+    await mkdir10(path41.dirname(filePath), { recursive: true });
+    await appendFile5(filePath, `${JSON.stringify({
       timestamp: new Date().toISOString(),
       event: "curator_skipped",
       entry_id: record.entry_id,
@@ -26577,11 +26669,11 @@ async function consumeInsightCandidates(directory, batchLimit = MESO_INSIGHT_BAT
     if (!existsSync20(filePath))
       return [];
     const consumed = [];
-    await transactFile(filePath, async (p) => readInsightJsonl2(await readFile13(p, "utf-8").catch(() => "")), async (p, data) => {
+    await transactFile(filePath, async (p) => readInsightJsonl2(await readFile12(p, "utf-8").catch(() => "")), async (p, data) => {
       const body = data.length === 0 ? "" : `${data.map((c) => JSON.stringify(c)).join(`
 `)}
 `;
-      await writeFile9(p, body, "utf-8");
+      await writeFile8(p, body, "utf-8");
     }, (all) => {
       if (all.length === 0)
         return null;
@@ -26900,9 +26992,9 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
     } catch {}
   }
   if (!options?.skipAutoPromotion) {
-    await _internals31.runAutoPromotion(directory, config);
+    await _internals32.runAutoPromotion(directory, config);
     if (phaseInfo.phase_number > 0) {
-      await _internals31.runAutoDemotion(directory, config, phaseInfo.phase_number);
+      await _internals32.runAutoDemotion(directory, config, phaseInfo.phase_number);
     }
   }
   return { stored, reinforced, skipped, rejected, quarantined };
@@ -26911,7 +27003,7 @@ var OUTCOME_PROMOTION_BLOCK = OUTCOME_BLOCK_THRESHOLD;
 async function runAutoPromotion(directory, config) {
   const knowledgePath = resolveSwarmKnowledgePath(directory);
   const entries = await readKnowledge(knowledgePath) ?? [];
-  const counterRollups = await readKnowledgeCounterRollups(directory);
+  const counterRollups = await readAuthoritativeKnowledgeCounterRollups(directory);
   let changed = false;
   for (const entry of entries) {
     if (entry.status === "promoted")
@@ -26945,7 +27037,7 @@ async function runAutoPromotion(directory, config) {
 async function runAutoDemotion(directory, config, phaseNumber) {
   const knowledgePath = resolveSwarmKnowledgePath(directory);
   const entries = await readKnowledge(knowledgePath) ?? [];
-  const counterRollups = await readKnowledgeCounterRollups(directory);
+  const counterRollups = await readAuthoritativeKnowledgeCounterRollups(directory);
   let changed = false;
   for (const entry of entries) {
     if (entry.status !== "promoted")
@@ -27017,7 +27109,7 @@ function createKnowledgeCuratorHook(directory, config, options = {}) {
         }
         inFlightEvidenceEntries.add(evidenceKey);
         try {
-          await _internals31.curateAndStoreSwarm(batch.lessons, batch.projectName, { phase_number: batch.phaseNumber }, directory, config, {
+          await _internals32.curateAndStoreSwarm(batch.lessons, batch.projectName, { phase_number: batch.phaseNumber }, directory, config, {
             llmDelegate: options.llmDelegateFactory?.(trigger.sessionID),
             enrichmentQuota: options.enrichmentQuota
           });
@@ -27049,14 +27141,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 _internals31.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config, {
+    await _internals32.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config, {
       llmDelegate: options.llmDelegateFactory?.(trigger.sessionID),
       enrichmentQuota: options.enrichmentQuota
     });
   };
   return safeHook(handler);
 }
-var _internals31 = {
+var _internals32 = {
   isWriteToEvidenceFile,
   curateAndStoreSwarm,
   runAutoPromotion,
@@ -27096,7 +27188,7 @@ async function runFinalizeRewardSweep(args) {
     }
     const timestamp = args.timestamp ?? new Date().toISOString();
     const vettedRoot = resolveVettedMemoryRoot(directory, memoryConfig);
-    const provider = _internals32.createConfiguredMemoryProviderForRoot(vettedRoot, memoryConfig);
+    const provider = _internals33.createConfiguredMemoryProviderForRoot(vettedRoot, memoryConfig);
     try {
       result.swept = true;
       for (const taskId of taskIds) {
@@ -27116,7 +27208,7 @@ async function runFinalizeRewardSweep(args) {
         }
         let taskRewarded = 0;
         for (const runId of runIds) {
-          const { memoriesRewarded } = await _internals32.applyCouncilReward(provider, {
+          const { memoriesRewarded } = await _internals33.applyCouncilReward(provider, {
             runId,
             unitId: taskId,
             reward: FINALIZE_NEGATIVE_TERMINAL_REWARD,
@@ -27142,7 +27234,7 @@ async function runFinalizeRewardSweep(args) {
   }
   return result;
 }
-var _internals32 = {
+var _internals33 = {
   createConfiguredMemoryProvider,
   createConfiguredMemoryProviderForRoot,
   applyCouncilReward
@@ -27169,7 +27261,7 @@ async function boundedSessionCall(call, timeoutMs, timeoutLabel, failureLabel, s
       })
     ]);
   } catch (error2) {
-    _internals33.log(`${failureLabel} for ephemeral session`, {
+    _internals34.log(`${failureLabel} for ephemeral session`, {
       sessionId,
       error: error2 instanceof Error ? error2.message : String(error2)
     });
@@ -27181,21 +27273,21 @@ async function boundedSessionCall(call, timeoutMs, timeoutLabel, failureLabel, s
 async function boundedAbortEphemeralSession(session, sessionId, timeoutMs = DEFAULT_EPHEMERAL_ABORT_TIMEOUT_MS) {
   if (typeof session.abort !== "function")
     return;
-  await _internals33.boundedSessionCall(() => session.abort({ path: { id: sessionId } }), timeoutMs, "ephemeral session abort timed out", "ephemeral session abort failed", sessionId);
+  await _internals34.boundedSessionCall(() => session.abort({ path: { id: sessionId } }), timeoutMs, "ephemeral session abort timed out", "ephemeral session abort failed", sessionId);
 }
 async function boundedDeleteEphemeralSession(session, sessionId, timeoutMs = DEFAULT_EPHEMERAL_TEARDOWN_DELETE_TIMEOUT_MS) {
-  await _internals33.boundedSessionCall(() => session.delete({ path: { id: sessionId } }), timeoutMs, "ephemeral session delete timed out", "ephemeral session delete failed", sessionId);
+  await _internals34.boundedSessionCall(() => session.delete({ path: { id: sessionId } }), timeoutMs, "ephemeral session delete timed out", "ephemeral session delete failed", sessionId);
 }
 async function teardownEphemeralSession(session, sessionId, options = {}) {
   const abortTimeoutMs = options.abortTimeoutMs ?? DEFAULT_EPHEMERAL_ABORT_TIMEOUT_MS;
   const deleteTimeoutMs = options.deleteTimeoutMs ?? DEFAULT_EPHEMERAL_TEARDOWN_DELETE_TIMEOUT_MS;
   const skipAbort = options.skipAbort ?? false;
   if (!skipAbort) {
-    await _internals33.boundedAbort(session, sessionId, abortTimeoutMs);
+    await _internals34.boundedAbort(session, sessionId, abortTimeoutMs);
   }
-  await _internals33.boundedDelete(session, sessionId, deleteTimeoutMs);
+  await _internals34.boundedDelete(session, sessionId, deleteTimeoutMs);
 }
-var _internals33 = {
+var _internals34 = {
   boundedSessionCall,
   boundedAbort: boundedAbortEphemeralSession,
   boundedDelete: boundedDeleteEphemeralSession,
@@ -27216,7 +27308,7 @@ function parseModelString(model) {
   };
 }
 var defaultBackoff = (retryAttempt) => 2 ** (retryAttempt - 1) * 1000;
-var defaultSleep = (ms) => new Promise((resolve13) => setTimeout(resolve13, ms));
+var defaultSleep = (ms) => new Promise((resolve14) => setTimeout(resolve14, ms));
 async function dispatchWithModelFallback(opts) {
   const maxRetries = Math.max(0, opts.maxTransientRetriesPerModel ?? 1);
   const backoff = opts.backoffMs ?? defaultBackoff;
@@ -27518,7 +27610,7 @@ function gatherSkillViolations(directory, sessionId) {
   if (!sessionId)
     return [];
   try {
-    const entries = _internals34.readSkillUsageEntriesTail(directory, {
+    const entries = _internals35.readSkillUsageEntriesTail(directory, {
       sessionID: sessionId
     });
     const bySkill = new Map;
@@ -27551,7 +27643,7 @@ async function gatherContradictionCandidates(directory, sessionStart, dedupThres
   if (!Number.isFinite(sessionStartMs))
     return [];
   try {
-    const all = await _internals34.readKnowledge(resolveSwarmKnowledgePath(directory));
+    const all = await _internals35.readKnowledge(resolveSwarmKnowledgePath(directory));
     const sessionCreated = all.filter((e) => {
       if (typeof e.created_at !== "string")
         return false;
@@ -27599,7 +27691,7 @@ async function gatherRealtimeAdmissionCounts(directory, sessionStart) {
   if (!Number.isFinite(sessionStartMs))
     return;
   try {
-    const entries = await _internals34.readKnowledge(resolveSwarmKnowledgePath(directory));
+    const entries = await _internals35.readKnowledge(resolveSwarmKnowledgePath(directory));
     let admitted = 0;
     let reinforced = 0;
     for (const e of entries) {
@@ -27618,7 +27710,7 @@ async function gatherRealtimeAdmissionCounts(directory, sessionStart) {
     }
     let rejected = 0;
     try {
-      const rejectedLessons = await _internals34.readRejectedLessons(directory);
+      const rejectedLessons = await _internals35.readRejectedLessons(directory);
       rejected = rejectedLessons.filter((r) => {
         const ms = Date.parse(r.rejected_at ?? "");
         return Number.isFinite(ms) && ms >= sessionStartMs;
@@ -27914,9 +28006,9 @@ async function runSessionReflection(input) {
   const agentDispatches = gatherAgentDispatches(input.agentSessions);
   const { lessons, taxonomy } = await gatherRetroLessonsAndTaxonomy(input.directory);
   const gateFailures = await gatherGateFailures(input.directory);
-  const skillViolations = _internals34.gatherSkillViolations(input.directory, input.sessionId);
-  const contradictionCandidates = await _internals34.gatherContradictionCandidates(input.directory, input.sessionStart, input.dedupThreshold ?? DEFAULT_DEDUP_THRESHOLD2);
-  const realtimeCounts = await _internals34.gatherRealtimeAdmissionCounts(input.directory, input.sessionStart);
+  const skillViolations = _internals35.gatherSkillViolations(input.directory, input.sessionId);
+  const contradictionCandidates = await _internals35.gatherContradictionCandidates(input.directory, input.sessionStart, input.dedupThreshold ?? DEFAULT_DEDUP_THRESHOLD2);
+  const realtimeCounts = await _internals35.gatherRealtimeAdmissionCounts(input.directory, input.sessionStart);
   const knowledgeDelta = input.knowledgeDelta ? {
     ...input.knowledgeDelta,
     admitted: realtimeCounts?.admitted ?? input.knowledgeDelta.admitted,
@@ -27976,7 +28068,7 @@ async function writeSessionReflection(directory, result) {
   await fs16.writeFile(reflectionPath, content, "utf-8");
   return reflectionPath;
 }
-var _internals34 = {
+var _internals35 = {
   gatherToolProblems,
   gatherAgentDispatches,
   gatherRetroLessonsAndTaxonomy,
@@ -27996,12 +28088,12 @@ var _internals34 = {
 
 // src/services/skill-improver.ts
 import { existsSync as existsSync22 } from "fs";
-import { mkdir as mkdir13, readFile as readFile14, rename as rename7, writeFile as writeFile11 } from "fs/promises";
+import { mkdir as mkdir12, readFile as readFile13, rename as rename6, writeFile as writeFile10 } from "fs/promises";
 import * as path44 from "path";
 init_logger();
 
 // src/services/trajectory-cluster.ts
-import { mkdir as mkdir12, writeFile as writeFile10 } from "fs/promises";
+import { mkdir as mkdir11, writeFile as writeFile9 } from "fs/promises";
 import * as path43 from "path";
 init_logger();
 var MACRO_TRAJECTORY_WINDOW = 200;
@@ -28162,15 +28254,15 @@ async function writeMotifProposals(directory, opts = {}) {
       return result;
     const max = opts.maxProposals ?? 10;
     const selected = motifs.slice(0, max);
-    const producedAt = _internals35.now().toISOString();
+    const producedAt = _internals36.now().toISOString();
     const candidates = selected.map((motif) => buildMotifCandidate(motif, opts.sessionId));
-    const dedupCheck = await _internals35.checkRecommendations(directory, candidates);
+    const dedupCheck = await _internals36.checkRecommendations(directory, candidates);
     const emitted = dedupCheck.decisions.filter((decision) => decision.emit);
     result.duplicatesSuppressed = dedupCheck.decisions.length - emitted.length;
     if (emitted.length === 0)
       return result;
     const proposalsDir = validateSwarmPath(directory, path43.join("skills", "proposals"));
-    await mkdir12(proposalsDir, { recursive: true });
+    await mkdir11(proposalsDir, { recursive: true });
     const written = [];
     for (const decision of emitted) {
       const motif = selected[decision.index];
@@ -28179,14 +28271,14 @@ async function writeMotifProposals(directory, opts = {}) {
         continue;
       const slug = `motif-${slugify(motif.signature)}`;
       const filePath = path43.join(proposalsDir, `${slug}.md`);
-      await writeFile10(filePath, buildMotifProposal(motif, {
+      await writeFile9(filePath, buildMotifProposal(motif, {
         fingerprint: decision.fingerprint,
         producedAt
       }), "utf-8");
       result.proposalsWritten.push(filePath);
       written.push(candidate);
     }
-    await _internals35.recordEmittedRecommendations(directory, written, {
+    await _internals36.recordEmittedRecommendations(directory, written, {
       producedAt
     });
     return result;
@@ -28352,15 +28444,15 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
       return result;
     const max = opts.maxProposals ?? 10;
     const selected = motifs.slice(0, max);
-    const producedAt = _internals35.now().toISOString();
+    const producedAt = _internals36.now().toISOString();
     const candidates = selected.map((motif) => buildWorkflowCandidate(motif, opts.sessionId));
-    const dedupCheck = await _internals35.checkRecommendations(directory, candidates);
+    const dedupCheck = await _internals36.checkRecommendations(directory, candidates);
     const emitted = dedupCheck.decisions.filter((decision) => decision.emit);
     result.duplicatesSuppressed = dedupCheck.decisions.length - emitted.length;
     if (emitted.length === 0)
       return result;
     const proposalsDir = validateSwarmPath(directory, path43.join("skills", "proposals"));
-    await mkdir12(proposalsDir, { recursive: true });
+    await mkdir11(proposalsDir, { recursive: true });
     const written = [];
     for (const decision of emitted) {
       const motif = selected[decision.index];
@@ -28369,14 +28461,14 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
         continue;
       const slug = workflowSlug(motif.signature);
       const filePath = path43.join(proposalsDir, `${slug}.md`);
-      await writeFile10(filePath, buildWorkflowProposal(motif, {
+      await writeFile9(filePath, buildWorkflowProposal(motif, {
         fingerprint: decision.fingerprint,
         producedAt
       }), "utf-8");
       result.proposalsWritten.push(filePath);
       written.push(candidate);
     }
-    await _internals35.recordEmittedRecommendations(directory, written, {
+    await _internals36.recordEmittedRecommendations(directory, written, {
       producedAt
     });
     return result;
@@ -28385,7 +28477,7 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
     return result;
   }
 }
-var _internals35 = {
+var _internals36 = {
   now: () => new Date,
   checkRecommendations,
   recordEmittedRecommendations
@@ -28503,10 +28595,10 @@ function timestampSlug(d) {
   return d.toISOString().replace(/[:.]/g, "-");
 }
 async function atomicWrite(p, content) {
-  await mkdir13(path44.dirname(p), { recursive: true });
+  await mkdir12(path44.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile11(tmp, content, "utf-8");
-  await rename7(tmp, p);
+  await writeFile10(tmp, content, "utf-8");
+  await rename6(tmp, p);
 }
 async function gatherInventory(directory) {
   const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
@@ -28520,7 +28612,7 @@ async function gatherInventory(directory) {
   for (const skill of skills.active) {
     let content;
     try {
-      content = await readFile14(skill.path, "utf-8");
+      content = await readFile13(skill.path, "utf-8");
     } catch {
       continue;
     }
@@ -28696,7 +28788,7 @@ async function reconcileStaleActiveSkills(directory, options = {}) {
   for (const skill of skills.active) {
     let content;
     try {
-      content = await readFile14(skill.path, "utf-8");
+      content = await readFile13(skill.path, "utf-8");
     } catch {
       continue;
     }
@@ -28714,7 +28806,7 @@ async function reconcileStaleActiveSkills(directory, options = {}) {
       continue;
     }
     try {
-      const regen = await _internals36.regenerateSkill(directory, skill.slug, {
+      const regen = await _internals37.regenerateSkill(directory, skill.slug, {
         evaluate: false
       });
       if (regen.regenerated) {
@@ -28970,7 +29062,7 @@ async function runSkillImprover(req) {
     autoApply
   };
 }
-var _internals36 = {
+var _internals37 = {
   runSkillImprover,
   buildDeterministicProposal,
   buildLLMProposalFrame,
@@ -29332,13 +29424,13 @@ var write_retro = createSwarmTool({
         task_id: args.task_id !== undefined ? String(args.task_id) : undefined,
         metadata: args.metadata
       };
-      return await _internals37.executeWriteRetro(writeRetroArgs, directory);
+      return await _internals38.executeWriteRetro(writeRetroArgs, directory);
     } catch {
       return JSON.stringify({ success: false, phase: rawPhase, message: "Invalid arguments" }, null, 2);
     }
   }
 });
-var _internals37 = {
+var _internals38 = {
   executeWriteRetro,
   write_retro
 };
@@ -29351,7 +29443,7 @@ import * as fsSync2 from "fs";
 import path46 from "path";
 var DEFAULT_MAX_SOURCE_BYTES = 2 * 1024 * 1024 * 1024;
 var DEFAULT_BUSY_TIMEOUT_MS = 5000;
-var _internals38 = {
+var _internals39 = {
   existsSync: fsSync2.existsSync,
   statSync: fsSync2.statSync,
   renameSync: fsSync2.renameSync,
@@ -29361,11 +29453,11 @@ var _internals38 = {
   DatabaseCtor: null
 };
 function resolveDatabaseCtor() {
-  return _internals38.DatabaseCtor ?? loadDatabaseCtor();
+  return _internals39.DatabaseCtor ?? loadDatabaseCtor();
 }
 function safeRemoveTemp(tempPath) {
   try {
-    _internals38.rmSync(tempPath, {
+    _internals39.rmSync(tempPath, {
       force: true,
       recursive: true,
       maxRetries: 3,
@@ -29421,7 +29513,7 @@ function captureRowCounts(db) {
 async function archiveSqliteSnapshot(opts) {
   const maxSourceBytes = opts.maxSourceBytes ?? DEFAULT_MAX_SOURCE_BYTES;
   const busyTimeoutMs = opts.busyTimeoutMs ?? DEFAULT_BUSY_TIMEOUT_MS;
-  if (!_internals38.existsSync(opts.sourcePath)) {
+  if (!_internals39.existsSync(opts.sourcePath)) {
     return {
       requiredness: "required",
       attempt: "not_attempted",
@@ -29434,10 +29526,10 @@ async function archiveSqliteSnapshot(opts) {
   let sourceBytes = 0;
   for (const suffix of ["", "-wal", "-shm"]) {
     const sidecar = opts.sourcePath + suffix;
-    if (!_internals38.existsSync(sidecar))
+    if (!_internals39.existsSync(sidecar))
       continue;
     try {
-      sourceBytes += _internals38.statSync(sidecar).size;
+      sourceBytes += _internals39.statSync(sidecar).size;
     } catch (err) {
       if (suffix === "") {
         return {
@@ -29464,7 +29556,7 @@ async function archiveSqliteSnapshot(opts) {
     };
   }
   const destFinal = path46.join(opts.destDir, opts.destName);
-  const destTemp = path46.join(opts.destDir, `.${opts.destName}.tmp.${_internals38.now()}.${_internals38.randomSuffix()}`);
+  const destTemp = path46.join(opts.destDir, `.${opts.destName}.tmp.${_internals39.now()}.${_internals39.randomSuffix()}`);
   let Db;
   try {
     Db = resolveDatabaseCtor();
@@ -29563,7 +29655,7 @@ async function archiveSqliteSnapshot(opts) {
     };
   }
   try {
-    _internals38.renameSync(destTemp, destFinal);
+    _internals39.renameSync(destTemp, destFinal);
   } catch (err) {
     safeRemoveTemp(destTemp);
     return {
@@ -29590,6 +29682,10 @@ async function archiveSqliteSnapshot(opts) {
 }
 
 // src/commands/close.ts
+var closeReceiptLifecycleInternals = {
+  recordPhaseCloseIntent,
+  reconcilePhaseClose
+};
 var CLOSE_SKILL_REVIEW_TIMEOUT_MS = 120000;
 var CLOSE_REFLECTION_TIMEOUT_MS = 90000;
 async function runAbortableReflection(input, timeoutMs) {
@@ -29699,6 +29795,9 @@ var ARCHIVE_ARTIFACTS = [
   "close-lessons.md",
   "knowledge.jsonl",
   "knowledge-rejected.jsonl",
+  "knowledge-receipts-v2.jsonl",
+  "knowledge-receipts-v2.snapshot.json",
+  "knowledge-receipts-v2-archive.jsonl",
   "run-memory.jsonl",
   "repo-graph.json",
   "doc-manifest.json",
@@ -29929,8 +30028,8 @@ async function runFinalizeStage(ctx) {
   ];
   ctx.curationSucceeded = false;
   try {
-    ctx.curationResult = await _internals39.curateAndStoreSwarm(ctx.allLessons, ctx.projectName, { phase_number: 0 }, ctx.directory, ctx.config, {
-      llmDelegate: _internals39.createCuratorLLMDelegate(ctx.directory, "phase", ctx.options.sessionID),
+    ctx.curationResult = await _internals40.curateAndStoreSwarm(ctx.allLessons, ctx.projectName, { phase_number: 0 }, ctx.directory, ctx.config, {
+      llmDelegate: _internals40.createCuratorLLMDelegate(ctx.directory, "phase", ctx.options.sessionID),
       enrichmentQuota: {
         maxCalls: ctx.config.enrichment.max_calls_per_day,
         window: ctx.config.enrichment.quota_window
@@ -29949,7 +30048,7 @@ async function runFinalizeStage(ctx) {
     if (ctx.config.hive_enabled === false) {} else {
       try {
         const entries = await readKnowledge(resolveSwarmKnowledgePath(ctx.directory));
-        const result = await _internals39.checkHivePromotions(entries, ctx.config, ctx.directory);
+        const result = await _internals40.checkHivePromotions(entries, ctx.config, ctx.directory);
         ctx.hivePromoted = result.new_promotions;
       } catch (hiveErr) {
         const msg = hiveErr instanceof Error ? hiveErr.message : String(hiveErr);
@@ -29970,7 +30069,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 } = _internals39.loadPluginConfigWithMeta(ctx.directory);
+      const { config: loadedConfig } = _internals40.loadPluginConfigWithMeta(ctx.directory);
       const skillImproverConfig = SkillImproverConfigSchema.parse(loadedConfig.skill_improver ?? {});
       const skillReviewResult = await runAbortableSkillReview({
         directory: ctx.directory,
@@ -30035,6 +30134,22 @@ async function runFinalizeStage(ctx) {
     const planDataSnapshot = structuredClone(ctx.planData);
     const closedPhasesLenBefore = ctx.closedPhases.length;
     const closedTasksLenBefore = ctx.closedTasks.length;
+    const receiptPhaseLabels = new Map;
+    for (const phase of ctx.planData.phases ?? []) {
+      const label = extractCurrentPhaseFromPlan({
+        ...ctx.planData,
+        current_phase: phase.id
+      }) ?? `Phase ${phase.id}`;
+      receiptPhaseLabels.set(phase.id, label);
+      const intent = await closeReceiptLifecycleInternals.recordPhaseCloseIntent(ctx.directory, label, ctx.options.sessionID);
+      if (!intent.ok) {
+        if (intent.detail === "no exact receipt lifecycle scope exists for phase closure") {
+          continue;
+        }
+        ctx.warnings.push(`Receipt phase-close intent failed for phase ${phase.id}: ${intent.detail}. Plan terminalization was not attempted.`);
+        return;
+      }
+    }
     ctx.guaranteeResult = guaranteeAllPlansComplete(ctx.planData);
     for (const phaseId of ctx.guaranteeResult.closedPhaseIds) {
       if (!ctx.closedPhases.includes(phaseId)) {
@@ -30046,13 +30161,15 @@ async function runFinalizeStage(ctx) {
         ctx.closedTasks.push(taskId);
       }
     }
+    let terminalPlanPersisted = ctx.planAlreadyDone;
     if (!ctx.planAlreadyDone || ctx.guaranteeResult.closedPhaseIds.length > 0 || ctx.guaranteeResult.closedTaskIds.length > 0) {
       try {
-        await _internals39.closePlanTerminalState(ctx.directory, ctx.planData, {
+        await _internals40.closePlanTerminalState(ctx.directory, ctx.planData, {
           closedPhaseIds: ctx.guaranteeResult.closedPhaseIds,
           closedTaskIds: ctx.guaranteeResult.closedTaskIds,
           originalStatuses: ctx.originalStatuses
         });
+        terminalPlanPersisted = true;
       } catch (error2) {
         const msg = error2 instanceof Error ? error2.message : String(error2);
         ctx.warnings.push(`Failed to persist terminal plan state: ${msg}`);
@@ -30062,14 +30179,20 @@ async function runFinalizeStage(ctx) {
         ctx.closedTasks.length = closedTasksLenBefore;
       }
     }
+    for (const phase of terminalPlanPersisted ? ctx.planData.phases ?? [] : []) {
+      const reconciled = await closeReceiptLifecycleInternals.reconcilePhaseClose(ctx.directory, receiptPhaseLabels.get(phase.id) ?? `Phase ${phase.id}`, true, ctx.options.sessionID);
+      if (!reconciled.ok) {
+        ctx.warnings.push(`Receipt phase-close reconciliation remains pending for phase ${phase.id}: ${reconciled.detail}`);
+      }
+    }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-n9eaxp3a.js");
-    const { config: pmLoadedConfig } = _internals39.loadPluginConfigWithMeta(ctx.directory);
+    const { CuratorConfigSchema: CCS } = await import("./schema-6xfqtpvn.js");
+    const { config: pmLoadedConfig } = _internals40.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
-      const pmResult = await _internals39.runCuratorPostMortem(ctx.directory, {
-        llmDelegate: _internals39.createCuratorLLMDelegate(ctx.directory, "postmortem", ctx.options.sessionID),
+      const pmResult = await _internals40.runCuratorPostMortem(ctx.directory, {
+        llmDelegate: _internals40.createCuratorLLMDelegate(ctx.directory, "postmortem", ctx.options.sessionID),
         scope: "project",
         sessionID: ctx.options.sessionID
       });
@@ -30092,7 +30215,7 @@ async function runArchiveStage(ctx) {
   try {
     await fs17.mkdir(ctx.archiveDir, { recursive: true });
     try {
-      await _internals39.flushAndDrainTelemetry();
+      await _internals40.flushAndDrainTelemetry();
     } catch (flushErr) {
       const msg = flushErr instanceof Error ? flushErr.message : String(flushErr);
       ctx.warnings.push(`Telemetry flush before archive failed: ${msg}`);
@@ -30271,7 +30394,7 @@ async function runArchiveEvidenceRetention(ctx) {
   let cacheMaxBytes;
   let cacheMaxRecords;
   try {
-    const { config: evidenceLoadedConfig } = _internals39.loadPluginConfigWithMeta(ctx.directory);
+    const { config: evidenceLoadedConfig } = _internals40.loadPluginConfigWithMeta(ctx.directory);
     const evidenceCfg = evidenceLoadedConfig.evidence ?? {};
     if (typeof evidenceCfg.max_age_days === "number") {
       maxAgeDays = evidenceCfg.max_age_days;
@@ -30287,7 +30410,7 @@ async function runArchiveEvidenceRetention(ctx) {
     }
   } catch {}
   try {
-    await _internals39.archiveEvidence(ctx.directory, maxAgeDays, maxBundles, {
+    await _internals40.archiveEvidence(ctx.directory, maxAgeDays, maxBundles, {
       report: true,
       cacheMaxBytes,
       cacheMaxRecords
@@ -30500,9 +30623,9 @@ async function runAlignStage(ctx) {
   const pruneBranches = ctx.args.includes("--prune-branches");
   let gitAlignResult = "";
   const prunedBranches = [];
-  const gitStatus = _internals39.getGitRepositoryStatus(ctx.directory);
+  const gitStatus = _internals40.getGitRepositoryStatus(ctx.directory);
   if (gitStatus.isRepo) {
-    const aggressiveResult = await _internals39.resetToMainAfterMerge(ctx.directory, {
+    const aggressiveResult = await _internals40.resetToMainAfterMerge(ctx.directory, {
       pruneBranches
     });
     if (aggressiveResult.success) {
@@ -30514,7 +30637,7 @@ async function runAlignStage(ctx) {
         ctx.warnings.push("Uncommitted changes were discarded during git alignment");
       }
     } else {
-      const alignResult = await _internals39.resetToRemoteBranch(ctx.directory, {
+      const alignResult = await _internals40.resetToRemoteBranch(ctx.directory, {
         pruneBranches
       });
       gitAlignResult = alignResult.message;
@@ -30550,7 +30673,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 = _internals39.getGitRepositoryStatus(directory);
+  const gitStatus = _internals40.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)",
@@ -30622,12 +30745,12 @@ async function handleCloseCommand(directory, args, options = {}) {
     }
   }
   if (args.includes("--dry-run")) {
-    return _internals39.runFinalizeDryRun(directory, swarmDir, planData, planExists);
+    return _internals40.runFinalizeDryRun(directory, swarmDir, planData, planExists);
   }
   let finalizeLock = {
     acquired: false
   };
-  finalizeLock = await _internals39.acquireFinalizeLock(directory);
+  finalizeLock = await _internals40.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.`;
   }
@@ -30658,7 +30781,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 } = _internals39.loadPluginConfigWithMeta(directory);
+    const { config: loadedConfig } = _internals40.loadPluginConfigWithMeta(directory);
     const config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     const ctx = {
       directory,
@@ -30707,9 +30830,9 @@ This project was already finalized in a previous /swarm close run. The plan has
       archiveSuffix: "",
       args
     };
-    ctx.fullAuto = options.sessionID ? _internals39.detectFullAuto(directory, options.sessionID) : false;
+    ctx.fullAuto = options.sessionID ? _internals40.detectFullAuto(directory, options.sessionID) : false;
     await runFinalizeStage(ctx);
-    await _internals39.runFinalizeRewardSweep({
+    await _internals40.runFinalizeRewardSweep({
       directory,
       closedTaskIds: ctx.guaranteeResult.closedTaskIds,
       memoryConfig: loadedConfig.memory
@@ -30793,9 +30916,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) {
-        _internals39.endAgentSession(sessionId);
+        _internals40.endAgentSession(sessionId);
       }
-      _internals39.resetSwarmStatePreservingSingletons();
+      _internals40.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}`);
@@ -30892,7 +31015,7 @@ function detectFullAuto(directory, sessionID) {
     return false;
   }
 }
-var _internals39 = {
+var _internals40 = {
   ACTIVE_STATE_DIRS_TO_CLEAN,
   countSessionKnowledgeEntries,
   CLOSE_SKILL_REVIEW_TIMEOUT_MS,
@@ -30921,7 +31044,7 @@ var _internals39 = {
   closePlanTerminalState,
   endAgentSession,
   flushAndDrainTelemetry: async () => {
-    const { flushAndDrainTelemetry } = await import("./telemetry-sc57xtb0.js");
+    const { flushAndDrainTelemetry } = await import("./telemetry-fb44gpba.js");
     return flushAndDrainTelemetry();
   }
 };
@@ -31187,7 +31310,7 @@ init_schema();
 
 // src/services/skill-consolidation.ts
 import { existsSync as existsSync26 } from "fs";
-import { mkdir as mkdir14, readFile as readFile15, rename as rename8, writeFile as writeFile12 } from "fs/promises";
+import { mkdir as mkdir13, readFile as readFile14, rename as rename7, writeFile as writeFile11 } from "fs/promises";
 import * as path49 from "path";
 var DEFAULT_CONSOLIDATION_INTERVAL_HOURS = 24;
 var DEFAULT_CONSOLIDATION_MAX_CALLS_PER_RUN = 1;
@@ -31201,7 +31324,7 @@ async function readState2(directory) {
   if (!existsSync26(filePath))
     return {};
   try {
-    const parsed = JSON.parse(await readFile15(filePath, "utf-8"));
+    const parsed = JSON.parse(await readFile14(filePath, "utf-8"));
     if (!parsed || typeof parsed !== "object")
       return {};
     return parsed;
@@ -31210,10 +31333,10 @@ async function readState2(directory) {
   }
 }
 async function atomicWrite2(filePath, content) {
-  await mkdir14(path49.dirname(filePath), { recursive: true });
+  await mkdir13(path49.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile12(tmp, content, "utf-8");
-  await rename8(tmp, filePath);
+  await writeFile11(tmp, content, "utf-8");
+  await rename7(tmp, filePath);
 }
 async function writeState2(directory, state) {
   await atomicWrite2(consolidationStatePath(directory), `${JSON.stringify(state, null, 2)}
@@ -31388,7 +31511,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 _internals40 = {
+var _internals41 = {
   appendFileSync: fs18.appendFileSync,
   readFileSync: fs18.readFileSync,
   existsSync: fs18.existsSync,
@@ -31401,10 +31524,10 @@ function readTelemetry(directory) {
   const filePath = telemetryFilePath(directory);
   const entries = [];
   try {
-    if (!_internals40.existsSync(filePath)) {
+    if (!_internals41.existsSync(filePath)) {
       return entries;
     }
-    const raw = _internals40.readFileSync(filePath, "utf-8");
+    const raw = _internals41.readFileSync(filePath, "utf-8");
     const lines = raw.split(`
 `);
     for (const line of lines) {
@@ -31619,7 +31742,7 @@ import { promisify as promisify2 } from "util";
 init_zod();
 import * as child_process3 from "child_process";
 import { randomUUID as randomUUID7 } from "crypto";
-import { readdir as readdir3, readFile as readFile16, stat as stat5 } from "fs/promises";
+import { readdir as readdir3, readFile as readFile15, stat as stat5 } from "fs/promises";
 import * as path51 from "path";
 import { promisify } from "util";
 function getExecFileAsync() {
@@ -31746,7 +31869,7 @@ async function getStaticEdges(directory) {
   const sourceFiles = await scanSourceFiles(directory);
   for (const sourceFile of sourceFiles) {
     try {
-      const content = await readFile16(sourceFile, "utf-8");
+      const content = await readFile15(sourceFile, "utf-8");
       const importRegex = /(?:import|require)\s*(?:\(?\s*['"`]|.*?from\s+['"`])([^'"`]+)['"`]/g;
       for (let match = importRegex.exec(content);match !== null; match = importRegex.exec(content)) {
         const importPath = match[1].trim();
@@ -31841,9 +31964,9 @@ async function detectDarkMatter(directory, options) {
   } catch {
     return [];
   }
-  const commitMap = await _internals41.parseGitLog(directory, maxCommitsToAnalyze);
-  const matrix = _internals41.buildCoChangeMatrix(commitMap, maxFilesPerCommit);
-  const staticEdges = await _internals41.getStaticEdges(directory);
+  const commitMap = await _internals42.parseGitLog(directory, maxCommitsToAnalyze);
+  const matrix = _internals42.buildCoChangeMatrix(commitMap, maxFilesPerCommit);
+  const staticEdges = await _internals42.getStaticEdges(directory);
   const results = [];
   for (const entry of matrix.values()) {
     const key = `${entry.fileA}::${entry.fileB}`;
@@ -31959,11 +32082,11 @@ var co_change_analyzer = createSwarmTool({
       npmiThreshold,
       maxCommitsToAnalyze
     };
-    const pairs = await _internals41.detectDarkMatter(directory, options);
-    return _internals41.formatDarkMatterOutput(pairs);
+    const pairs = await _internals42.detectDarkMatter(directory, options);
+    return _internals42.formatDarkMatterOutput(pairs);
   }
 });
-var _internals41 = {
+var _internals42 = {
   parseGitLog,
   buildCoChangeMatrix,
   getStaticEdges,
@@ -31980,7 +32103,7 @@ var DEFAULT_MAX_COMMITS = 500;
 var cache = new Map;
 async function readGitHead(directory) {
   try {
-    const { stdout } = await _internals42.execFile("git", ["rev-parse", "HEAD"], {
+    const { stdout } = await _internals43.execFile("git", ["rev-parse", "HEAD"], {
       cwd: directory,
       timeout: GIT_HEAD_TIMEOUT_MS
     });
@@ -32006,9 +32129,9 @@ async function getCoChangeData(directory, options) {
   let entries;
   let commitsObserved;
   try {
-    const commitMap = await _internals42.parseGitLog(directory, maxCommits);
+    const commitMap = await _internals43.parseGitLog(directory, maxCommits);
     commitsObserved = commitMap.size;
-    const matrix = _internals42.buildCoChangeMatrix(commitMap);
+    const matrix = _internals43.buildCoChangeMatrix(commitMap);
     entries = Array.from(matrix.values());
   } catch {
     return { pairs: [], commitsObserved: 0 };
@@ -32032,10 +32155,10 @@ async function getCoChangePairs(directory, options) {
   const data = await getCoChangeData(directory, options);
   return data.pairs;
 }
-var _internals42 = {
+var _internals43 = {
   execFile: execFileAsync,
-  parseGitLog: _internals41.parseGitLog,
-  buildCoChangeMatrix: _internals41.buildCoChangeMatrix
+  parseGitLog: _internals42.parseGitLog,
+  buildCoChangeMatrix: _internals42.buildCoChangeMatrix
 };
 
 // src/turbo/epic/coupling-report.ts
@@ -32259,7 +32382,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 _internals43.loadPlanJsonOnly(directory);
+  const plan = await _internals44.loadPlanJsonOnly(directory);
   if (plan === null) {
     return "No plan found at `.swarm/plan.json`. Run `/swarm plan` to create one before measuring coupling.";
   }
@@ -32283,7 +32406,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 _internals43.getCoChangePairs(directory);
+  const cochangePairs = await _internals44.getCoChangePairs(directory);
   const report = computeCouplingReport(tasks, cochangePairs, {
     npmi: parsed.threshold,
     minCoChanges: parsed.minCoChanges
@@ -32322,14 +32445,14 @@ _Warning: failed to persist report (${persistStatus.error})._`;
   }
   return `${formatCouplingReportMarkdown(report)}${persistTrailer}`;
 }
-var _internals43 = {
+var _internals44 = {
   loadPlanJsonOnly,
   getCoChangePairs
 };
 
 // src/commands/curate.ts
 init_schema();
-var _internals44 = {
+var _internals45 = {
   checkHivePromotions,
   readKnowledge,
   resolveSwarmKnowledgePath,
@@ -32337,9 +32460,9 @@ var _internals44 = {
   loadPluginConfigWithMeta,
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
-      import("./schema-n9eaxp3a.js"),
-      import("./curator-3zpdqt9r.js"),
-      import("./curator-llm-factory-2h0xb62t.js")
+      import("./schema-6xfqtpvn.js"),
+      import("./curator-04xqq68e.js"),
+      import("./curator-llm-factory-cfm8fhdw.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -32348,20 +32471,20 @@ async function handleCurateCommand(directory, _args, options) {
   try {
     let config;
     try {
-      const { config: loadedConfig } = _internals44.loadPluginConfigWithMeta(directory);
+      const { config: loadedConfig } = _internals45.loadPluginConfigWithMeta(directory);
       config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     } catch {
       config = KnowledgeConfigSchema.parse({});
     }
-    const swarmPath = _internals44.resolveSwarmKnowledgePath(directory);
-    const swarmEntries = await _internals44.readKnowledge(swarmPath) ?? [];
-    const summary = await _internals44.checkHivePromotions(swarmEntries, config, directory);
+    const swarmPath = _internals45.resolveSwarmKnowledgePath(directory);
+    const swarmEntries = await _internals45.readKnowledge(swarmPath) ?? [];
+    const summary = await _internals45.checkHivePromotions(swarmEntries, config, directory);
     if (options?.sessionID) {
       let onDemandPhase = 1;
       try {
-        const { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 } = await _internals44.loadCuratorDeps();
+        const { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 } = await _internals45.loadCuratorDeps();
         const curatorConfig = CuratorConfigSchema.parse({});
-        const priorSummary = await _internals44.readSwarmFileAsync(directory, "curator-summary.json");
+        const priorSummary = await _internals45.readSwarmFileAsync(directory, "curator-summary.json");
         if (priorSummary) {
           try {
             const parsed = JSON.parse(priorSummary);
@@ -32372,7 +32495,7 @@ async function handleCurateCommand(directory, _args, options) {
         }
         let planPhaseCount = Infinity;
         try {
-          const planRaw = await _internals44.readSwarmFileAsync(directory, "plan.json");
+          const planRaw = await _internals45.readSwarmFileAsync(directory, "plan.json");
           if (planRaw) {
             const plan = JSON.parse(planRaw);
             if (Array.isArray(plan.phases))
@@ -32391,8 +32514,8 @@ async function handleCurateCommand(directory, _args, options) {
           summary.knowledge_skipped = applied.skipped;
           summary.curator_phase = onDemandPhase;
           try {
-            const updatedEntries = await _internals44.readKnowledge(swarmPath) ?? [];
-            const postUpdateHive = await _internals44.checkHivePromotions(updatedEntries, config, directory);
+            const updatedEntries = await _internals45.readKnowledge(swarmPath) ?? [];
+            const postUpdateHive = await _internals45.checkHivePromotions(updatedEntries, config, directory);
             summary.new_promotions += postUpdateHive.new_promotions;
             summary.encounters_incremented += postUpdateHive.encounters_incremented;
             summary.advancements += postUpdateHive.advancements;
@@ -32458,7 +32581,7 @@ async function handleDarkMatterCommand(directory, args) {
   }
   let pairs;
   try {
-    pairs = await _internals41.detectDarkMatter(directory, options);
+    pairs = await _internals42.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Dark Matter Analysis Failed
@@ -32723,7 +32846,7 @@ ${USAGE7}`;
 // src/commands/design-docs.ts
 init_warning_buffer();
 var MAX_DESC_LEN = 2000;
-var _internals45 = { loadPluginConfigWithMeta };
+var _internals46 = { 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:
@@ -32819,7 +32942,7 @@ async function handleDesignDocsCommand(directory, args) {
 ${USAGE8}`;
   }
   try {
-    const { config } = _internals45.loadPluginConfigWithMeta(directory);
+    const { config } = _internals46.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.
 
@@ -32895,7 +33018,7 @@ init_executor();
 // src/services/knowledge-diagnostics.ts
 init_package();
 import { existsSync as existsSync29, readFileSync as readFileSync19 } from "fs";
-import { readFile as readFile17 } from "fs/promises";
+import { readFile as readFile16 } from "fs/promises";
 import { join as join42 } from "path";
 
 // src/services/version-check.ts
@@ -32972,7 +33095,7 @@ var INSIGHT_BACKLOG_WARN = 50;
 async function readRawLines(filePath) {
   if (!existsSync29(filePath))
     return { entries: [], corrupt: 0 };
-  const content = await readFile17(filePath, "utf-8");
+  const content = await readFile16(filePath, "utf-8");
   const entries = [];
   let corrupt = 0;
   for (const line of content.split(`
@@ -33244,7 +33367,7 @@ async function computeCurationDiagnostics(directory, entries) {
   let scanCompleted = false;
   let scanRemaining = 0;
   try {
-    const { getScanStatus } = await import("./scan-cursor-rc8q12ss.js");
+    const { getScanStatus } = await import("./scan-cursor-j8ytdpam.js");
     const status = await getScanStatus(directory);
     scanGeneration = status.generation;
     scanCompleted = status.completed;
@@ -33252,19 +33375,19 @@ async function computeCurationDiagnostics(directory, entries) {
   } catch {}
   let configMatch = null;
   try {
-    const { isLinked: isLinked2 } = await import("./knowledge-link-q46k9adx.js");
+    const { isLinked: isLinked2 } = await import("./knowledge-link-axx45d1h.js");
     if (isLinked2(directory)) {
-      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-n9eaxp3a.js");
+      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-6xfqtpvn.js");
       let config;
       try {
-        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-j1xmren9.js");
+        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hfwzxh3j.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-d52h4g8t.js");
+      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-9291bdat.js");
       const currentFp = cohortConfigFingerprint2(buildConfigFingerprintInput2(config));
       const cohortFp = await readCohortConfigFingerprint(directory);
       configMatch = cohortFp === null ? null : currentFp === cohortFp;
@@ -33299,7 +33422,7 @@ async function countPendingProposals(directory) {
   if (!existsSync29(proposalsPath))
     return 0;
   try {
-    const content = await readFile17(proposalsPath, "utf-8");
+    const content = await readFile16(proposalsPath, "utf-8");
     let n = 0;
     for (const line of content.split(`
 `)) {
@@ -33321,7 +33444,7 @@ async function safeJsonlCount(filePath) {
   if (!filePath || !existsSync29(filePath))
     return 0;
   try {
-    const content = await readFile17(filePath, "utf-8");
+    const content = await readFile16(filePath, "utf-8");
     let n = 0;
     for (const line of content.split(`
 `)) {
@@ -33426,7 +33549,7 @@ function resolveCachePackageRoot(cachePath) {
   const nestedPackageRoot = path55.join(cachePath, "node_modules", "opencode-swarm");
   return existsSync30(nestedPackageRoot) ? nestedPackageRoot : cachePath;
 }
-var _internals46 = {
+var _internals47 = {
   detectSandboxCapability: () => sandboxCapabilityProbe.detect(),
   getSandboxExecutor: getExecutor
 };
@@ -34010,9 +34133,9 @@ async function checkCurator(directory) {
 }
 async function getSandboxStatus() {
   try {
-    const capability = await _internals46.detectSandboxCapability();
+    const capability = await _internals47.detectSandboxCapability();
     const mechanism = capability.mechanism ?? "none";
-    const executor = await _internals46.getSandboxExecutor();
+    const executor = await _internals47.getSandboxExecutor();
     const hasExecutor = executor !== null;
     if (hasExecutor) {
       const executorStrength = executor?.strength;
@@ -34475,7 +34598,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-fnmfd35x.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-qqe6172n.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true, {
       applyLossy: true
     });
@@ -34820,7 +34943,7 @@ function readPromotionEvidence(directory) {
 }
 
 // src/commands/epic.ts
-var _internals47 = {
+var _internals48 = {
   loadPluginConfigWithMeta,
   loadPlanJsonOnly,
   getCoChangeData,
@@ -34842,7 +34965,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 = _internals47.ensureAgentSession(sessionID, undefined, directory);
+  const session = _internals48.ensureAgentSession(sessionID, undefined, directory);
   const arg0 = args[0]?.toLowerCase();
   switch (arg0) {
     case "status":
@@ -34869,7 +34992,7 @@ Usage:
 }
 function enableAndAck(directory, sessionID, session) {
   try {
-    _internals47.enableEpicMode(directory, sessionID);
+    _internals48.enableEpicMode(directory, sessionID);
   } catch (err) {
     return `Error enabling Epic Mode: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -34885,7 +35008,7 @@ function enableAndAck(directory, sessionID, session) {
 }
 function disableAndAck(directory, sessionID, session) {
   try {
-    _internals47.disableEpicMode(directory, sessionID);
+    _internals48.disableEpicMode(directory, sessionID);
   } catch (err) {
     return `Error disabling Epic Mode: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -34894,12 +35017,12 @@ function disableAndAck(directory, sessionID, session) {
 }
 function renderStatus(directory, sessionID) {
   const lines = ["## Epic Mode \u2014 Status", ""];
-  if (_internals47.isStateUnreadable(directory)) {
+  if (_internals48.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 = _internals47.loadEpicSessionState(directory, sessionID);
+  const state = _internals48.loadEpicSessionState(directory, sessionID);
   if (!state) {
     lines.push("Epic Mode has not been toggled for this session.");
     return lines.join(`
@@ -34951,7 +35074,7 @@ function formatGreenfieldDetail(input) {
 function renderLast(directory) {
   let records;
   try {
-    records = _internals47.readPromotionEvidence(directory);
+    records = _internals48.readPromotionEvidence(directory);
   } catch (err) {
     return `Error reading epic-promotions.jsonl: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -35006,7 +35129,7 @@ function renderLast(directory) {
 `);
 }
 function renderCalibration(directory) {
-  if (_internals47.isCalibrationStateUnreadable(directory)) {
+  if (_internals48.isCalibrationStateUnreadable(directory)) {
     return [
       "## Epic Mode \u2014 Calibration",
       "",
@@ -35018,11 +35141,11 @@ function renderCalibration(directory) {
   }
   let state;
   try {
-    state = _internals47.loadCalibrationState(directory);
+    state = _internals48.loadCalibrationState(directory);
   } catch (err) {
     return `Error reading calibration state: ${err instanceof Error ? err.message : String(err)}`;
   }
-  const { config } = _internals47.loadPluginConfigWithMeta(directory);
+  const { config } = _internals48.loadPluginConfigWithMeta(directory);
   const staticThreshold = config.turbo?.epic?.mode?.activation_threshold ?? 0.3;
   const calibrationCfg = config.turbo?.epic?.calibration;
   const loosenWindow = calibrationCfg?.loosen_window ?? 10;
@@ -35070,7 +35193,7 @@ function renderCalibration(directory) {
   lines.push("");
   let recentDivergent = [];
   try {
-    const all = _internals47.readDivergenceHistory(directory, { limit: 50 });
+    const all = _internals48.readDivergenceHistory(directory, { limit: 50 });
     recentDivergent = all.filter((r) => !r.isClean).slice(-5);
   } catch {}
   lines.push("### Recent divergent tasks (tightened the threshold)");
@@ -35087,11 +35210,11 @@ function renderCalibration(directory) {
 `);
 }
 async function renderDecide(directory) {
-  const plan = await _internals47.loadPlanJsonOnly(directory);
+  const plan = await _internals48.loadPlanJsonOnly(directory);
   if (!plan) {
     return "No plan found at `.swarm/plan.json`. Run `/swarm plan` first.";
   }
-  const { config } = _internals47.loadPluginConfigWithMeta(directory);
+  const { config } = _internals48.loadPluginConfigWithMeta(directory);
   const modeCfg = config.turbo?.epic?.mode;
   const cochangeCfg = config.turbo?.epic?.cochange;
   const activationThreshold = modeCfg?.activation_threshold ?? 0.3;
@@ -35101,20 +35224,20 @@ async function renderDecide(directory) {
   const tasks = [];
   for (const phase of plan.phases) {
     for (const task of phase.tasks) {
-      const scopeFiles = _internals47.readTaskScopes(directory, task.id);
+      const scopeFiles = _internals48.readTaskScopes(directory, task.id);
       const scope = scopeFiles ?? task.files_touched ?? [];
       tasks.push({ id: task.id, scope });
     }
   }
-  const { pairs, commitsObserved } = await _internals47.getCoChangeData(directory);
+  const { pairs, commitsObserved } = await _internals48.getCoChangeData(directory);
   const isGitProject = (() => {
     try {
-      return _internals47.isGitRepo(directory);
+      return _internals48.isGitRepo(directory);
     } catch {
       return false;
     }
   })();
-  const verdict = _internals47.decideEpicActivation(tasks, pairs, commitsObserved, {
+  const verdict = _internals48.decideEpicActivation(tasks, pairs, commitsObserved, {
     activationThreshold,
     minCommitsForSignal,
     cochangeNpmiThreshold,
@@ -35158,7 +35281,7 @@ function formatVerdict(verdict) {
 }
 
 // src/services/evidence-service.ts
-var _internals48 = {
+var _internals49 = {
   loadEvidence,
   listEvidenceTaskIds
 };
@@ -35203,7 +35326,7 @@ function getVerdictEmoji(verdict) {
   return getVerdictIcon(verdict);
 }
 async function getTaskEvidenceData(directory, taskId) {
-  const result = await _internals48.loadEvidence(directory, taskId);
+  const result = await _internals49.loadEvidence(directory, taskId);
   if (result.status !== "found") {
     return {
       hasEvidence: false,
@@ -35226,13 +35349,13 @@ async function getTaskEvidenceData(directory, taskId) {
   };
 }
 async function getEvidenceListData(directory) {
-  const taskIds = await _internals48.listEvidenceTaskIds(directory);
+  const taskIds = await _internals49.listEvidenceTaskIds(directory);
   if (taskIds.length === 0) {
     return { hasEvidence: false, tasks: [] };
   }
   const tasks = [];
   for (const taskId of taskIds) {
-    const result = await _internals48.loadEvidence(directory, taskId);
+    const result = await _internals49.loadEvidence(directory, taskId);
     if (result.status === "found") {
       tasks.push({
         taskId,
@@ -35312,7 +35435,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-nfdc1ht9.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-em58myd7.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -35668,7 +35791,7 @@ function isStaticallyEquivalent(originalCode, mutatedCode) {
   const strippedMutated = stripCode(mutatedCode);
   return strippedOriginal === strippedMutated;
 }
-var _internals49 = {
+var _internals50 = {
   isStaticallyEquivalent,
   checkEquivalence,
   batchCheckEquivalence
@@ -35708,7 +35831,7 @@ async function batchCheckEquivalence(patches, llmJudge) {
   const results = [];
   for (const { patch, originalCode, mutatedCode } of patches) {
     try {
-      const result = await _internals49.checkEquivalence(patch, originalCode, mutatedCode, llmJudge);
+      const result = await _internals50.checkEquivalence(patch, originalCode, mutatedCode, llmJudge);
       results.push(result);
     } catch (err) {
       results.push({
@@ -35782,10 +35905,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 = _internals50.resolveExecutableFromPath([
+  const resolvedExecutable = _internals51.resolveExecutableFromPath([
     args.executable
   ]);
-  const result = await _internals50.runExternalTool({
+  const result = await _internals51.runExternalTool({
     executable: resolvedExecutable ?? args.executable,
     args: args.args,
     cwd: args.cwd,
@@ -35804,7 +35927,7 @@ var runMutationCommand = async (args) => {
 };
 var runLegacyTestSeam = async (args) => {
   try {
-    const result = _internals50.spawnSync(args.executable, args.args, {
+    const result = _internals51.spawnSync(args.executable, args.args, {
       cwd: args.cwd,
       timeout: args.timeoutMs,
       stdio: "pipe"
@@ -35838,11 +35961,11 @@ var runLegacyTestSeam = async (args) => {
 function selectRunner(options) {
   if (options.runner)
     return options.runner;
-  if (_internals50.spawnSync !== defaultLegacySpawnSync)
+  if (_internals51.spawnSync !== defaultLegacySpawnSync)
     return runLegacyTestSeam;
-  return _internals50.runCommand;
+  return _internals51.runCommand;
 }
-var _internals50 = {
+var _internals51 = {
   executeMutation,
   computeReport,
   executeMutationSuite,
@@ -37029,7 +37152,7 @@ async function qualityBudget(input, directory, abortSignal) {
       }
     };
   }
-  const metrics = await _internals51.computeQualityMetrics(changedFiles, thresholds, directory);
+  const metrics = await _internals52.computeQualityMetrics(changedFiles, thresholds, directory);
   abortSignal?.throwIfAborted();
   const errorsCount = metrics.violations.filter((v) => v.severity === "error").length;
   const warningsCount = metrics.violations.filter((v) => v.severity === "warning").length;
@@ -37090,11 +37213,11 @@ var quality_budget = createSwarmTool({
     }).optional().describe("Quality budget thresholds")
   },
   async execute(args, directory, ctx) {
-    const result = await _internals51.qualityBudget(args, directory, ctx?.abort);
+    const result = await _internals52.qualityBudget(args, directory, ctx?.abort);
     return JSON.stringify(result);
   }
 });
-var _internals51 = {
+var _internals52 = {
   qualityBudget,
   computeQualityMetrics
 };
@@ -37967,7 +38090,7 @@ var SEMGREP_AVAILABILITY_MAX_STDOUT_BYTES = 16 * 1024;
 var SEMGREP_AVAILABILITY_MAX_STDERR_BYTES = 16 * 1024;
 var MAX_OUTPUT_BYTES = 10 * 1024 * 1024;
 function resolveSemgrepBinary() {
-  return _internals52.resolveExecutableFromPath(process.platform === "win32" ? ["semgrep.exe"] : ["semgrep"]);
+  return _internals53.resolveExecutableFromPath(process.platform === "win32" ? ["semgrep.exe"] : ["semgrep"]);
 }
 function getAvailabilityProbeCwd() {
   try {
@@ -37978,7 +38101,7 @@ function getAvailabilityProbeCwd() {
 }
 async function runSemgrepAvailabilityProbe(executable, cwd, generation) {
   try {
-    const run = await _internals52.runExternalTool({
+    const run = await _internals53.runExternalTool({
       executable,
       args: ["--version"],
       cwd,
@@ -38000,14 +38123,14 @@ async function waitForAvailabilityProbe(probe, abortSignal) {
     return probe;
   if (abortSignal.aborted)
     return false;
-  return new Promise((resolve17) => {
+  return new Promise((resolve18) => {
     let settled = false;
     const finish = (available) => {
       if (settled)
         return;
       settled = true;
       abortSignal.removeEventListener("abort", onAbort);
-      resolve17(available);
+      resolve18(available);
     };
     const onAbort = () => finish(false);
     abortSignal.addEventListener("abort", onAbort, { once: true });
@@ -38024,7 +38147,7 @@ function describeExternalToolFailure(status) {
       return "Semgrep process failed to start or terminate safely";
   }
 }
-var _internals52 = {
+var _internals53 = {
   isSemgrepAvailable,
   checkSemgrepAvailable,
   resetSemgrepCache,
@@ -38040,7 +38163,7 @@ function isSemgrepAvailable() {
   if (semgrepAvailableCache !== null) {
     return semgrepAvailableCache;
   }
-  return _internals52.resolveSemgrepBinary() !== null;
+  return _internals53.resolveSemgrepBinary() !== null;
 }
 async function checkSemgrepAvailable(cwd, abortSignal) {
   if (abortSignal?.aborted)
@@ -38048,14 +38171,14 @@ async function checkSemgrepAvailable(cwd, abortSignal) {
   if (semgrepAvailableCache !== null) {
     return semgrepAvailableCache;
   }
-  const executable = _internals52.resolveSemgrepBinary();
+  const executable = _internals53.resolveSemgrepBinary();
   if (!executable) {
     semgrepAvailableCache = false;
     return false;
   }
   if (!semgrepAvailabilityProbe) {
     const generation = semgrepAvailabilityGeneration;
-    const probe = runSemgrepAvailabilityProbe(executable, cwd ?? _internals52.getAvailabilityProbeCwd(), generation);
+    const probe = runSemgrepAvailabilityProbe(executable, cwd ?? _internals53.getAvailabilityProbeCwd(), generation);
     semgrepAvailabilityProbe = probe;
     probe.then(() => {
       if (semgrepAvailabilityProbe === probe) {
@@ -38164,12 +38287,12 @@ async function runSemgrep(options) {
   const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS2;
   if (files.length === 0) {
     return {
-      available: _internals52.isSemgrepAvailable(),
+      available: _internals53.isSemgrepAvailable(),
       findings: [],
       engine: "tier_a"
     };
   }
-  if (!await _internals52.checkSemgrepAvailable(options.cwd, options.abortSignal)) {
+  if (!await _internals53.checkSemgrepAvailable(options.cwd, options.abortSignal)) {
     if (options.abortSignal?.aborted) {
       return {
         available: true,
@@ -38185,7 +38308,7 @@ async function runSemgrep(options) {
       engine: "tier_a"
     };
   }
-  const executable = _internals52.resolveSemgrepBinary();
+  const executable = _internals53.resolveSemgrepBinary();
   if (!executable) {
     return {
       available: false,
@@ -38204,10 +38327,10 @@ async function runSemgrep(options) {
   }
   args.push(...files);
   try {
-    const result = await _internals52.runExternalTool({
+    const result = await _internals53.runExternalTool({
       executable,
       args,
-      cwd: options.cwd ?? _internals52.getAvailabilityProbeCwd(),
+      cwd: options.cwd ?? _internals53.getAvailabilityProbeCwd(),
       timeoutMs,
       maxStdoutBytes: MAX_OUTPUT_BYTES,
       maxStderrBytes: MAX_OUTPUT_BYTES,
@@ -38361,7 +38484,7 @@ function assignOccurrenceIndices(findings, directory) {
     }
     const occIdx = countMap.get(baseKey) ?? 0;
     countMap.set(baseKey, occIdx + 1);
-    const fp = _internals53.fingerprintFinding(finding, directory, occIdx);
+    const fp = _internals54.fingerprintFinding(finding, directory, occIdx);
     return {
       finding,
       index: occIdx,
@@ -38373,7 +38496,7 @@ function assignOccurrenceIndices(findings, directory) {
 async function waitForLockRetry(delayMs, abortSignal) {
   if (abortSignal?.aborted)
     return false;
-  return await new Promise((resolve18) => {
+  return await new Promise((resolve19) => {
     let settled = false;
     const finish = (value) => {
       if (settled)
@@ -38381,7 +38504,7 @@ async function waitForLockRetry(delayMs, abortSignal) {
       settled = true;
       clearTimeout(timeout);
       abortSignal?.removeEventListener("abort", onAbort);
-      resolve18(value);
+      resolve19(value);
     };
     const onAbort = () => finish(false);
     const timeout = setTimeout(() => finish(true), delayMs);
@@ -38465,7 +38588,7 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       }
     } catch {}
     const scannedRelFiles = new Set(scannedFiles.map((f) => normalizeFindingPath(directory, f)));
-    const indexed = _internals53.assignOccurrenceIndices(findings, directory);
+    const indexed = _internals54.assignOccurrenceIndices(findings, directory);
     if (existing && !opts?.force) {
       const prunedFingerprints = existing.fingerprints.filter((fp) => {
         const relFile = fp.slice(0, fp.indexOf("|"));
@@ -38621,7 +38744,7 @@ function loadBaseline(directory, phase) {
     };
   }
 }
-var _internals53 = {
+var _internals54 = {
   fingerprintFinding,
   assignOccurrenceIndices,
   captureOrMergeBaseline,
@@ -38769,7 +38892,7 @@ async function sastScan(input, directory, config) {
   if (abort_signal?.aborted) {
     return cancelledScanResult(allFindings, filesScanned);
   }
-  const semgrepAvailable = !offline_only && await _internals54.checkSemgrepAvailable(directory, abort_signal);
+  const semgrepAvailable = !offline_only && await _internals55.checkSemgrepAvailable(directory, abort_signal);
   const engine = semgrepAvailable ? "tier_a+tier_b" : "tier_a";
   const filesByLanguage = new Map;
   let semgrepError = abort_signal?.aborted ? "SAST scan cancelled" : undefined;
@@ -38840,7 +38963,7 @@ async function sastScan(input, directory, config) {
         let semgrepResult;
         if (bucketKey.startsWith("auto:")) {
           const lang = bucketKey.slice("auto:".length);
-          semgrepResult = await _internals54.runSemgrep({
+          semgrepResult = await _internals55.runSemgrep({
             files: bucketFiles,
             lang,
             useAutoConfig: true,
@@ -38848,7 +38971,7 @@ async function sastScan(input, directory, config) {
             abortSignal: abort_signal
           });
         } else {
-          semgrepResult = await _internals54.runSemgrep({
+          semgrepResult = await _internals55.runSemgrep({
             files: bucketFiles,
             cwd: directory,
             abortSignal: abort_signal
@@ -39139,11 +39262,11 @@ var sast_scan = createSwarmTool({
       phase: safeArgs.phase,
       abort_signal: ctx?.abort
     };
-    const result = await _internals54.sastScan(input, directory);
+    const result = await _internals55.sastScan(input, directory);
     return JSON.stringify(result, null, 2);
   }
 });
-var _internals54 = {
+var _internals55 = {
   sastScan,
   sast_scan,
   checkSemgrepAvailable: (directory, abortSignal) => checkSemgrepAvailable(directory, abortSignal),
@@ -39975,7 +40098,7 @@ function extractCurrentPhaseFromPlan2(plan) {
   if (!plan) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
-  if (!_internals55.validatePlanPhases(plan)) {
+  if (!_internals56.validatePlanPhases(plan)) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
   let currentPhase = null;
@@ -40117,9 +40240,9 @@ function extractPhaseMetrics(content) {
 async function getHandoffData(directory) {
   const now = new Date().toISOString();
   const sessionContent = await readSwarmFileAsync(directory, "session/state.json");
-  const sessionState = _internals55.parseSessionState(sessionContent);
+  const sessionState = _internals56.parseSessionState(sessionContent);
   const plan = await loadPlanJsonOnly(directory);
-  const planInfo = _internals55.extractCurrentPhaseFromPlan(plan);
+  const planInfo = _internals56.extractCurrentPhaseFromPlan(plan);
   if (!plan) {
     const planMdContent = await readSwarmFileAsync(directory, "plan.md");
     if (planMdContent) {
@@ -40138,8 +40261,8 @@ async function getHandoffData(directory) {
     }
   }
   const contextContent = await readSwarmFileAsync(directory, "context.md");
-  const recentDecisions = _internals55.extractDecisions(contextContent);
-  const rawPhaseMetrics = _internals55.extractPhaseMetrics(contextContent);
+  const recentDecisions = _internals56.extractDecisions(contextContent);
+  const rawPhaseMetrics = _internals56.extractPhaseMetrics(contextContent);
   const phaseMetrics = sanitizeString2(rawPhaseMetrics, 1000);
   let delegationState = null;
   if (sessionState?.delegationState) {
@@ -40305,7 +40428,7 @@ ${lines.join(`
 `)}
 \`\`\``;
 }
-var _internals55 = {
+var _internals56 = {
   getHandoffData,
   formatHandoffMarkdown,
   formatContinuationPrompt,
@@ -40473,15 +40596,15 @@ async function writeSnapshot(directory, state) {
 }
 function createSnapshotWriterHook(directory) {
   return (_input, _output) => {
-    _writeInFlight = _writeInFlight.then(() => _internals56.writeSnapshot(directory, swarmState), () => _internals56.writeSnapshot(directory, swarmState));
+    _writeInFlight = _writeInFlight.then(() => _internals57.writeSnapshot(directory, swarmState), () => _internals57.writeSnapshot(directory, swarmState));
     return _writeInFlight;
   };
 }
 async function flushPendingSnapshot(directory) {
-  _writeInFlight = _writeInFlight.then(() => _internals56.writeSnapshot(directory, swarmState), () => _internals56.writeSnapshot(directory, swarmState));
+  _writeInFlight = _writeInFlight.then(() => _internals57.writeSnapshot(directory, swarmState), () => _internals57.writeSnapshot(directory, swarmState));
   await _writeInFlight;
 }
-var _internals56 = {
+var _internals57 = {
   writeSnapshot,
   createSnapshotWriterHook,
   flushPendingSnapshot
@@ -40767,7 +40890,7 @@ function parseIssueRef(input, directory) {
   }
   return null;
 }
-var _internals57 = {
+var _internals58 = {
   writeFileSync: fs29.writeFileSync,
   mkdirSync: fs29.mkdirSync,
   renameSync: fs29.renameSync,
@@ -40778,18 +40901,18 @@ var _internals57 = {
 function atomicWriteFileSync(dir, filename, content) {
   const tmpPath = path68.join(dir, `.tmp-${filename}-${Date.now()}-${process.pid}`);
   const finalPath = path68.join(dir, filename);
-  _internals57.writeFileSync(tmpPath, content, "utf-8");
+  _internals58.writeFileSync(tmpPath, content, "utf-8");
   try {
-    _internals57.renameSync(tmpPath, finalPath);
+    _internals58.renameSync(tmpPath, finalPath);
   } catch {
     try {
-      _internals57.unlinkSync(finalPath);
+      _internals58.unlinkSync(finalPath);
     } catch {}
     try {
-      _internals57.renameSync(tmpPath, finalPath);
+      _internals58.renameSync(tmpPath, finalPath);
     } catch (retryErr) {
       try {
-        _internals57.unlinkSync(tmpPath);
+        _internals58.unlinkSync(tmpPath);
       } catch {}
       throw retryErr;
     }
@@ -40849,10 +40972,10 @@ ${USAGE9}`;
   };
   let oldTraceState = null;
   try {
-    oldTraceState = _internals57.readFileSync(path68.join(swarmDir, "issue-trace-state.json"), "utf-8");
+    oldTraceState = _internals58.readFileSync(path68.join(swarmDir, "issue-trace-state.json"), "utf-8");
   } catch {}
   try {
-    _internals57.mkdirSync(swarmDir, { recursive: true });
+    _internals58.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) {
@@ -40862,11 +40985,11 @@ ${USAGE9}`;
       } catch {}
     } else {
       try {
-        _internals57.unlinkSync(path68.join(swarmDir, "issue-trace-state.json"));
+        _internals58.unlinkSync(path68.join(swarmDir, "issue-trace-state.json"));
       } catch {}
     }
     try {
-      _internals57.unlinkSync(path68.join(swarmDir, "issue-reference.json"));
+      _internals58.unlinkSync(path68.join(swarmDir, "issue-reference.json"));
     } catch {}
     const errMsg = e instanceof Error ? e.message : String(e);
     return `Error: Failed to persist issue reference durably: ${errMsg}
@@ -40892,14 +41015,14 @@ init_schema();
 init_logger();
 import { randomUUID as randomUUID8 } from "crypto";
 import { existsSync as existsSync38, readFileSync as readFileSync30 } from "fs";
-import { mkdir as mkdir15, readFile as readFile18, writeFile as writeFile13 } from "fs/promises";
+import { mkdir as mkdir14, readFile as readFile17, writeFile as writeFile12 } from "fs/promises";
 import * as os8 from "os";
 import * as path69 from "path";
 init_knowledge_types();
 async function migrateKnowledgeToExternal(_directory, _config) {
   const externalSentinelPath = path69.join(_directory, ".swarm", ".knowledge-external-migrated");
   const contextPath = path69.join(_directory, ".swarm", "context.md");
-  if (_internals58.existsSync(externalSentinelPath)) {
+  if (_internals59.existsSync(externalSentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -40908,7 +41031,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
       skippedReason: "external-sentinel-exists"
     };
   }
-  if (!_internals58.existsSync(contextPath)) {
+  if (!_internals59.existsSync(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -40917,7 +41040,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
       skippedReason: "no-context-file"
     };
   }
-  const contextContent = await _internals58.readFile(contextPath, "utf-8");
+  const contextContent = await _internals59.readFile(contextPath, "utf-8");
   if (contextContent.trim().length === 0) {
     return {
       migrated: false,
@@ -40935,7 +41058,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
       entriesCount++;
     }
   }
-  await _internals58.writeSentinel(externalSentinelPath, entriesCount, entriesCount);
+  await _internals59.writeSentinel(externalSentinelPath, entriesCount, entriesCount);
   return {
     migrated: true,
     entriesMigrated: entriesCount,
@@ -40943,7 +41066,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
     entriesTotal: entriesCount
   };
 }
-var _internals58 = {
+var _internals59 = {
   appendKnowledge,
   migrateContextToKnowledge,
   migrateKnowledgeToExternal,
@@ -40958,9 +41081,9 @@ var _internals58 = {
   resolveLegacyHiveKnowledgePath,
   existsSync: existsSync38,
   readFileSync: readFileSync30,
-  readFile: readFile18,
-  mkdir: mkdir15,
-  writeFile: writeFile13
+  readFile: readFile17,
+  mkdir: mkdir14,
+  writeFile: writeFile12
 };
 async function migrateContextToKnowledge(directory, config) {
   const sentinelPath = path69.join(directory, ".swarm", ".knowledge-migrated");
@@ -40984,7 +41107,7 @@ async function migrateContextToKnowledge(directory, config) {
       skippedReason: "no-context-file"
     };
   }
-  const contextContent = await readFile18(contextPath, "utf-8");
+  const contextContent = await readFile17(contextPath, "utf-8");
   if (contextContent.trim().length === 0) {
     return {
       migrated: false,
@@ -40994,9 +41117,9 @@ async function migrateContextToKnowledge(directory, config) {
       skippedReason: "empty-context"
     };
   }
-  const rawEntries = _internals58.parseContextMd(contextContent);
+  const rawEntries = _internals59.parseContextMd(contextContent);
   if (rawEntries.length === 0) {
-    await _internals58.writeSentinel(sentinelPath, 0, 0);
+    await _internals59.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -41007,10 +41130,10 @@ async function migrateContextToKnowledge(directory, config) {
   const existing = await readKnowledge(knowledgePath);
   let migrated = 0;
   let dropped = 0;
-  const projectName = _internals58.inferProjectName(directory);
+  const projectName = _internals59.inferProjectName(directory);
   for (const raw of rawEntries) {
     if (config.validation_enabled !== false) {
-      const category = raw.categoryHint ?? _internals58.inferCategoryFromText(raw.text);
+      const category = raw.categoryHint ?? _internals59.inferCategoryFromText(raw.text);
       const result = validateLesson(raw.text, existing.map((e) => e.lesson), {
         category,
         scope: "global",
@@ -41030,8 +41153,8 @@ async function migrateContextToKnowledge(directory, config) {
     const entry = {
       id: randomUUID8(),
       tier: "swarm",
-      lesson: _internals58.truncateLesson(raw.text),
-      category: raw.categoryHint ?? _internals58.inferCategoryFromText(raw.text),
+      lesson: _internals59.truncateLesson(raw.text),
+      category: raw.categoryHint ?? _internals59.inferCategoryFromText(raw.text),
       tags: [...inferredTags, `migration:${raw.sourceSection}`],
       scope: "global",
       confidence: 0.3,
@@ -41054,7 +41177,7 @@ async function migrateContextToKnowledge(directory, config) {
   if (migrated > 0) {
     await rewriteKnowledge(knowledgePath, existing);
   }
-  await _internals58.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals59.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -41064,7 +41187,7 @@ async function migrateContextToKnowledge(directory, config) {
   };
 }
 async function migrateHiveKnowledgeLegacy(config) {
-  const legacyHivePath = _internals58.resolveLegacyHiveKnowledgePath();
+  const legacyHivePath = _internals59.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath2();
   const sentinelPath = path69.join(path69.dirname(canonicalHivePath), ".hive-knowledge-migrated");
   if (existsSync38(sentinelPath)) {
@@ -41087,7 +41210,7 @@ async function migrateHiveKnowledgeLegacy(config) {
   }
   const legacyEntries = await readKnowledge(legacyHivePath);
   if (legacyEntries.length === 0) {
-    await _internals58.writeSentinel(sentinelPath, 0, 0);
+    await _internals59.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -41135,7 +41258,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       const newHiveEntry = {
         id: resolvedId,
         tier: "hive",
-        lesson: _internals58.truncateLesson(lesson),
+        lesson: _internals59.truncateLesson(lesson),
         category,
         tags: ["migration:legacy-hive"],
         scope: scopeTag,
@@ -41154,7 +41277,7 @@ async function migrateHiveKnowledgeLegacy(config) {
         encounter_score: 1
       };
       try {
-        await _internals58.appendKnowledge(canonicalHivePath, newHiveEntry);
+        await _internals59.appendKnowledge(canonicalHivePath, newHiveEntry);
         existingHiveEntries.push(newHiveEntry);
         migrated++;
       } catch (appendError) {
@@ -41170,7 +41293,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       dropped++;
     }
   }
-  await _internals58.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals59.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} legacy hive entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -41181,7 +41304,7 @@ async function migrateHiveKnowledgeLegacy(config) {
   };
 }
 function parseContextMd(content) {
-  const sections = _internals58.splitIntoSections(content);
+  const sections = _internals59.splitIntoSections(content);
   const entries = [];
   const seen = new Set;
   const sectionPatterns = [
@@ -41197,7 +41320,7 @@ function parseContextMd(content) {
     const match = sectionPatterns.find((sp) => sp.pattern.test(section.heading));
     if (!match)
       continue;
-    const bullets = _internals58.extractBullets(section.body);
+    const bullets = _internals59.extractBullets(section.body);
     for (const bullet of bullets) {
       if (bullet.length < 15)
         continue;
@@ -41206,9 +41329,9 @@ function parseContextMd(content) {
         continue;
       seen.add(normalized);
       entries.push({
-        text: _internals58.truncateLesson(bullet),
+        text: _internals59.truncateLesson(bullet),
         sourceSection: match.sourceSection,
-        categoryHint: _internals58.inferCategoryFromText(bullet)
+        categoryHint: _internals59.inferCategoryFromText(bullet)
       });
     }
   }
@@ -41298,8 +41421,8 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await _internals58.mkdir(path69.dirname(sentinelPath), { recursive: true });
-  await _internals58.writeFile(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
+  await _internals59.mkdir(path69.dirname(sentinelPath), { recursive: true });
+  await _internals59.writeFile(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 function resolveLegacyHiveKnowledgePath() {
   const platform = process.platform;
@@ -41711,7 +41834,7 @@ function timeoutMessage(timeoutMs) {
 async function computeWithTimeout(directory, currentPhase, timeoutMs) {
   const controller = new AbortController;
   let timeout;
-  const metricsPromise = _internals59.computeLearningMetrics(directory, {
+  const metricsPromise = _internals60.computeLearningMetrics(directory, {
     currentPhase,
     signal: controller.signal
   });
@@ -41768,19 +41891,19 @@ ${JSON.stringify({
     return `Error computing learning metrics: ${message}. Run /swarm diagnose to check .swarm/ health.`;
   }
 }
-var _internals59 = {
+var _internals60 = {
   computeLearningMetrics
 };
 
 // src/commands/link.ts
-import { mkdir as mkdir17, writeFile as writeFile14 } from "fs/promises";
+import { mkdir as mkdir16, writeFile as writeFile13 } from "fs/promises";
 import * as path71 from "path";
 init_schema();
 
 // src/knowledge/family-migration.ts
 var import_proper_lockfile6 = __toESM(require_proper_lockfile(), 1);
 import { existsSync as existsSync39, readFileSync as readFileSync31 } from "fs";
-import { mkdir as mkdir16 } from "fs/promises";
+import { mkdir as mkdir15 } from "fs/promises";
 import * as path70 from "path";
 
 // src/knowledge/family-manifest.ts
@@ -42063,7 +42186,7 @@ async function snapshotSourceFamily(storeDir) {
   const snapshot = {};
   let release = null;
   try {
-    await mkdir16(storeDir, { recursive: true });
+    await mkdir15(storeDir, { recursive: true });
   } catch {}
   try {
     release = await import_proper_lockfile6.default.lock(storeDir, {
@@ -42082,7 +42205,7 @@ async function snapshotSourceFamily(storeDir) {
   return snapshot;
 }
 async function migrateKnowledgeFamily(destinationDir, sourceDir) {
-  await mkdir16(destinationDir, { recursive: true });
+  await mkdir15(destinationDir, { recursive: true });
   let destRelease = null;
   try {
     destRelease = await import_proper_lockfile6.default.lock(destinationDir, {
@@ -42232,8 +42355,8 @@ ${formatStatus(directory)}`;
     const { config: loadedConfig } = loadPluginConfigWithMeta(directory);
     const config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     const fingerprint = cohortConfigFingerprint(buildConfigFingerprintInput(config));
-    await mkdir17(linkDir, { recursive: true });
-    await writeFile14(path71.join(linkDir, "cohort-config.json"), JSON.stringify({ fingerprint, updated_at: new Date().toISOString() }, null, 2), "utf-8");
+    await mkdir16(linkDir, { recursive: true });
+    await writeFile13(path71.join(linkDir, "cohort-config.json"), JSON.stringify({ fingerprint, updated_at: new Date().toISOString() }, null, 2), "utf-8");
   } catch {}
   const relinkNote = existing ? `
 (Re-linked from previous link "${existing.linkId}".)` : "";
@@ -42289,7 +42412,7 @@ async function readLatestLoopState(directory) {
     return null;
   }
 }
-var _internals60 = {
+var _internals61 = {
   readLatestLoopState
 };
 var USAGE10 = `Usage: /swarm loop <objective> [--max-cycles 1..5] [--autonomy checkpoint|auto] [--depth standard|exhaustive] [--resume]
@@ -42402,7 +42525,7 @@ ${USAGE10}`;
   }
   let autonomy = parsed.autonomy;
   if (parsed.resume && !parsed.autonomyExplicit) {
-    const state = await _internals60.readLatestLoopState(_directory);
+    const state = await _internals61.readLatestLoopState(_directory);
     if (state?.autonomy && AUTONOMY_LEVELS.has(state.autonomy)) {
       autonomy = state.autonomy;
     }
@@ -42491,7 +42614,7 @@ async function rmTempRoot(tempRoot) {
     } catch (err) {
       if (attempt === 9)
         throw err;
-      await new Promise((resolve21) => setTimeout(resolve21, 50));
+      await new Promise((resolve22) => setTimeout(resolve22, 50));
     }
   }
 }
@@ -42892,7 +43015,7 @@ function parseJsonObject(candidate) {
 // src/memory/injector.ts
 init_schema();
 // src/memory/consolidation-log.ts
-import { appendFile as appendFile7, mkdir as mkdir18, readFile as readFile20 } from "fs/promises";
+import { appendFile as appendFile6, mkdir as mkdir17, readFile as readFile19 } from "fs/promises";
 import * as path73 from "path";
 var LOG_RELATIVE_PATH = path73.join("memory", "consolidation-log.jsonl");
 var LOG_BASENAME = "consolidation-log.jsonl";
@@ -42909,7 +43032,7 @@ async function readConsolidationLog(target) {
   const filePath = resolveLogPath2(target);
   let raw;
   try {
-    raw = await readFile20(filePath, "utf-8");
+    raw = await readFile19(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -43469,14 +43592,14 @@ function truncate(value, maxLength) {
 }
 
 // src/commands/memory-link.ts
-import { mkdir as mkdir20, writeFile as writeFile15 } from "fs/promises";
+import { mkdir as mkdir19, writeFile as writeFile14 } from "fs/promises";
 import * as path76 from "path";
 init_schema();
 
 // src/memory/memory-family-migration.ts
 var import_proper_lockfile7 = __toESM(require_proper_lockfile(), 1);
 import { copyFileSync as copyFileSync4, existsSync as existsSync41, readFileSync as readFileSync32, unlinkSync as unlinkSync12 } from "fs";
-import { mkdir as mkdir19, rename as rename9 } from "fs/promises";
+import { mkdir as mkdir18, rename as rename8 } from "fs/promises";
 import * as path75 from "path";
 init_logger();
 
@@ -43618,12 +43741,12 @@ function stageSqliteDb(sourceStoragePath, destDir) {
 async function mergeStagedSqlite(destStoragePath, stagedPath) {
   const destDbPath = path75.join(destStoragePath, "memory.db");
   if (!existsSync41(destDbPath)) {
-    await rename9(stagedPath, destDbPath);
+    await rename8(stagedPath, destDbPath);
     for (const suffix of ["-wal", "-shm"]) {
       const stagedSidecar = `${stagedPath}${suffix}`;
       if (existsSync41(stagedSidecar)) {
         try {
-          await rename9(stagedSidecar, `${destDbPath}${suffix}`);
+          await rename8(stagedSidecar, `${destDbPath}${suffix}`);
         } catch {}
       }
     }
@@ -43696,7 +43819,7 @@ async function countRowsSafe(dbPath) {
 async function migrateMemoryFamily(destRoot, sourceRoot) {
   const destStoragePath = rootStoragePath(destRoot);
   const sourceStoragePath = rootStoragePath(sourceRoot);
-  await mkdir19(destStoragePath, { recursive: true });
+  await mkdir18(destStoragePath, { recursive: true });
   let destRelease = null;
   try {
     destRelease = await import_proper_lockfile7.default.lock(destStoragePath, {
@@ -43743,7 +43866,7 @@ async function migrateMemoryFamily(destRoot, sourceRoot) {
     }
     if (isCohortRoot(sourceRoot)) {
       const backupDir = path75.join(destStoragePath, "backups");
-      await mkdir19(backupDir, { recursive: true });
+      await mkdir18(backupDir, { recursive: true });
       const stamp = new Date().toISOString().replace(/[:.]/g, "-");
       const sourceDbPath = path75.join(sourceStoragePath, "memory.db");
       if (existsSync41(sourceDbPath)) {
@@ -43879,10 +44002,10 @@ ${formatStatus2(directory)}`;
     return `\u274C Failed to migrate the memory family into the cohort store: ${error2 instanceof Error ? error2.message : String(error2)}`;
   }
   try {
-    await mkdir20(cohortRoot.cohortRoot, { recursive: true });
+    await mkdir19(cohortRoot.cohortRoot, { recursive: true });
     const fingerprintInput = buildMemoryCohortFingerprintInput(memoryConfig);
     const fingerprint = computeMemoryCohortFingerprint(fingerprintInput);
-    await writeFile15(path76.join(cohortRoot.cohortRoot, "memory-cohort-config.json"), JSON.stringify({
+    await writeFile14(path76.join(cohortRoot.cohortRoot, "memory-cohort-config.json"), JSON.stringify({
       fingerprint,
       algorithm_version: FINGERPRINT_ALGORITHM_VERSION,
       config: fingerprintInput,
@@ -43956,15 +44079,15 @@ async function handleMemoryUnlinkCommand(directory, args) {
 }
 
 // src/services/plan-service.ts
-var _internals61 = {
+var _internals62 = {
   loadPlanJsonOnly,
   derivePlanMarkdown,
   readSwarmFileAsync
 };
 async function getPlanData(directory, phaseArg) {
-  const plan = await _internals61.loadPlanJsonOnly(directory);
+  const plan = await _internals62.loadPlanJsonOnly(directory);
   if (plan) {
-    const fullMarkdown = _internals61.derivePlanMarkdown(plan);
+    const fullMarkdown = _internals62.derivePlanMarkdown(plan);
     if (phaseArg === undefined || phaseArg === null || phaseArg === "") {
       return {
         hasPlan: true,
@@ -44007,7 +44130,7 @@ async function getPlanData(directory, phaseArg) {
       isLegacy: false
     };
   }
-  const planContent = await _internals61.readSwarmFileAsync(directory, "plan.md");
+  const planContent = await _internals62.readSwarmFileAsync(directory, "plan.md");
   if (!planContent) {
     return {
       hasPlan: false,
@@ -44104,7 +44227,7 @@ async function handlePlanCommand(directory, args) {
   return formatPlanMarkdown(planData);
 }
 // src/commands/post-mortem.ts
-var _internals62 = {
+var _internals63 = {
   createCuratorLLMDelegate,
   runCuratorPostMortem
 };
@@ -44152,10 +44275,10 @@ async function handlePostMortemCommand(directory, args, options) {
     };
     if (options?.sessionID) {
       try {
-        pmOptions.llmDelegate = _internals62.createCuratorLLMDelegate(directory, "postmortem", options.sessionID);
+        pmOptions.llmDelegate = _internals63.createCuratorLLMDelegate(directory, "postmortem", options.sessionID);
       } catch {}
     }
-    const result = await _internals62.runCuratorPostMortem(directory, pmOptions);
+    const result = await _internals63.runCuratorPostMortem(directory, pmOptions);
     const lines = [];
     if (result.success) {
       lines.push("## Post-Mortem Report Generated");
@@ -44413,7 +44536,7 @@ function formatMergeGroupStatus(status, conclusion, htmlUrl) {
   }
   return parts.join(" ");
 }
-var _internals63 = {
+var _internals64 = {
   formatRelativeTime,
   formatMergeGroupStatus,
   listActive,
@@ -44421,7 +44544,7 @@ var _internals63 = {
   parseMergeGroupRuns
 };
 async function handlePrMonitorStatusCommand(directory, _args, sessionID, source) {
-  const allActive = await _internals63.listActive(directory);
+  const allActive = await _internals64.listActive(directory);
   const allSessions = source === "cli";
   const subs = allSessions ? allActive : allActive.filter((record) => record.sessionID === sessionID);
   if (subs.length === 0) {
@@ -44437,7 +44560,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 _internals63.listMergeGroupRuns(directory, sub.repoFullName, sub.prNumber);
+    const mergeGroupRuns = await _internals64.listMergeGroupRuns(directory, sub.repoFullName, sub.prNumber);
     if (mergeGroupRuns.runs.length > 0) {
       lines.push("     Merge-group runs:");
       for (const run of mergeGroupRuns.runs) {
@@ -44578,7 +44701,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 = _internals64.loadPluginConfig(directory);
+    const config = _internals65.loadPluginConfig(directory);
     const prMonitorConfig = config.pr_monitor;
     if (!prMonitorConfig?.enabled) {
       return [
@@ -44588,7 +44711,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
       ].join(`
 `);
     }
-    await _internals64.subscribe(directory, {
+    await _internals65.subscribe(directory, {
       sessionID,
       prNumber: prInfo.number,
       repoFullName,
@@ -44616,7 +44739,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals64 = {
+var _internals65 = {
   loadPluginConfig,
   subscribe
 };
@@ -44639,9 +44762,9 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
   const refToken = rest[0];
-  const prInfo = _internals65.parsePrRef(refToken, directory);
+  const prInfo = _internals66.parsePrRef(refToken, directory);
   if (!prInfo) {
-    if (_internals65.looksLikePrRef(refToken)) {
+    if (_internals66.looksLikePrRef(refToken)) {
       return [
         `Error: Could not resolve PR reference from "${refToken}".`,
         "",
@@ -44662,8 +44785,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 = _internals65.buildCorrelationId(sessionID, repoFullName, prInfo.number);
-    const result = await _internals65.unsubscribe(directory, correlationId);
+    const correlationId = _internals66.buildCorrelationId(sessionID, repoFullName, prInfo.number);
+    const result = await _internals66.unsubscribe(directory, correlationId);
     if (!result) {
       return [
         `Not subscribed to ${prUrl}`,
@@ -44690,7 +44813,7 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals65 = {
+var _internals66 = {
   unsubscribe,
   buildCorrelationId,
   parsePrRef,
@@ -44739,7 +44862,7 @@ function normalizeRelativePathForPlatform(value, platform) {
 }
 function isRegularFile(candidate) {
   try {
-    return _internals66.statSync(candidate).isFile();
+    return _internals67.statSync(candidate).isFile();
   } catch {
     return false;
   }
@@ -44747,21 +44870,21 @@ function isRegularFile(candidate) {
 function readTextFileBounded(filePath, maxBytes) {
   let fd;
   try {
-    fd = _internals66.openSync(filePath, "r");
-    const stats = _internals66.fstatSync(fd);
+    fd = _internals67.openSync(filePath, "r");
+    const stats = _internals67.fstatSync(fd);
     if (!stats.isFile() || !Number.isSafeInteger(stats.size) || stats.size < 0 || stats.size > maxBytes) {
       return null;
     }
     const bytes = Buffer.alloc(stats.size);
     let offset = 0;
     while (offset < bytes.byteLength) {
-      const bytesRead = _internals66.readSync(fd, bytes, offset, bytes.byteLength - offset, null);
+      const bytesRead = _internals67.readSync(fd, bytes, offset, bytes.byteLength - offset, null);
       if (bytesRead === 0)
         break;
       offset += bytesRead;
     }
     const overflowProbe = Buffer.alloc(1);
-    if (_internals66.readSync(fd, overflowProbe, 0, 1, null) > 0)
+    if (_internals67.readSync(fd, overflowProbe, 0, 1, null) > 0)
       return null;
     return bytes.subarray(0, offset).toString("utf8");
   } catch {
@@ -44769,7 +44892,7 @@ function readTextFileBounded(filePath, maxBytes) {
   } finally {
     if (fd !== undefined) {
       try {
-        _internals66.closeSync(fd);
+        _internals67.closeSync(fd);
       } catch {}
     }
   }
@@ -44790,7 +44913,7 @@ function getAncestorDirectories(directory) {
   }
   return roots;
 }
-function getTrustedShimNames(linter, platform = _internals66.platform()) {
+function getTrustedShimNames(linter, platform = _internals67.platform()) {
   const isWindows = platform === "win32";
   if (linter === "biome") {
     return isWindows ? ["biome.exe", "biome.cmd", "biome.ps1"] : ["biome"];
@@ -44807,7 +44930,7 @@ function getPackageManifestPath(searchRoot, linter) {
   return path77.join(getPackageRootFromSearchRoot(searchRoot, linter), "package.json");
 }
 function getPackageDisplayPath(searchRoot, linter) {
-  return path77.join(searchRoot, NODE_MODULES, BIN_DIRECTORY, linter === "biome" ? _internals66.platform() === "win32" ? "biome.exe" : "biome" : _internals66.platform() === "win32" ? "eslint" : "eslint");
+  return path77.join(searchRoot, NODE_MODULES, BIN_DIRECTORY, linter === "biome" ? _internals67.platform() === "win32" ? "biome.exe" : "biome" : _internals67.platform() === "win32" ? "eslint" : "eslint");
 }
 function getBiomeNativePackage(platform, arch) {
   const archMap = platform === "darwin" ? { arm64: "@biomejs/cli-darwin-arm64", x64: "@biomejs/cli-darwin-x64" } : platform === "linux" ? {
@@ -44822,7 +44945,7 @@ function getBiomeNativePackage(platform, arch) {
     return null;
   return archMap[arch] ?? null;
 }
-function getBiomeNativeExecutable(searchRoot, platform = _internals66.platform(), arch = _internals66.arch()) {
+function getBiomeNativeExecutable(searchRoot, platform = _internals67.platform(), arch = _internals67.arch()) {
   const nativePackage = getBiomeNativePackage(platform, arch);
   if (!nativePackage)
     return null;
@@ -44858,8 +44981,8 @@ function resolveCanonicalPackageCommand(searchRoot, linter, source) {
   let canonicalCandidate;
   try {
     const packageRoot = path77.dirname(manifestPath);
-    canonicalPackageRoot = _internals66.realpathSync(packageRoot);
-    canonicalCandidate = _internals66.realpathSync(path77.resolve(packageRoot, relativeBinPath));
+    canonicalPackageRoot = _internals67.realpathSync(packageRoot);
+    canonicalCandidate = _internals67.realpathSync(path77.resolve(packageRoot, relativeBinPath));
   } catch {
     return null;
   }
@@ -44871,7 +44994,7 @@ function resolveCanonicalPackageCommand(searchRoot, linter, source) {
     return null;
   return {
     linter,
-    executable: _internals66.execPath(),
+    executable: _internals67.execPath(),
     argsPrefix: [canonicalCandidate],
     displayPrefix: [getPackageDisplayPath(searchRoot, linter)],
     source
@@ -44912,7 +45035,7 @@ function resolveLocalLinterCommand(linter, directory) {
   }
   return null;
 }
-function findPathShimCandidate(linter, envPath = _internals66.pathEnv(), platform = _internals66.platform()) {
+function findPathShimCandidate(linter, envPath = _internals67.pathEnv(), platform = _internals67.platform()) {
   const entries = envPath.split(path77.delimiter).filter(Boolean);
   const shimNames = getTrustedShimNames(linter, platform).filter((name) => name.endsWith(".cmd") || name.endsWith(".ps1") || platform !== "win32");
   for (const entry of entries) {
@@ -44942,7 +45065,7 @@ function getExpectedShimSuffixes(linter) {
     normalizeRelativePathForPlatform(nodeModulesPackageOnlySuffix, "linux")
   ];
 }
-function resolvePathShimTarget(shimPath, linter, platform = _internals66.platform()) {
+function resolvePathShimTarget(shimPath, linter, platform = _internals67.platform()) {
   const contents = readTextFileBounded(shimPath, MAX_PATH_SHIM_BYTES);
   if (contents === null)
     return null;
@@ -44989,7 +45112,7 @@ function resolvePathShimTarget(shimPath, linter, platform = _internals66.platfor
     return null;
   let canonicalShimDir;
   try {
-    canonicalShimDir = _internals66.realpathSync(path77.dirname(shimPath));
+    canonicalShimDir = _internals67.realpathSync(path77.dirname(shimPath));
   } catch {
     return null;
   }
@@ -44998,7 +45121,7 @@ function resolvePathShimTarget(shimPath, linter, platform = _internals66.platfor
     return null;
   let canonicalTarget;
   try {
-    canonicalTarget = _internals66.realpathSync(resolvedTarget);
+    canonicalTarget = _internals67.realpathSync(resolvedTarget);
   } catch {
     return null;
   }
@@ -45008,7 +45131,7 @@ function resolvePathShimTarget(shimPath, linter, platform = _internals66.platfor
   }
   let canonicalShimParent;
   try {
-    canonicalShimParent = _internals66.realpathSync(path77.dirname(canonicalShimDir));
+    canonicalShimParent = _internals67.realpathSync(path77.dirname(canonicalShimDir));
   } catch {
     return null;
   }
@@ -45022,8 +45145,8 @@ function resolvePathShimTarget(shimPath, linter, platform = _internals66.platfor
   return canonicalTarget;
 }
 function resolvePathLinterCommand(linter, directory) {
-  const platform = _internals66.platform();
-  const envPath = _internals66.pathEnv();
+  const platform = _internals67.platform();
+  const envPath = _internals67.pathEnv();
   const nativeNames = platform === "win32" ? linter === "biome" ? ["biome.exe"] : ["eslint.exe"] : linter === "biome" ? ["biome"] : ["eslint"];
   const nativeExecutable = resolveExecutableFromPath(nativeNames, envPath, platform);
   if (nativeExecutable) {
@@ -45043,7 +45166,7 @@ function resolvePathLinterCommand(linter, directory) {
     return null;
   return {
     linter,
-    executable: _internals66.execPath(),
+    executable: _internals67.execPath(),
     argsPrefix: [shimTarget],
     displayPrefix: [path77.join(directory, NODE_MODULES, BIN_DIRECTORY, linter)],
     source: "path-shim"
@@ -45080,7 +45203,7 @@ function buildExecutionError(mode, command, linter, result) {
   };
 }
 async function probeResolvedCommand(command, cwd, abortSignal) {
-  const result = await _internals66.runExternalTool({
+  const result = await _internals67.runExternalTool({
     executable: command.executable,
     args: [...command.argsPrefix, "--version"],
     cwd,
@@ -45098,7 +45221,7 @@ async function resolveLinterCommand(linter, directory) {
 async function detectResolvedLinter(directory, abortSignal) {
   if (!directory)
     return null;
-  if (!_internals66.existsSync(directory))
+  if (!_internals67.existsSync(directory))
     return null;
   const cwd = toAbsoluteDirectory(directory);
   for (const linter of SUPPORTED_LINTERS) {
@@ -45112,12 +45235,12 @@ async function detectResolvedLinter(directory, abortSignal) {
   return null;
 }
 function detectRuff(cwd) {
-  if (_internals66.existsSync(path77.join(cwd, "ruff.toml")))
+  if (_internals67.existsSync(path77.join(cwd, "ruff.toml")))
     return hasAdditionalCommand("ruff");
   try {
     const pyproject = path77.join(cwd, "pyproject.toml");
-    if (_internals66.existsSync(pyproject)) {
-      const content = _internals66.readFileSync(pyproject, "utf-8");
+    if (_internals67.existsSync(pyproject)) {
+      const content = _internals67.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
         return hasAdditionalCommand("ruff");
     }
@@ -45125,32 +45248,32 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return _internals66.existsSync(path77.join(cwd, "Cargo.toml")) && hasAdditionalCommand("cargo");
+  return _internals67.existsSync(path77.join(cwd, "Cargo.toml")) && hasAdditionalCommand("cargo");
 }
 function detectGolangciLint(cwd) {
-  return _internals66.existsSync(path77.join(cwd, "go.mod")) && hasAdditionalCommand("golangci-lint");
+  return _internals67.existsSync(path77.join(cwd, "go.mod")) && hasAdditionalCommand("golangci-lint");
 }
 function readTextFileSafe(filePath) {
   try {
-    return _internals66.readFileSync(filePath, "utf-8");
+    return _internals67.readFileSync(filePath, "utf-8");
   } catch {
     return "";
   }
 }
 function resolveAdditionalExecutable(name) {
-  const platform = _internals66.platform();
+  const platform = _internals67.platform();
   if (platform !== "win32") {
-    return _internals66.isCommandAvailable(name) ? name : null;
+    return _internals67.isCommandAvailable(name) ? name : null;
   }
-  return resolveExecutableFromPath([`${name}.exe`], _internals66.pathEnv(), platform);
+  return resolveExecutableFromPath([`${name}.exe`], _internals67.pathEnv(), platform);
 }
 function resolveWindowsCommandInterpreter() {
-  const candidate = _internals66.comSpec();
+  const candidate = _internals67.comSpec();
   if (!candidate || !path77.isAbsolute(candidate) || path77.basename(candidate).toLowerCase() !== "cmd.exe" || !isRegularFile(candidate)) {
     return null;
   }
   try {
-    const canonical = _internals66.realpathSync(candidate);
+    const canonical = _internals67.realpathSync(candidate);
     return path77.basename(canonical).toLowerCase() === "cmd.exe" ? canonical : null;
   } catch {
     return null;
@@ -45162,7 +45285,7 @@ function buildWindowsBatchCommand(wrapperPath, args) {
     return null;
   let canonicalWrapper;
   try {
-    canonicalWrapper = _internals66.realpathSync(wrapperPath);
+    canonicalWrapper = _internals67.realpathSync(wrapperPath);
   } catch {
     return null;
   }
@@ -45176,13 +45299,13 @@ function buildWindowsBatchCommand(wrapperPath, args) {
   return [interpreter, "/d", "/s", "/v:off", "/c", command];
 }
 function resolveWindowsBatchCommandFromPath(name, args) {
-  if (_internals66.platform() !== "win32")
+  if (_internals67.platform() !== "win32")
     return null;
-  const wrapper = resolveExecutableFromPath(WINDOWS_BATCH_WRAPPER_EXTENSIONS.map((extension) => `${name}${extension}`), _internals66.pathEnv(), "win32");
+  const wrapper = resolveExecutableFromPath(WINDOWS_BATCH_WRAPPER_EXTENSIONS.map((extension) => `${name}${extension}`), _internals67.pathEnv(), "win32");
   return wrapper ? buildWindowsBatchCommand(wrapper, args) : null;
 }
 function resolveContainedWindowsBatchCommand(cwd, fileName, args) {
-  if (_internals66.platform() !== "win32")
+  if (_internals67.platform() !== "win32")
     return null;
   const candidate = path77.join(cwd, fileName);
   if (!isRegularFile(candidate))
@@ -45190,8 +45313,8 @@ function resolveContainedWindowsBatchCommand(cwd, fileName, args) {
   let canonicalCwd;
   let canonicalCandidate;
   try {
-    canonicalCwd = _internals66.realpathSync(cwd);
-    canonicalCandidate = _internals66.realpathSync(candidate);
+    canonicalCwd = _internals67.realpathSync(cwd);
+    canonicalCandidate = _internals67.realpathSync(candidate);
   } catch {
     return null;
   }
@@ -45212,22 +45335,22 @@ function hasAdditionalCommand(name) {
 }
 function resolvePhpVendorCommand(cwd, name) {
   const relativeProxy = path77.join("vendor", "bin", name);
-  if (!_internals66.existsSync(path77.join(cwd, relativeProxy)))
+  if (!_internals67.existsSync(path77.join(cwd, relativeProxy)))
     return null;
-  if (_internals66.platform() !== "win32")
+  if (_internals67.platform() !== "win32")
     return [relativeProxy];
   const phpExecutable = resolveAdditionalExecutable("php");
   return phpExecutable ? [phpExecutable, relativeProxy] : null;
 }
 function hasCheckstyleGradleSignal(cwd) {
-  const gradleFiles = ["build.gradle", "build.gradle.kts"].map((file) => path77.join(cwd, file)).filter((file) => _internals66.existsSync(file));
-  return _internals66.existsSync(path77.join(cwd, "checkstyle.xml")) || _internals66.existsSync(path77.join(cwd, "config", "checkstyle", "checkstyle.xml")) || gradleFiles.some((file) => /\bcheckstyle\b/i.test(readTextFileSafe(file)));
+  const gradleFiles = ["build.gradle", "build.gradle.kts"].map((file) => path77.join(cwd, file)).filter((file) => _internals67.existsSync(file));
+  return _internals67.existsSync(path77.join(cwd, "checkstyle.xml")) || _internals67.existsSync(path77.join(cwd, "config", "checkstyle", "checkstyle.xml")) || gradleFiles.some((file) => /\bcheckstyle\b/i.test(readTextFileSafe(file)));
 }
 function resolveCheckstyleCommand(cwd) {
-  const hasMavenProject = _internals66.existsSync(path77.join(cwd, "pom.xml"));
+  const hasMavenProject = _internals67.existsSync(path77.join(cwd, "pom.xml"));
   const hasGradleSignal = hasCheckstyleGradleSignal(cwd);
   if (hasGradleSignal) {
-    if (_internals66.platform() === "win32") {
+    if (_internals67.platform() === "win32") {
       const gradlew = resolveContainedWindowsBatchCommand(cwd, "gradlew.bat", [
         "checkstyleMain"
       ]);
@@ -45235,7 +45358,7 @@ function resolveCheckstyleCommand(cwd) {
         return gradlew;
     } else {
       const gradlew = path77.join(cwd, "gradlew");
-      if (_internals66.existsSync(gradlew))
+      if (_internals67.existsSync(gradlew))
         return [gradlew, "checkstyleMain"];
     }
     const gradle = buildAdditionalCommand("gradle", ["checkstyleMain"]);
@@ -45249,7 +45372,7 @@ function resolveCheckstyleCommand(cwd) {
   }
   return null;
 }
-function isUnsafeShellWrapperExecutable(executable, platform = _internals66.platform()) {
+function isUnsafeShellWrapperExecutable(executable, platform = _internals67.platform()) {
   return platform === "win32" && UNSAFE_SHELL_WRAPPER_EXTENSIONS.has(path77.extname(executable).toLowerCase());
 }
 function detectCheckstyle(cwd) {
@@ -45257,7 +45380,7 @@ function detectCheckstyle(cwd) {
 }
 function hasRootKotlinFile(cwd) {
   try {
-    return _internals66.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
+    return _internals67.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
   } catch {
     return false;
   }
@@ -45267,27 +45390,27 @@ function buildGradleHasKotlinSignal(cwd) {
   return /\b(kotlin|org\.jetbrains\.kotlin|ktlint)\b/i.test(content);
 }
 function detectKtlint(cwd) {
-  const hasKotlin = _internals66.existsSync(path77.join(cwd, "build.gradle.kts")) || _internals66.existsSync(path77.join(cwd, "build.gradle")) && buildGradleHasKotlinSignal(cwd) || hasRootKotlinFile(cwd);
+  const hasKotlin = _internals67.existsSync(path77.join(cwd, "build.gradle.kts")) || _internals67.existsSync(path77.join(cwd, "build.gradle")) && buildGradleHasKotlinSignal(cwd) || hasRootKotlinFile(cwd);
   return hasKotlin && hasAdditionalCommand("ktlint");
 }
 function detectPhpLinter(cwd) {
-  if ((_internals66.existsSync(path77.join(cwd, "phpstan.neon")) || _internals66.existsSync(path77.join(cwd, "phpstan.neon.dist"))) && resolvePhpVendorCommand(cwd, "phpstan") !== null) {
+  if ((_internals67.existsSync(path77.join(cwd, "phpstan.neon")) || _internals67.existsSync(path77.join(cwd, "phpstan.neon.dist"))) && resolvePhpVendorCommand(cwd, "phpstan") !== null) {
     return "phpstan";
   }
-  if (_internals66.existsSync(path77.join(cwd, "pint.json")) && resolvePhpVendorCommand(cwd, "pint") !== null) {
+  if (_internals67.existsSync(path77.join(cwd, "pint.json")) && resolvePhpVendorCommand(cwd, "pint") !== null) {
     return "pint";
   }
-  if (_internals66.existsSync(path77.join(cwd, ".php-cs-fixer.php")) && resolvePhpVendorCommand(cwd, "php-cs-fixer") !== null) {
+  if (_internals67.existsSync(path77.join(cwd, ".php-cs-fixer.php")) && resolvePhpVendorCommand(cwd, "php-cs-fixer") !== null) {
     return "php-cs-fixer";
   }
-  if (_internals66.existsSync(path77.join(cwd, "phpcs.xml")) && resolvePhpVendorCommand(cwd, "phpcs") !== null) {
+  if (_internals67.existsSync(path77.join(cwd, "phpcs.xml")) && resolvePhpVendorCommand(cwd, "phpcs") !== null) {
     return "phpcs";
   }
   return null;
 }
 function detectDotnetFormat(cwd) {
   try {
-    const files = _internals66.readdirSync(cwd);
+    const files = _internals67.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"));
     return hasCsproj && hasAdditionalCommand("dotnet");
   } catch {
@@ -45295,14 +45418,14 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (_internals66.existsSync(path77.join(cwd, "CMakeLists.txt"))) {
+  if (_internals67.existsSync(path77.join(cwd, "CMakeLists.txt"))) {
     return hasAdditionalCommand("cppcheck");
   }
   try {
     const dirsToCheck = [cwd, path77.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
-        return _internals66.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
+        return _internals67.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
       } catch {
         return false;
       }
@@ -45313,13 +45436,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return _internals66.existsSync(path77.join(cwd, "Package.swift")) && hasAdditionalCommand("swiftlint");
+  return _internals67.existsSync(path77.join(cwd, "Package.swift")) && hasAdditionalCommand("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return _internals66.existsSync(path77.join(cwd, "pubspec.yaml")) && hasAdditionalCommand("dart");
+  return _internals67.existsSync(path77.join(cwd, "pubspec.yaml")) && hasAdditionalCommand("dart");
 }
 function detectRubocop(cwd) {
-  return (_internals66.existsSync(path77.join(cwd, "Gemfile")) || _internals66.existsSync(path77.join(cwd, "gems.rb")) || _internals66.existsSync(path77.join(cwd, ".rubocop.yml"))) && (hasAdditionalCommand("rubocop") || hasAdditionalCommand("bundle"));
+  return (_internals67.existsSync(path77.join(cwd, "Gemfile")) || _internals67.existsSync(path77.join(cwd, "gems.rb")) || _internals67.existsSync(path77.join(cwd, ".rubocop.yml"))) && (hasAdditionalCommand("rubocop") || hasAdditionalCommand("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -45364,7 +45487,7 @@ async function runResolvedLint(command, mode, directory, abortSignal) {
       error: "Command exceeds maximum allowed length"
     };
   }
-  const runResult = await _internals66.runExternalTool({
+  const runResult = await _internals67.runExternalTool({
     executable: command.executable,
     args: [...command.argsPrefix, ...lintArgs],
     cwd: toAbsoluteDirectory(directory),
@@ -45442,7 +45565,7 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 async function runLint(linter, mode, directory, abortSignal) {
-  const resolved = await _internals66.resolveLinterCommand(linter, directory);
+  const resolved = await _internals67.resolveLinterCommand(linter, directory);
   if (!resolved) {
     return {
       success: false,
@@ -45483,7 +45606,7 @@ async function runAdditionalLint(linter, mode, cwd, abortSignal) {
       error: `No safely executable ${linter} command found`
     };
   }
-  const runResult = await _internals66.runExternalTool({
+  const runResult = await _internals67.runExternalTool({
     executable,
     args,
     cwd: toAbsoluteDirectory(cwd),
@@ -45491,7 +45614,7 @@ async function runAdditionalLint(linter, mode, cwd, abortSignal) {
     maxStdoutBytes: MAX_OUTPUT_BYTES2,
     maxStderrBytes: MAX_OUTPUT_BYTES2,
     abortSignal,
-    windowsVerbatimArguments: _internals66.platform() === "win32" && path77.basename(executable).toLowerCase() === "cmd.exe"
+    windowsVerbatimArguments: _internals67.platform() === "win32" && path77.basename(executable).toLowerCase() === "cmd.exe"
   });
   if (runResult.status !== "completed") {
     return buildExecutionError(mode, command, linter, runResult);
@@ -45538,15 +45661,15 @@ var lint = createSwarmTool({
     }
     const { mode } = args;
     const cwd = directory;
-    const resolvedLinter = await _internals66.detectResolvedLinter(directory, ctx?.abort);
+    const resolvedLinter = await _internals67.detectResolvedLinter(directory, ctx?.abort);
     if (resolvedLinter) {
-      const result = await _internals66.runResolvedLint(resolvedLinter, mode, directory, ctx?.abort);
+      const result = await _internals67.runResolvedLint(resolvedLinter, mode, directory, ctx?.abort);
       return JSON.stringify(result, null, 2);
     }
-    const additionalLinter = _internals66.detectAdditionalLinter(cwd);
+    const additionalLinter = _internals67.detectAdditionalLinter(cwd);
     if (additionalLinter) {
       warn(`[lint] Using ${additionalLinter} linter for this project`);
-      const result = await _internals66.runAdditionalLint(additionalLinter, mode, cwd, ctx?.abort);
+      const result = await _internals67.runAdditionalLint(additionalLinter, mode, cwd, ctx?.abort);
       return JSON.stringify(result, null, 2);
     }
     const errorResult = {
@@ -45560,7 +45683,7 @@ For Rust: rustup component add clippy`
     return JSON.stringify(errorResult, null, 2);
   }
 });
-var _internals66 = {
+var _internals67 = {
   MAX_PACKAGE_MANIFEST_BYTES,
   MAX_PATH_SHIM_BYTES,
   arch: () => process.arch,
@@ -45964,14 +46087,14 @@ function readBoundedFile(filePath, expectedPathStat) {
   let fd = null;
   try {
     const flags = fs32.constants.O_RDONLY | (O_NOFOLLOW !== undefined ? O_NOFOLLOW : 0);
-    fd = _internals67.openFile(filePath, flags);
+    fd = _internals68.openFile(filePath, flags);
   } catch {
     return { status: "incomplete", reason: "read_error" };
   }
   let outcome;
   let closeFailed = false;
   try {
-    const stat6 = _internals67.fstatFile(fd);
+    const stat6 = _internals68.fstatFile(fd);
     const descriptorIdentity = getStableFileIdentity(stat6);
     const initialSize = stat6.size;
     if (!stat6.isFile()) {
@@ -45983,14 +46106,14 @@ function readBoundedFile(filePath, expectedPathStat) {
       const buffer = Buffer.allocUnsafe(bufferLength);
       let bytesRead = 0;
       while (bytesRead < buffer.length) {
-        const count = _internals67.readFileChunk(fd, buffer, bytesRead, buffer.length - bytesRead, null);
+        const count = _internals68.readFileChunk(fd, buffer, bytesRead, buffer.length - bytesRead, null);
         if (count === 0)
           break;
         bytesRead += count;
       }
-      const postStat = _internals67.fstatFile(fd);
+      const postStat = _internals68.fstatFile(fd);
       const postDescriptorIdentity = getStableFileIdentity(postStat);
-      const postPathStat = _internals67.lstatFile(filePath);
+      const postPathStat = _internals68.lstatFile(filePath);
       const postPathIdentity = getStableFileIdentity(postPathStat);
       if (!postStat.isFile() || postDescriptorIdentity === null || postDescriptorIdentity !== descriptorIdentity || postPathStat.isSymbolicLink() || !postPathStat.isFile() || postPathIdentity === null || postPathIdentity !== descriptorIdentity) {
         outcome = { status: "incomplete", reason: "read_error" };
@@ -46012,7 +46135,7 @@ function readBoundedFile(filePath, expectedPathStat) {
   } finally {
     if (fd !== null) {
       try {
-        _internals67.closeFile(fd);
+        _internals68.closeFile(fd);
       } catch {
         closeFailed = true;
       }
@@ -46025,7 +46148,7 @@ function readBoundedFile(filePath, expectedPathStat) {
 function scanFileForSecrets(filePath, mode) {
   const findings = [];
   try {
-    const lstat3 = _internals67.lstatFile(filePath);
+    const lstat3 = _internals68.lstatFile(filePath);
     if (lstat3.isSymbolicLink()) {
       return mode === "explicit" ? { status: "incomplete", reason: "symlink" } : { status: "skipped", reason: "symlink" };
     }
@@ -46080,7 +46203,7 @@ function assertNever(value) {
   throw new Error(`Unhandled secretscan outcome: ${String(value)}`);
 }
 async function yieldToEventLoop() {
-  await new Promise((resolve24) => setImmediate(resolve24));
+  await new Promise((resolve25) => setImmediate(resolve25));
 }
 function serializeSecretscanResult(result) {
   let findings = result.findings;
@@ -46204,8 +46327,8 @@ async function collectScannableFiles(dir, excludeExact, excludeGlobs, scanDir, v
       while (true) {
         if (state.entriesSinceYield >= DISCOVERY_YIELD_INTERVAL) {
           state.entriesSinceYield = 0;
-          await _internals67.yieldToEventLoop();
-          if (_internals67.now() >= state.deadline) {
+          await _internals68.yieldToEventLoop();
+          if (_internals68.now() >= state.deadline) {
             state.deadlineExceeded = true;
             recordIncompletePath(state.incompletePaths, scanDir, currentDir, "deadline");
             stoppedEarly = true;
@@ -46268,7 +46391,7 @@ async function collectScannableFiles(dir, excludeExact, excludeGlobs, scanDir, v
       }
     } finally {
       try {
-        _internals67.closeDirectory(directory);
+        _internals68.closeDirectory(directory);
       } catch (error2) {
         if (error2.code !== "ERR_DIR_CLOSED") {
           state.cleanupFailed = true;
@@ -46390,7 +46513,7 @@ var secretscan = createSwarmTool({
         symlinkSkipped: 0
       };
       const visited = new Set;
-      const deadline = _internals67.now() + SCAN_TIME_BUDGET_MS;
+      const deadline = _internals68.now() + SCAN_TIME_BUDGET_MS;
       const discovery = {
         files: [],
         totalCandidates: 0,
@@ -46402,7 +46525,7 @@ var secretscan = createSwarmTool({
         directoriesQueued: 1,
         unexaminedDirectories: 0
       };
-      await _internals67.yieldToEventLoop();
+      await _internals68.yieldToEventLoop();
       await collectScannableFiles(scanDir, excludeExact, excludeGlobs, scanDir, visited, stats, discovery);
       const files = discovery.files;
       files.sort(compareFilePaths);
@@ -46421,7 +46544,7 @@ var secretscan = createSwarmTool({
       let skippedFiles = stats.skippedFiles;
       let incompleteFiles = stats.fileErrors + Math.max(0, discovery.totalCandidates - filesToScan.length) + (discovery.deadlineExceeded || discovery.cleanupFailed ? 1 : 0) + discovery.unexaminedDirectories;
       for (let index = 0;index < filesToScan.length; index++) {
-        if (_internals67.now() >= deadline) {
+        if (_internals68.now() >= deadline) {
           for (const remaining of filesToScan.slice(index)) {
             recordIncompletePath(discovery.incompletePaths, scanDir, remaining, "deadline");
           }
@@ -46457,7 +46580,7 @@ var secretscan = createSwarmTool({
           }
         }
         if (index + 1 < filesToScan.length) {
-          await _internals67.yieldToEventLoop();
+          await _internals68.yieldToEventLoop();
         }
       }
       allFindings.sort((a, b) => {
@@ -46520,7 +46643,7 @@ var secretscan = createSwarmTool({
 });
 async function runSecretscan(directory) {
   try {
-    const result = await _internals67.secretscan.execute({ directory }, {});
+    const result = await _internals68.secretscan.execute({ directory }, {});
     const jsonStr = typeof result === "string" ? result : result.output;
     return JSON.parse(jsonStr);
   } catch (e) {
@@ -46571,10 +46694,10 @@ async function runSecretscanOnFiles(files, directory) {
     if (files.length > filesToScan.length) {
       recordIncompletePath(incompletePaths, canonicalRoot, canonicalRoot, "max_files");
     }
-    const deadline = _internals67.now() + SCAN_TIME_BUDGET_MS;
-    await _internals67.yieldToEventLoop();
+    const deadline = _internals68.now() + SCAN_TIME_BUDGET_MS;
+    await _internals68.yieldToEventLoop();
     for (let index = 0;index < filesToScan.length; index++) {
-      if (_internals67.now() >= deadline) {
+      if (_internals68.now() >= deadline) {
         for (const remaining of filesToScan.slice(index)) {
           const remainingPath = path78.isAbsolute(remaining) ? path78.resolve(remaining) : path78.resolve(rawRoot, remaining);
           recordIncompletePath(incompletePaths, canonicalRoot, remainingPath, "deadline");
@@ -46601,7 +46724,7 @@ async function runSecretscanOnFiles(files, directory) {
       }
       let lstat3;
       try {
-        lstat3 = _internals67.lstatFile(resolvedPath);
+        lstat3 = _internals68.lstatFile(resolvedPath);
       } catch (error2) {
         const err = error2;
         if (err.code === "ENOENT") {
@@ -46670,7 +46793,7 @@ async function runSecretscanOnFiles(files, directory) {
           assertNever(outcome);
       }
       if (index + 1 < filesToScan.length) {
-        await _internals67.yieldToEventLoop();
+        await _internals68.yieldToEventLoop();
       }
     }
     findings.sort((a, b) => {
@@ -46700,7 +46823,7 @@ async function runSecretscanOnFiles(files, directory) {
     };
   }
 }
-var _internals67 = {
+var _internals68 = {
   secretscan,
   runSecretscan,
   runSecretscanOnFiles,
@@ -46984,7 +47107,7 @@ async function buildImpactMapInternal(cwd) {
   }
   return impactMap;
 }
-var _internals68 = {
+var _internals69 = {
   validateProjectRoot,
   normalizePath: normalizePath2,
   isCacheStale,
@@ -46999,8 +47122,8 @@ var _internals68 = {
   _clearGoModuleCache
 };
 async function buildImpactMap(cwd) {
-  const impactMap = await _internals68.buildImpactMapInternal(cwd);
-  await _internals68.saveImpactMap(cwd, impactMap);
+  const impactMap = await _internals69.buildImpactMapInternal(cwd);
+  await _internals69.saveImpactMap(cwd, impactMap);
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
@@ -47014,7 +47137,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 (!_internals68.isCacheStale(map, generatedAt)) {
+          if (!_internals69.isCacheStale(map, generatedAt)) {
             return map;
           }
           if (options?.skipRebuild) {
@@ -47034,13 +47157,13 @@ async function loadImpactMap(cwd, options) {
   if (options?.skipRebuild) {
     return {};
   }
-  return _internals68.buildImpactMap(cwd);
+  return _internals69.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
   if (!path79.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
-  _internals68.validateProjectRoot(cwd);
+  _internals69.validateProjectRoot(cwd);
   const cacheDir2 = path79.join(cwd, ".swarm", "cache");
   const cachePath = path79.join(cacheDir2, "impact-map.json");
   if (!fs33.existsSync(cacheDir2)) {
@@ -47064,7 +47187,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
     };
   }
   const validFiles = changedFiles.filter((f) => typeof f === "string" && f.length > 0 && !f.includes("\x00"));
-  const impactMap = await _internals68.loadImpactMap(cwd);
+  const impactMap = await _internals69.loadImpactMap(cwd);
   const impactedTestsSet = new Set;
   const untestedFiles = [];
   let visitedCount = 0;
@@ -47341,7 +47464,7 @@ function batchAppendTestRuns(records, workingDir) {
   }
   const historyPath = getHistoryPath(workingDir);
   const historyDir = path80.dirname(historyPath);
-  _internals69.validateProjectRoot(workingDir);
+  _internals70.validateProjectRoot(workingDir);
   if (!fs34.existsSync(historyDir)) {
     fs34.mkdirSync(historyDir, { recursive: true });
   }
@@ -47464,7 +47587,7 @@ function getAllHistory(workingDir) {
   records.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
   return records;
 }
-var _internals69 = {
+var _internals70 = {
   validateProjectRoot
 };
 
@@ -47575,7 +47698,7 @@ var MAX_SAFE_TEST_FILES = 50;
 var MAX_SAFE_SOURCE_FILES = 1;
 async function estimateFanOut(sourceFiles, cwd) {
   try {
-    const impactMap = await _internals70.loadImpactMap(cwd, {
+    const impactMap = await _internals71.loadImpactMap(cwd, {
       skipRebuild: true
     });
     const uniqueTestFiles = new Set;
@@ -47665,45 +47788,45 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return _internals70.existsSync(path82.join(cwd, "go.mod")) && _internals70.isCommandAvailable("go");
+  return _internals71.existsSync(path82.join(cwd, "go.mod")) && _internals71.isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return _internals70.existsSync(path82.join(cwd, "pom.xml")) && _internals70.isCommandAvailable("mvn");
+  return _internals71.existsSync(path82.join(cwd, "pom.xml")) && _internals71.isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = _internals70.existsSync(path82.join(cwd, "build.gradle")) || _internals70.existsSync(path82.join(cwd, "build.gradle.kts"));
-  const hasGradlew = _internals70.existsSync(path82.join(cwd, "gradlew")) || _internals70.existsSync(path82.join(cwd, "gradlew.bat"));
-  return hasBuildFile && (hasGradlew || _internals70.isCommandAvailable("gradle"));
+  const hasBuildFile = _internals71.existsSync(path82.join(cwd, "build.gradle")) || _internals71.existsSync(path82.join(cwd, "build.gradle.kts"));
+  const hasGradlew = _internals71.existsSync(path82.join(cwd, "gradlew")) || _internals71.existsSync(path82.join(cwd, "gradlew.bat"));
+  return hasBuildFile && (hasGradlew || _internals71.isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
   try {
-    const files = _internals70.readdirSync(cwd);
+    const files = _internals71.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj"));
-    return hasCsproj && _internals70.isCommandAvailable("dotnet");
+    return hasCsproj && _internals71.isCommandAvailable("dotnet");
   } catch {
     return false;
   }
 }
 function detectCTest(cwd) {
-  const hasSource = _internals70.existsSync(path82.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = _internals70.existsSync(path82.join(cwd, "CMakeCache.txt")) || _internals70.existsSync(path82.join(cwd, "build", "CMakeCache.txt"));
-  return (hasSource || hasBuildCache) && _internals70.isCommandAvailable("ctest");
+  const hasSource = _internals71.existsSync(path82.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = _internals71.existsSync(path82.join(cwd, "CMakeCache.txt")) || _internals71.existsSync(path82.join(cwd, "build", "CMakeCache.txt"));
+  return (hasSource || hasBuildCache) && _internals71.isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return _internals70.existsSync(path82.join(cwd, "Package.swift")) && _internals70.isCommandAvailable("swift");
+  return _internals71.existsSync(path82.join(cwd, "Package.swift")) && _internals71.isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return _internals70.existsSync(path82.join(cwd, "pubspec.yaml")) && (_internals70.isCommandAvailable("dart") || _internals70.isCommandAvailable("flutter"));
+  return _internals71.existsSync(path82.join(cwd, "pubspec.yaml")) && (_internals71.isCommandAvailable("dart") || _internals71.isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = _internals70.existsSync(path82.join(cwd, ".rspec"));
-  const hasGemfile = _internals70.existsSync(path82.join(cwd, "Gemfile"));
-  const hasSpecDir = _internals70.existsSync(path82.join(cwd, "spec"));
+  const hasRSpecFile = _internals71.existsSync(path82.join(cwd, ".rspec"));
+  const hasGemfile = _internals71.existsSync(path82.join(cwd, "Gemfile"));
+  const hasSpecDir = _internals71.existsSync(path82.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
-  return hasRSpec && (_internals70.isCommandAvailable("bundle") || _internals70.isCommandAvailable("rspec"));
+  return hasRSpec && (_internals71.isCommandAvailable("bundle") || _internals71.isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return _internals70.existsSync(path82.join(cwd, "test")) && (_internals70.existsSync(path82.join(cwd, "Gemfile")) || _internals70.existsSync(path82.join(cwd, "Rakefile"))) && _internals70.isCommandAvailable("ruby");
+  return _internals71.existsSync(path82.join(cwd, "test")) && (_internals71.existsSync(path82.join(cwd, "Gemfile")) || _internals71.existsSync(path82.join(cwd, "Rakefile"))) && _internals71.isCommandAvailable("ruby");
 }
 var DISPATCH_FRAMEWORK_MAP = {
   bun: "bun",
@@ -47794,8 +47917,8 @@ async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
     const packageJsonPath = path82.join(baseDir, "package.json");
-    if (_internals70.existsSync(packageJsonPath)) {
-      const content = _internals70.readFileSync(packageJsonPath, "utf-8");
+    if (_internals71.existsSync(packageJsonPath)) {
+      const content = _internals71.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       const _deps = pkg.dependencies || {};
       const devDeps = pkg.devDependencies || {};
@@ -47814,7 +47937,7 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (_internals70.existsSync(path82.join(baseDir, "bun.lockb")) || _internals70.existsSync(path82.join(baseDir, "bun.lock"))) {
+      if (_internals71.existsSync(path82.join(baseDir, "bun.lockb")) || _internals71.existsSync(path82.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
@@ -47824,28 +47947,28 @@ async function detectTestFramework(cwd) {
     const pyprojectTomlPath = path82.join(baseDir, "pyproject.toml");
     const setupCfgPath = path82.join(baseDir, "setup.cfg");
     const requirementsTxtPath = path82.join(baseDir, "requirements.txt");
-    if (_internals70.existsSync(pyprojectTomlPath)) {
-      const content = _internals70.readFileSync(pyprojectTomlPath, "utf-8");
+    if (_internals71.existsSync(pyprojectTomlPath)) {
+      const content = _internals71.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
         return "pytest";
       if (content.includes("pytest"))
         return "pytest";
     }
-    if (_internals70.existsSync(setupCfgPath)) {
-      const content = _internals70.readFileSync(setupCfgPath, "utf-8");
+    if (_internals71.existsSync(setupCfgPath)) {
+      const content = _internals71.readFileSync(setupCfgPath, "utf-8");
       if (content.includes("[pytest]"))
         return "pytest";
     }
-    if (_internals70.existsSync(requirementsTxtPath)) {
-      const content = _internals70.readFileSync(requirementsTxtPath, "utf-8");
+    if (_internals71.existsSync(requirementsTxtPath)) {
+      const content = _internals71.readFileSync(requirementsTxtPath, "utf-8");
       if (content.includes("pytest"))
         return "pytest";
     }
   } catch {}
   try {
     const cargoTomlPath = path82.join(baseDir, "Cargo.toml");
-    if (_internals70.existsSync(cargoTomlPath)) {
-      const content = _internals70.readFileSync(cargoTomlPath, "utf-8");
+    if (_internals71.existsSync(cargoTomlPath)) {
+      const content = _internals71.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
         if (content.includes("tokio") || content.includes("mockall") || content.includes("pretty_assertions")) {
           return "cargo";
@@ -47857,7 +47980,7 @@ async function detectTestFramework(cwd) {
     const pesterConfigPath = path82.join(baseDir, "pester.config.ps1");
     const pesterConfigJsonPath = path82.join(baseDir, "pester.config.ps1.json");
     const pesterPs1Path = path82.join(baseDir, "tests.ps1");
-    if (_internals70.existsSync(pesterConfigPath) || _internals70.existsSync(pesterConfigJsonPath) || _internals70.existsSync(pesterPs1Path)) {
+    if (_internals71.existsSync(pesterConfigPath) || _internals71.existsSync(pesterConfigJsonPath) || _internals71.existsSync(pesterPs1Path)) {
       return "pester";
     }
   } catch {}
@@ -47885,12 +48008,12 @@ async function detectTestFramework(cwd) {
   return "none";
 }
 function detectPhpTest(cwd) {
-  if (_internals70.existsSync(path82.join(cwd, "artisan")) && _internals70.existsSync(path82.join(cwd, "composer.json"))) {
+  if (_internals71.existsSync(path82.join(cwd, "artisan")) && _internals71.existsSync(path82.join(cwd, "composer.json"))) {
     return "php-artisan";
   }
-  if (_internals70.existsSync(path82.join(cwd, "Pest.php")))
+  if (_internals71.existsSync(path82.join(cwd, "Pest.php")))
     return "pest";
-  if (_internals70.existsSync(path82.join(cwd, "phpunit.xml")) || _internals70.existsSync(path82.join(cwd, "phpunit.xml.dist"))) {
+  if (_internals71.existsSync(path82.join(cwd, "phpunit.xml")) || _internals71.existsSync(path82.join(cwd, "phpunit.xml.dist"))) {
     return "phpunit";
   }
   return null;
@@ -48272,9 +48395,9 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
     case "swift-test":
       return ["swift", "test"];
     case "dart-test":
-      return _internals70.isCommandAvailable("flutter") ? ["flutter", "test", ...files] : ["dart", "test", ...files];
+      return _internals71.isCommandAvailable("flutter") ? ["flutter", "test", ...files] : ["dart", "test", ...files];
     case "rspec": {
-      const args = _internals70.isCommandAvailable("bundle") ? ["bundle", "exec", "rspec"] : ["rspec"];
+      const args = _internals71.isCommandAvailable("bundle") ? ["bundle", "exec", "rspec"] : ["rspec"];
       if (bail)
         args.push("--fail-fast");
       if (scope !== "all" && files.length > 0) {
@@ -48754,9 +48877,9 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
       stderr: "pipe",
       cwd
     });
-    const timeoutPromise = new Promise((resolve26) => setTimeout(() => {
+    const timeoutPromise = new Promise((resolve27) => setTimeout(() => {
       proc.kill();
-      resolve26(-1);
+      resolve27(-1);
     }, timeout_ms));
     const [exitCode, stdoutResult, stderrResult] = await Promise.all([
       Promise.race([proc.exited, timeoutPromise]),
@@ -49287,7 +49410,7 @@ var test_runner = createSwarmTool({
         return JSON.stringify(errorResult, null, 2);
       }
       try {
-        const impactResult = await _internals70.analyzeImpact(sourceFiles, workingDir, MAX_SAFE_TEST_FILES);
+        const impactResult = await _internals71.analyzeImpact(sourceFiles, workingDir, MAX_SAFE_TEST_FILES);
         if (impactResult.budgetExceeded) {
           const errorResult = {
             success: false,
@@ -49377,7 +49500,7 @@ var test_runner = createSwarmTool({
     return JSON.stringify(result, null, 2);
   }
 });
-var _internals70 = {
+var _internals71 = {
   analyzeImpact,
   loadImpactMap,
   isCommandAvailable,
@@ -49479,9 +49602,9 @@ function getVersionFileVersion(dir) {
 async function runVersionCheck(dir, _timeoutMs) {
   const startTime = Date.now();
   try {
-    const packageVersion = _internals71.getPackageVersion(dir);
-    const changelogVersion = _internals71.getChangelogVersion(dir);
-    const versionFileVersion = _internals71.getVersionFileVersion(dir);
+    const packageVersion = _internals72.getPackageVersion(dir);
+    const changelogVersion = _internals72.getChangelogVersion(dir);
+    const versionFileVersion = _internals72.getVersionFileVersion(dir);
     const versions = [];
     if (packageVersion)
       versions.push(`package.json: ${packageVersion}`);
@@ -49670,7 +49793,7 @@ async function runTestsCheck(_dir, scope, timeoutMs) {
 async function runSecretsCheck(dir, timeoutMs) {
   const startTime = Date.now();
   try {
-    const secretsPromise = _internals71.runSecretscan(dir);
+    const secretsPromise = _internals72.runSecretscan(dir);
     const timeoutPromise = new Promise((_, reject) => {
       setTimeout(() => {
         reject(new Error(`Secrets check timed out after ${timeoutMs}ms`));
@@ -49892,7 +50015,7 @@ async function runPreflight(dir, phase, config) {
   const reportId = `preflight-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   let validatedDir;
   try {
-    validatedDir = _internals71.validateDirectoryPath(dir);
+    validatedDir = _internals72.validateDirectoryPath(dir);
   } catch (error2) {
     return {
       id: reportId,
@@ -49912,7 +50035,7 @@ async function runPreflight(dir, phase, config) {
   }
   let validatedTimeout;
   try {
-    validatedTimeout = _internals71.validateTimeout(config?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
+    validatedTimeout = _internals72.validateTimeout(config?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
   } catch (error2) {
     return {
       id: reportId,
@@ -49953,12 +50076,12 @@ async function runPreflight(dir, phase, config) {
   });
   const checks = [];
   log("[Preflight] Running lint check...");
-  const lintResult = await _internals71.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
+  const lintResult = await _internals72.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 _internals71.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
+    const testsResult = await _internals72.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
     checks.push(testsResult);
     log(`[Preflight] Tests check: ${testsResult.status} ${testsResult.message}`);
   } else {
@@ -49970,7 +50093,7 @@ async function runPreflight(dir, phase, config) {
   }
   if (!cfg.skipSecrets) {
     log("[Preflight] Running secrets check...");
-    const secretsResult = await _internals71.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
+    const secretsResult = await _internals72.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
     checks.push(secretsResult);
     log(`[Preflight] Secrets check: ${secretsResult.status} ${secretsResult.message}`);
   } else {
@@ -49982,7 +50105,7 @@ async function runPreflight(dir, phase, config) {
   }
   if (!cfg.skipEvidence) {
     log("[Preflight] Running evidence check...");
-    const evidenceResult = await _internals71.runEvidenceCheck(validatedDir);
+    const evidenceResult = await _internals72.runEvidenceCheck(validatedDir);
     checks.push(evidenceResult);
     log(`[Preflight] Evidence check: ${evidenceResult.status} ${evidenceResult.message}`);
   } else {
@@ -49993,12 +50116,12 @@ async function runPreflight(dir, phase, config) {
     });
   }
   log("[Preflight] Running requirement coverage check...");
-  const reqCoverageResult = await _internals71.runRequirementCoverageCheck(validatedDir, phase);
+  const reqCoverageResult = await _internals72.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 _internals71.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
+    const versionResult = await _internals72.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
     checks.push(versionResult);
     log(`[Preflight] Version check: ${versionResult.status} ${versionResult.message}`);
   } else {
@@ -50061,10 +50184,10 @@ function formatPreflightMarkdown(report) {
 async function handlePreflightCommand(directory, _args) {
   const plan = await loadPlan(directory);
   const phase = plan?.current_phase ?? 1;
-  const report = await _internals71.runPreflight(directory, phase);
-  return _internals71.formatPreflightMarkdown(report);
+  const report = await _internals72.runPreflight(directory, phase);
+  return _internals72.formatPreflightMarkdown(report);
 }
-var _internals71 = {
+var _internals72 = {
   runPreflight,
   formatPreflightMarkdown,
   handlePreflightCommand,
@@ -50347,13 +50470,13 @@ class CircuitBreaker {
     if (this.config.callTimeoutMs <= 0) {
       return fn();
     }
-    return new Promise((resolve27, reject) => {
+    return new Promise((resolve28, reject) => {
       const timeout = setTimeout(() => {
         reject(new Error(`Call timeout after ${this.config.callTimeoutMs}ms`));
       }, this.config.callTimeoutMs);
       fn().then((result) => {
         clearTimeout(timeout);
-        resolve27(result);
+        resolve28(result);
       }).catch((error2) => {
         clearTimeout(timeout);
         reject(error2);
@@ -50652,7 +50775,7 @@ class AutomationQueue {
 
 // src/background/worker.ts
 function sleep(ms) {
-  return new Promise((resolve27) => setTimeout(resolve27, ms));
+  return new Promise((resolve28) => setTimeout(resolve28, ms));
 }
 
 class WorkerManager {
@@ -51063,7 +51186,7 @@ function pruneOldResetBackups(backupsRoot, warnings) {
 }
 
 // src/commands/reset.ts
-var _internals72 = {
+var _internals73 = {
   backupSwarmStateBeforeReset
 };
 async function handleResetCommand(directory, args) {
@@ -51096,11 +51219,13 @@ async function handleResetCommand(directory, args) {
     "events.jsonl",
     "run-memory.jsonl",
     "reproduction.json",
-    "issue-publication.json"
+    "issue-publication.json",
+    "recurrence-sweep.json",
+    "implementation-review.json"
   ];
   const results = [];
   try {
-    const backup = _internals72.backupSwarmStateBeforeReset(directory, "reset", [
+    const backup = _internals73.backupSwarmStateBeforeReset(directory, "reset", [
       ...filesToReset,
       "summaries"
     ]);
@@ -51210,7 +51335,7 @@ function clearTrajectoryStep(sessionId) {
 }
 
 // src/commands/reset-session.ts
-var _internals73 = {
+var _internals74 = {
   cleanupOrphanedBranches,
   backupSwarmStateBeforeReset
 };
@@ -51222,7 +51347,7 @@ function errorMessage(err) {
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
-    const backup = _internals73.backupSwarmStateBeforeReset(directory, "reset-session", ["session"]);
+    const backup = _internals74.backupSwarmStateBeforeReset(directory, "reset-session", ["session"]);
     if (backup.backupDir && backup.copied.length > 0) {
       const rel = path86.relative(directory, backup.backupDir);
       results.push(`\uD83D\uDCE6 Backed up session state to ${rel}/ (restore by copying files back into .swarm/session/)`);
@@ -51289,7 +51414,7 @@ async function handleResetSessionCommand(directory, _args) {
     results.push(`\u26A0\uFE0F Failed to remove .swarm-worktrees/: ${errorMessage(err)}`);
   }
   try {
-    const branchResult = await _internals73.cleanupOrphanedBranches(directory, []);
+    const branchResult = await _internals74.cleanupOrphanedBranches(directory, []);
     if (branchResult.removed.length > 0) {
       results.push(`\u2705 Removed ${branchResult.removed.length} orphan swarm-lane branch(es)`);
     }
@@ -51448,7 +51573,7 @@ function resolveReceiptsDir(directory) {
 function resolveReceiptIndexPath(directory) {
   return path88.join(resolveReceiptsDir(directory), "index.json");
 }
-var _internals74 = {
+var _internals75 = {
   openSync: fs41.openSync,
   lstatBigIntSync: (path89) => fs41.lstatSync(path89, { bigint: true }),
   fstatBigIntSync: (fd) => fs41.fstatSync(fd, { bigint: true })
@@ -51460,7 +51585,7 @@ function pathsEqual(left, right) {
 }
 function captureCanonicalDirectory(directory, label, expected) {
   const resolved = path88.resolve(directory);
-  const stat6 = _internals74.lstatBigIntSync(resolved);
+  const stat6 = _internals75.lstatBigIntSync(resolved);
   if (!stat6.isDirectory() || stat6.isSymbolicLink()) {
     throw new Error(`${label} must be a real directory`);
   }
@@ -51546,7 +51671,7 @@ function assertDirectReceiptFile(context, filePath, mustExist) {
     throw new Error("review receipt file escapes its expected directory");
   }
   try {
-    const stat6 = _internals74.lstatBigIntSync(resolved);
+    const stat6 = _internals75.lstatBigIntSync(resolved);
     if (!stat6.isFile() || stat6.isSymbolicLink()) {
       throw new Error("review receipt path must be a real file");
     }
@@ -51570,7 +51695,7 @@ function readReviewReceiptText(directory, receiptPath, maxBytes = 1048576) {
     const resolved = assertDirectReceiptFile(context, receiptPath, true);
     if (path88.extname(resolved) !== ".json")
       return null;
-    const pathBeforeOpen = _internals74.lstatBigIntSync(resolved);
+    const pathBeforeOpen = _internals75.lstatBigIntSync(resolved);
     if (!pathBeforeOpen.isFile() || pathBeforeOpen.isSymbolicLink() || pathBeforeOpen.size < 0n || pathBeforeOpen.size > BigInt(maxBytes)) {
       return null;
     }
@@ -51578,10 +51703,10 @@ function readReviewReceiptText(directory, receiptPath, maxBytes = 1048576) {
     if (!pathsEqual(canonicalBeforeOpen, resolved))
       return null;
     assertReceiptContextCurrent(context);
-    descriptor = _internals74.openSync(canonicalBeforeOpen, "r");
-    const openedBeforeRead = _internals74.fstatBigIntSync(descriptor);
+    descriptor = _internals75.openSync(canonicalBeforeOpen, "r");
+    const openedBeforeRead = _internals75.fstatBigIntSync(descriptor);
     assertReceiptContextCurrent(context);
-    const pathAfterOpen = _internals74.lstatBigIntSync(resolved);
+    const pathAfterOpen = _internals75.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;
@@ -51594,9 +51719,9 @@ function readReviewReceiptText(directory, receiptPath, maxBytes = 1048576) {
         break;
       bytesRead += count;
     }
-    const openedAfterRead = _internals74.fstatBigIntSync(descriptor);
+    const openedAfterRead = _internals75.fstatBigIntSync(descriptor);
     assertReceiptContextCurrent(context);
-    const pathAfterRead = _internals74.lstatBigIntSync(resolved);
+    const pathAfterRead = _internals75.lstatBigIntSync(resolved);
     const canonicalAfterRead = fs41.realpathSync(resolved);
     if (bytesRead !== buffer.length || !sameFileSnapshot2(openedBeforeRead, openedAfterRead) || !sameFileSnapshot2(openedAfterRead, pathAfterRead) || !pathsEqual(canonicalBeforeOpen, canonicalAfterRead)) {
       return null;
@@ -52140,7 +52265,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 _internals75 = {
+var _internals76 = {
   spawn: child_process6.spawn,
   realpath: fs42.promises.realpath,
   lstatBigInt: (path90) => fs42.promises.lstat(path90, { bigint: true }),
@@ -52180,7 +52305,7 @@ async function missingPathParentIsContained(root, absolutePath2) {
   let current = path89.dirname(absolutePath2);
   for (;; ) {
     try {
-      const canonical = await _internals75.realpath(current);
+      const canonical = await _internals76.realpath(current);
       return samePath2(root, canonical) || isContained2(root, canonical);
     } catch (error2) {
       if (error2.code !== "ENOENT")
@@ -52207,13 +52332,13 @@ async function resolveHeadSha(directory) {
   let child;
   let timeoutHandle;
   try {
-    child = _internals75.spawn("git", ["rev-parse", "--verify", "HEAD"], {
+    child = _internals76.spawn("git", ["rev-parse", "--verify", "HEAD"], {
       cwd: directory,
       stdio: ["ignore", "pipe", "ignore"],
       timeout: HEAD_TIMEOUT_MS,
       windowsHide: true
     });
-    return await new Promise((resolve30) => {
+    return await new Promise((resolve31) => {
       let settled = false;
       let stdoutBytes = 0;
       const stdoutChunks = [];
@@ -52223,7 +52348,7 @@ async function resolveHeadSha(directory) {
         settled = true;
         if (timeoutHandle !== undefined)
           clearTimeout(timeoutHandle);
-        resolve30(value);
+        resolve31(value);
       };
       const killAndFail = () => {
         try {
@@ -52270,7 +52395,7 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
   let realRoot;
   try {
     lexicalRoot = path89.resolve(directory);
-    realRoot = await _internals75.realpath(lexicalRoot);
+    realRoot = await _internals76.realpath(lexicalRoot);
   } catch {
     return null;
   }
@@ -52311,7 +52436,7 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
   for (const candidate of ordered) {
     let before;
     try {
-      before = await _internals75.lstatBigInt(candidate.absolutePath);
+      before = await _internals76.lstatBigInt(candidate.absolutePath);
     } catch (error2) {
       if (error2.code === "ENOENT") {
         if (!await missingPathParentIsContained(realRoot, candidate.absolutePath)) {
@@ -52330,7 +52455,7 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
       return null;
     let realCandidate;
     try {
-      realCandidate = await _internals75.realpath(candidate.absolutePath);
+      realCandidate = await _internals76.realpath(candidate.absolutePath);
     } catch {
       return null;
     }
@@ -52342,15 +52467,15 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
     let bytes;
     let openedBefore;
     try {
-      handle = await _internals75.open(realCandidate, "r");
-      openedBefore = await _internals75.fileHandleStatBigInt(handle);
-      const canonicalAfterOpen = await _internals75.realpath(candidate.absolutePath);
+      handle = await _internals76.open(realCandidate, "r");
+      openedBefore = await _internals76.fileHandleStatBigInt(handle);
+      const canonicalAfterOpen = await _internals76.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 _internals75.fileHandleStatBigInt(handle);
-      const canonicalAfterRead = await _internals75.realpath(candidate.absolutePath);
+      const openedAfter = await _internals76.fileHandleStatBigInt(handle);
+      const canonicalAfterRead = await _internals76.realpath(candidate.absolutePath);
       if (!sameFileSnapshot3(openedBefore, openedAfter) || !samePath2(realCandidate, canonicalAfterRead) || !isContained2(realRoot, canonicalAfterRead) || BigInt(bytes.byteLength) !== openedBefore.size) {
         return null;
       }
@@ -52374,8 +52499,8 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
   }
   for (const stable of stableFiles) {
     try {
-      const current = await _internals75.lstatBigInt(stable.absolutePath);
-      const canonical = await _internals75.realpath(stable.absolutePath);
+      const current = await _internals76.lstatBigInt(stable.absolutePath);
+      const canonical = await _internals76.realpath(stable.absolutePath);
       if (!current.isFile() || current.isSymbolicLink() || !sameFileSnapshot3(stable.stat, current) || !samePath2(stable.canonicalPath, canonical) || !isContained2(realRoot, canonical)) {
         return null;
       }
@@ -52385,7 +52510,7 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
   }
   for (const deletedPath of deletedPaths) {
     try {
-      await _internals75.lstatBigInt(deletedPath);
+      await _internals76.lstatBigInt(deletedPath);
       return null;
     } catch (error2) {
       if (error2.code !== "ENOENT" || !await missingPathParentIsContained(realRoot, deletedPath)) {
@@ -52548,7 +52673,7 @@ function parseReviewerOutput(text, options = {}) {
     outputMode: "legacy"
   };
 }
-var _internals76 = {
+var _internals77 = {
   delegationEnd: telemetry.delegationEnd,
   resolveReviewerTaskScope,
   buildReviewerTaskScope,
@@ -52754,7 +52879,7 @@ function scopeFreshnessMismatches(reviewed, current) {
 }
 function createScopeVerifier(input, reviewed, maxBytes) {
   return async () => {
-    const current = await _internals77.collectReviewDiff({
+    const current = await _internals78.collectReviewDiff({
       directory: input.directory,
       selector: input.selector,
       maxBytes
@@ -52763,7 +52888,7 @@ function createScopeVerifier(input, reviewed, maxBytes) {
   };
 }
 async function stalePersistenceResult(input, maxBytes, message, modelCalls) {
-  const current = await _internals77.collectReviewDiff({
+  const current = await _internals78.collectReviewDiff({
     directory: input.directory,
     selector: input.selector,
     maxBytes
@@ -53142,7 +53267,7 @@ async function persistErrorResult(input, diff, result, error2, dispatches, promp
   evidence2.review.error = error2;
   addCost(evidence2, dispatches);
   try {
-    result.evidencePath = await _internals77.persistEvidence(input.directory, evidence2);
+    result.evidencePath = await _internals78.persistEvidence(input.directory, evidence2);
   } catch {
     if (input.config.final_review.mode === "gate") {
       result.blocked = true;
@@ -53158,7 +53283,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 _internals77.collectReviewDiff({
+  const diff = await _internals78.collectReviewDiff({
     directory: input.directory,
     selector: input.selector,
     maxBytes
@@ -53172,7 +53297,7 @@ async function runReviewEngine(input) {
     const evidence3 = baseEvidence(input, diff, "clean");
     let evidencePath2;
     try {
-      evidencePath2 = await _internals77.persistEvidence(input.directory, evidence3, { verifyCurrent: createScopeVerifier(input, diff, maxBytes) });
+      evidencePath2 = await _internals78.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);
@@ -53194,7 +53319,7 @@ async function runReviewEngine(input) {
     phase: input.phase
   });
   if (input.phase !== undefined && (input.trigger === "phase_completion" || input.trigger === "plan_completion")) {
-    const existing = _internals77.readPhaseEvidence(input.directory, input.phase);
+    const existing = _internals78.readPhaseEvidence(input.directory, input.phase);
     const integrity = existing ? validateAutoReviewEvidenceIntegrity(input.directory, existing, {
       scopeHash: diff.scopeHash,
       phase: input.phase,
@@ -53320,7 +53445,7 @@ async function runReviewEngine(input) {
       validation: byId.get(finding.finding_id)
     }));
   }
-  const currentScope = await _internals77.collectReviewDiff({
+  const currentScope = await _internals78.collectReviewDiff({
     directory: input.directory,
     selector: input.selector,
     maxBytes
@@ -53399,7 +53524,7 @@ async function runReviewEngine(input) {
       findingValidations: findings.map((finding) => finding.validation).filter((item) => Boolean(item))
     });
     receiptId = receipt.id;
-    receiptPath = await _internals77.persistReceipt(input.directory, receipt, {
+    receiptPath = await _internals78.persistReceipt(input.directory, receipt, {
       verifyCurrent: createScopeVerifier(input, diff, maxBytes)
     });
     evidence2.receipt_path = receiptPath;
@@ -53429,7 +53554,7 @@ async function runReviewEngine(input) {
   }
   let evidencePath;
   try {
-    evidencePath = await _internals77.persistEvidence(input.directory, evidence2, {
+    evidencePath = await _internals78.persistEvidence(input.directory, evidence2, {
       verifyCurrent: createScopeVerifier(input, diff, maxBytes)
     });
   } catch (error2) {
@@ -53466,7 +53591,7 @@ async function runReviewEngine(input) {
   input.injectAdvisory?.(input.sessionID, advisoryMessage(input, result));
   return result;
 }
-var _internals77 = {
+var _internals78 = {
   collectReviewDiff,
   persistEvidence: persistAutoReviewEvidence,
   persistReceipt: persistReviewReceipt,
@@ -53737,7 +53862,7 @@ async function handleReviewCommand(ctx) {
   } catch (error2) {
     return `Review configuration error: ${error2 instanceof Error ? error2.message : String(error2)}`;
   }
-  const result = await _internals78.runReviewEngine({
+  const result = await _internals79.runReviewEngine({
     directory: ctx.directory,
     sessionID: ctx.sessionID,
     trigger: "manual",
@@ -53751,10 +53876,10 @@ async function handleReviewCommand(ctx) {
     validatorModel,
     validatorFallbackModels
   });
-  const evidence2 = _internals78.readEvidence(result.evidencePath, ctx.directory);
+  const evidence2 = _internals79.readEvidence(result.evidencePath, ctx.directory);
   return parsed.json ? renderJson(result, evidence2, parsed.selector) : renderHuman(result, evidence2, parsed.selector);
 }
-var _internals78 = {
+var _internals79 = {
   runReviewEngine,
   readEvidence
 };
@@ -54000,7 +54125,7 @@ async function handleRollbackCommand(directory, args) {
 // src/commands/sdd.ts
 import * as fs47 from "fs";
 import * as path94 from "path";
-var _internals79 = {
+var _internals80 = {
   writeProjectedSpecSync
 };
 var SWARM_SPEC_REL = path94.join(".swarm", "spec.md");
@@ -54023,6 +54148,9 @@ Spec-Kit SDD support:
   - detects .specify/ marker + specs/NNN-feature-name/spec.md layout
   - projects a single Spec-Kit feature into .swarm/spec.md via /swarm sdd project
   - use --source speckit or --source openspec to disambiguate when both are present`;
+function allowedMutationsFor(source) {
+  return source === "swarm" ? ["create", "refine", "archive"] : ["none (read-only input; refine in the source tool)"];
+}
 function isUnsafeId(value) {
   return value.includes("/") || value.includes("\\") || value.includes("..") || value.includes("[") || value.includes("]") || containsControlChars(value);
 }
@@ -54170,7 +54298,8 @@ ${speckitDetection.features.map((f) => `- ${f.featureId}`).join(`
     "### Effective Spec",
     status.effectiveSpec ? `- source: ${status.effectiveSpec.source}
 - hash: ${status.effectiveSpec.hash}
-- sources: ${status.effectiveSpec.sourcePaths.length}` : "- none",
+- path(s): ${status.effectiveSpec.sourcePaths.join(", ")}
+- allowed mutations: ${allowedMutationsFor(status.effectiveSpec.source).join(", ")}` : "- none",
     status.errors.length > 0 ? `
 ### Errors
 ${formatList(status.errors)}` : "",
@@ -54396,7 +54525,7 @@ ${USAGE12}`;
 
 ${USAGE12}`;
     }
-    const result2 = _internals79.writeProjectedSpecSync(directory, {
+    const result2 = _internals80.writeProjectedSpecSync(directory, {
       source: "speckit",
       feature: resolution.feature,
       dryRun: parsed.dryRun,
@@ -54454,7 +54583,7 @@ ${formatList(result2.projection.warnings)}` : ""
     ].join(`
 `);
   }
-  const result = _internals79.writeProjectedSpecSync(directory, {
+  const result = _internals80.writeProjectedSpecSync(directory, {
     changeId: parsed.changeId,
     dryRun: parsed.dryRun,
     overwrite: parsed.overwrite
@@ -54535,7 +54664,7 @@ async function handleSimulateCommand(directory, args) {
   }
   let darkMatterPairs;
   try {
-    darkMatterPairs = await _internals41.detectDarkMatter(directory, options);
+    darkMatterPairs = await _internals42.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Simulate Report
@@ -54693,7 +54822,7 @@ function writeFileFsyncedThenRename(tempPath, targetPath, data) {
     throw err;
   }
 }
-var _internals80 = {
+var _internals81 = {
   withEvidenceLock,
   writeFileFsyncedThenRename,
   writeFileSync: writeFileSyncAsync,
@@ -54712,7 +54841,7 @@ async function appendEvent(directory, eventInput) {
     throw new Error(`invalid candidate id: ${eventInput.candidateId}`);
   }
   const filePath = ledgerPath(directory, eventInput.skillSlug, eventInput.candidateId);
-  return _internals80.withEvidenceLock(directory, path95.join(".swarm", "evolution", "skills", eventInput.skillSlug, eventInput.candidateId, "lifecycle.jsonl"), "skill-opt-ledger", "append-skill-opt-event", async () => {
+  return _internals81.withEvidenceLock(directory, path95.join(".swarm", "evolution", "skills", eventInput.skillSlug, eventInput.candidateId, "lifecycle.jsonl"), "skill-opt-ledger", "append-skill-opt-event", async () => {
     ensureCandidateDir(directory, eventInput.skillSlug, eventInput.candidateId);
     const existing = existsSync52(filePath) ? readFileSync39(filePath, "utf8") : "";
     const events = parseEventsFromText(existing);
@@ -54744,8 +54873,8 @@ async function appendEvent(directory, eventInput) {
     const validContent = events.map((e) => JSON.stringify(e)).join(`
 `) + (events.length > 0 ? `
 ` : "");
-    _internals80.writeFileFsyncedThenRename(tempPath, filePath, validContent + line);
-    const verify = parseEventsFromText(_internals80.readFileSync(filePath, "utf8"));
+    _internals81.writeFileFsyncedThenRename(tempPath, filePath, validContent + line);
+    const verify = parseEventsFromText(_internals81.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}`);
@@ -54849,7 +54978,7 @@ function writeStateProjection(directory, skillSlug, candidateId2, replay) {
     updatedAt: new Date().toISOString()
   };
   const tempPath = `${target}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
-  _internals80.writeFileFsyncedThenRename(tempPath, target, `${JSON.stringify(projection, null, 2)}
+  _internals81.writeFileFsyncedThenRename(tempPath, target, `${JSON.stringify(projection, null, 2)}
 `);
 }
 function writeArtifact(directory, skillSlug, candidateId2, fileName, content) {
@@ -54857,7 +54986,7 @@ function writeArtifact(directory, skillSlug, candidateId2, fileName, content) {
   const dir = ensureCandidateDir(directory, skillSlug, candidateId2);
   const target = path95.join(dir, fileName);
   const tempPath = `${target}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
-  _internals80.writeFileFsyncedThenRename(tempPath, target, content);
+  _internals81.writeFileFsyncedThenRename(tempPath, target, content);
   return target;
 }
 function readArtifact(directory, skillSlug, candidateId2, fileName) {
@@ -54950,16 +55079,16 @@ function currentCandidateState(directory, skillSlug, candidateId2) {
 function writeSkillFileAtomic(targetPath, content) {
   const tempPath = `${targetPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   try {
-    _internals81.writeFileSync(tempPath, content, "utf8");
-    _internals81.renameSync(tempPath, targetPath);
+    _internals82.writeFileSync(tempPath, content, "utf8");
+    _internals82.renameSync(tempPath, targetPath);
   } finally {
     try {
       if (existsSync53(tempPath))
-        _internals81.unlinkSync(tempPath);
+        _internals82.unlinkSync(tempPath);
     } catch {}
   }
 }
-var _internals81 = {
+var _internals82 = {
   writeFileSync: writeFileSync18,
   renameSync: renameSync19,
   unlinkSync: unlinkSync21
@@ -55416,7 +55545,7 @@ function buildGeneratorInputs(args) {
     }
   };
 }
-var _internals82 = {
+var _internals83 = {
   draftDeterministic: defaultDeterministicDraft
 };
 function defaultDeterministicDraft(inputs) {
@@ -55486,7 +55615,7 @@ function countChangedLines(a, b) {
   return changed;
 }
 function draftCandidate(inputs) {
-  const candidate2 = _internals82.draftDeterministic(inputs);
+  const candidate2 = _internals83.draftDeterministic(inputs);
   enforceTrustRegion(candidate2, inputs.budget);
   return candidate2;
 }
@@ -55523,21 +55652,21 @@ async function deterministicSeed(input) {
 }
 
 // src/services/skill-optimizer/smoke.ts
-import { existsSync as existsSync54, lstatSync as lstatSync10, readFileSync as readFileSync41, realpathSync as realpathSync11 } from "fs";
+import { existsSync as existsSync54, lstatSync as lstatSync10, readFileSync as readFileSync41, realpathSync as realpathSync12 } from "fs";
 import * as path98 from "path";
 
 // src/hooks/spawn-helper.ts
 import * as child_process7 from "child_process";
 var WIN32_CMD_BINARIES = new Set(["npm", "npx", "pnpm", "yarn"]);
-var _internals83 = {
+var _internals84 = {
   spawn: child_process7.spawn
 };
 function spawnAsync(command, cwd, timeoutMs) {
-  return new Promise((resolve33) => {
+  return new Promise((resolve34) => {
     try {
       const [rawCmd, ...args] = command;
       const cmd = process.platform === "win32" && WIN32_CMD_BINARIES.has(rawCmd) && !rawCmd.includes(".") ? `${rawCmd}.cmd` : rawCmd;
-      const proc = _internals83.spawn(cmd, args, {
+      const proc = _internals84.spawn(cmd, args, {
         cwd,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -55580,30 +55709,30 @@ function spawnAsync(command, cwd, timeoutMs) {
         try {
           proc.kill();
         } catch {}
-        resolve33(null);
+        resolve34(null);
       }, timeoutMs);
       proc.on("close", (code) => {
         if (done)
           return;
         done = true;
         clearTimeout(timer);
-        resolve33({ exitCode: code ?? 1, stdout, stderr });
+        resolve34({ exitCode: code ?? 1, stdout, stderr });
       });
       proc.on("error", () => {
         if (done)
           return;
         done = true;
         clearTimeout(timer);
-        resolve33(null);
+        resolve34(null);
       });
     } catch {
-      resolve33(null);
+      resolve34(null);
     }
   });
 }
 
 // src/services/skill-optimizer/smoke.ts
-var _internals84 = {
+var _internals85 = {
   validateSkillPath,
   isSymbolicLink: (p) => {
     try {
@@ -55616,7 +55745,7 @@ var _internals84 = {
     const rel = path98.relative(path98.resolve(root), path98.resolve(target));
     return rel.startsWith("..") || path98.isAbsolute(rel);
   },
-  realpath: (p) => realpathSync11(p),
+  realpath: (p) => realpathSync12(p),
   evaluateSkillChange,
   isRejectedSkillContent,
   spawnAsync
@@ -55624,7 +55753,7 @@ var _internals84 = {
 async function validateSkillSmoke(input) {
   const notes = [];
   const repoRel = path98.join(".opencode", "skills", "generated", input.skillSlug, "SKILL.md");
-  if (!_internals84.validateSkillPath(repoRel)) {
+  if (!_internals85.validateSkillPath(repoRel)) {
     return {
       ok: false,
       verdict: "VIOLATED",
@@ -55633,16 +55762,16 @@ async function validateSkillSmoke(input) {
   }
   const skillRoot = path98.join(input.directory, ".opencode", "skills", "generated", input.skillSlug);
   if (existsSync54(skillRoot)) {
-    if (_internals84.isSymbolicLink(skillRoot)) {
+    if (_internals85.isSymbolicLink(skillRoot)) {
       return {
         ok: false,
         verdict: "VIOLATED",
         notes: ["skill root is a symlink (reparse denied)"]
       };
     }
-    const realRoot = _internals84.realpath(skillRoot);
-    const realProjectDir = _internals84.realpath(input.directory);
-    if (_internals84.escapedRoot(realProjectDir, realRoot)) {
+    const realRoot = _internals85.realpath(skillRoot);
+    const realProjectDir = _internals85.realpath(input.directory);
+    if (_internals85.escapedRoot(realProjectDir, realRoot)) {
       return {
         ok: false,
         verdict: "VIOLATED",
@@ -55660,7 +55789,7 @@ async function validateSkillSmoke(input) {
       notes: [`frontmatter: ${fmError}`]
     };
   }
-  const rejected = await _internals84.isRejectedSkillContent(input.directory, input.skillSlug, input.candidateContent);
+  const rejected = await _internals85.isRejectedSkillContent(input.directory, input.skillSlug, input.candidateContent);
   if (rejected) {
     return {
       ok: false,
@@ -55670,7 +55799,7 @@ async function validateSkillSmoke(input) {
       ]
     };
   }
-  const evalResult = await _internals84.evaluateSkillChange({
+  const evalResult = await _internals85.evaluateSkillChange({
     directory: input.directory,
     slug: input.skillSlug,
     candidateContent: input.candidateContent,
@@ -55689,7 +55818,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 _internals84.spawnAsync(input.checkCommand, input.directory, input.checkTimeoutMs ?? 60000);
+    const cmdResult = await _internals85.spawnAsync(input.checkCommand, input.directory, input.checkTimeoutMs ?? 60000);
     if (!cmdResult || cmdResult.exitCode !== 0) {
       return {
         ok: false,
@@ -55759,7 +55888,7 @@ async function prepareCandidatePayloads(inputRoot, candidateId2, skillSlug, base
   candidate2.contentHash = await computeCandidateInputContentHash2(inputRoot, candidate2);
   return { baseline, candidate: candidate2 };
 }
-var _internals85 = {
+var _internals86 = {
   tryAcquireLock,
   emitTelemetry: emit,
   evaluateCandidateV1,
@@ -55767,7 +55896,7 @@ var _internals85 = {
 };
 async function acquireProjectLock(directory) {
   assertProjectRoot(directory);
-  const result = await _internals85.tryAcquireLock(directory, PROJECT_LOCK_PATH, "skill-opt-controller", "project-run");
+  const result = await _internals86.tryAcquireLock(directory, PROJECT_LOCK_PATH, "skill-opt-controller", "project-run");
   if (!result.acquired)
     return null;
   return async () => {
@@ -55781,7 +55910,7 @@ async function acquireProjectLock(directory) {
 async function acquireSkillLock(directory, skillSlug) {
   assertProjectRoot(directory);
   const lockPath = path99.join(".swarm", "evolution", "skills", skillSlug, ".skill.lock");
-  const result = await _internals85.tryAcquireLock(directory, lockPath, "skill-opt-controller", `skill-${skillSlug}`);
+  const result = await _internals86.tryAcquireLock(directory, lockPath, "skill-opt-controller", `skill-${skillSlug}`);
   if (!result.acquired)
     return null;
   return async () => {
@@ -55978,13 +56107,13 @@ async function runValidationWithTransientRetry(input, candidateContent, baseline
   while (true) {
     try {
       const evalInputRoot = input.inputRoot ?? input.directory;
-      const { baseline, candidate: candidate2 } = await _internals85.prepareCandidatePayloads(evalInputRoot, candidateId2, input.skillSlug, input.baselineModel, input.candidateModel, baselineContent, candidateContent);
+      const { baseline, candidate: candidate2 } = await _internals86.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: createModelEvaluationExecutor2 } = await import("./runner-y78d7ryb.js");
+      const { createModelEvaluationExecutor: createModelEvaluationExecutor2 } = await import("./runner-fh3r41nw.js");
       const executor = createModelEvaluationExecutor2(input.dispatcher, input.sessionId);
-      const result = await _internals85.evaluateCandidateV1({
+      const result = await _internals86.evaluateCandidateV1({
         projectRoot: input.directory,
         inputRoot: input.inputRoot ?? input.directory,
         tasks: input.validationTasks,
@@ -56042,7 +56171,7 @@ async function runValidationWithTransientRetry(input, candidateContent, baseline
           deadband: input.config.deadband
         };
       }
-      _internals85.emitTelemetry?.("loop_detected", {
+      _internals86.emitTelemetry?.("loop_detected", {
         skillSlug: input.skillSlug,
         reason: message.slice(0, 160),
         source: "skill-opt-controller"
@@ -56500,7 +56629,7 @@ async function handleSpecifyCommand(_directory, args) {
 init_loader();
 init_schema();
 import * as fsSync4 from "fs";
-import { readFile as readFile22 } from "fs/promises";
+import { readFile as readFile21 } from "fs/promises";
 import * as path104 from "path";
 
 // src/consensus/store.ts
@@ -56891,7 +57020,7 @@ function getCompactionMetrics(sessionId) {
 }
 
 // src/services/status-service.ts
-var _internals86 = {
+var _internals87 = {
   loadLeanTurboRunState,
   hasActiveLeanTurbo,
   hasActiveFullAuto,
@@ -57070,11 +57199,11 @@ async function getStatusData(directory, agents, sessionId) {
   } catch {
     status.memoryCohort = { linked: false };
   }
-  status.fullAutoActive = _internals86.hasActiveFullAuto();
+  status.fullAutoActive = _internals87.hasActiveFullAuto();
   if (status.fullAutoActive) {
-    const sid = _internals86.getActiveFullAutoSessionID();
+    const sid = _internals87.getActiveFullAutoSessionID();
     if (sid) {
-      const runState = _internals86.loadFullAutoRunState(directory, sid);
+      const runState = _internals87.loadFullAutoRunState(directory, sid);
       if (runState?.lastEscalation) {
         status.fullAutoEscalation = {
           reason: runState.lastEscalation.reason,
@@ -57108,7 +57237,7 @@ async function getStatusData(directory, agents, sessionId) {
 }
 function enrichWithLeanTurbo(status, directory) {
   const turboMode = hasActiveTurboMode();
-  const leanActive = _internals86.hasActiveLeanTurbo();
+  const leanActive = _internals87.hasActiveLeanTurbo();
   let turboStrategy = "off";
   if (leanActive) {
     turboStrategy = "lean";
@@ -57139,7 +57268,7 @@ function enrichWithLeanTurbo(status, directory) {
     }
   }
   if (leanSessionID) {
-    const runState = _internals86.loadLeanTurboRunState(directory, leanSessionID);
+    const runState = _internals87.loadLeanTurboRunState(directory, leanSessionID);
     if (runState) {
       status.leanTurboPhase = runState.phase;
       status.leanMaxParallelCoders = runState.maxParallelCoders;
@@ -57339,7 +57468,7 @@ async function safeLineCount(filePath) {
   try {
     if (!fsSync4.existsSync(filePath))
       return 0;
-    const content = await readFile22(filePath, "utf-8");
+    const content = await readFile21(filePath, "utf-8");
     let n = 0;
     for (const line of content.split(`
 `)) {
@@ -57394,7 +57523,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 _internals87 = {
+var _internals88 = {
   loadPluginConfigWithMeta
 };
 async function handleTurboCommand(directory, args, sessionID) {
@@ -57454,7 +57583,7 @@ async function handleTurboCommand(directory, args, sessionID) {
   if (arg0 === "on") {
     let strategy = "standard";
     try {
-      const { config } = _internals87.loadPluginConfigWithMeta(directory);
+      const { config } = _internals88.loadPluginConfigWithMeta(directory);
       if (config.turbo?.strategy === "lean") {
         strategy = "lean";
       }
@@ -57551,7 +57680,7 @@ function enableLeanTurbo(session, directory, sessionID) {
   let maxParallelCoders = 4;
   let conflictPolicy = "serialize";
   try {
-    const { config } = _internals87.loadPluginConfigWithMeta(directory);
+    const { config } = _internals88.loadPluginConfigWithMeta(directory);
     const leanConfig = config.turbo?.lean;
     if (leanConfig) {
       maxParallelCoders = leanConfig.max_parallel_coders ?? 4;
@@ -57814,7 +57943,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-pj9h75cc.js");
+    const { buildHelpText } = await import("./index-djbhe0yh.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -57823,7 +57952,7 @@ async function handleHelpCommand(ctx) {
     return _internals18.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals18.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-pj9h75cc.js");
+  const { buildHelpText: fullHelp } = await import("./index-djbhe0yh.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -58000,7 +58129,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-yktan15c.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-pn1bcgfz.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -58010,7 +58139,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-yktan15c.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-pn1bcgfz.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -58020,7 +58149,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-82da8y5a.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-vb5zkegf.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -58548,8 +58677,8 @@ Subcommands:
   "ci-simulate": {
     handler: (ctx) => handleCiSimulateCommand(ctx.directory, ctx.args),
     description: "Create a temporary merge-result worktree and run CI before merge queue entry",
-    args: "[--base origin/main] [--head <ref>]",
-    details: "Creates a detached temporary worktree under .swarm/ci-simulate from the base ref, merges the current worktree HEAD (or --head ref), runs fixed local CI gates (typecheck, Biome CI, build, unit/integration/security/smoke tests, drift check), then removes the worktree and prunes metadata. Intended as a pre-queue merge_group simulation helper.",
+    args: "[pr-ref] [--base <ref>]",
+    details: "Creates a detached temporary worktree under the OS temp dir (swarm-ci-simulate) from the base \u2014 an explicit validated --base <ref> when given (stacked/release-branch PRs), otherwise the detected default remote branch (origin/HEAD, init.defaultBranch, origin/main, origin/master, verified to exist) \u2014 merges the given PR ref (or the current ref), runs fixed local CI gates (typecheck, lint, build, test), then removes the worktree non-force and prunes metadata. Worktree removal is fail-closed: a blocked or dirty worktree is surfaced, never force-deleted. Intended as a pre-queue merge_group simulation helper.",
     category: "agent",
     toolPolicy: "agent"
   },
@@ -59487,11 +59616,11 @@ record inside as a structured directive you MUST inspect before:
 5. Escalating or invoking skill_improve.
 
 For every applicable directive in the block:
-- Cite \`KNOWLEDGE_APPLIED: <id>\` in the next plan / delegation / gate action that complies with it.
+- Copy the encoded \`trace_id\` and directive \`id\` tokens exactly and cite \`KNOWLEDGE_APPLIED:<trace_id>:<entry_id>\` in the next plan / delegation / gate action that complies with it.
 - If a directive references a generated skill via \`skill: file:...\`, you MUST add that path to the SKILLS: field of any matching subagent delegation.
-- If a directive does NOT apply to the current action, record \`KNOWLEDGE_IGNORED: <id> reason=<short reason>\` once in your reply.
-- If current system/repository/task authority or observed evidence disproves a directive, record \`KNOWLEDGE_CONTRADICTED: <id> reason=<observable conflict>\` and follow current authority.
-- If runtime evidence shows a directive was violated (reviewer rejection, failing test, scope breach), record \`KNOWLEDGE_VIOLATED: <id> reason=<reason>\` and re-plan.
+- If a directive does NOT apply to the current action, record \`KNOWLEDGE_IGNORED:<trace_id>:<entry_id> reason=<short reason>\` once in your reply.
+- If current system/repository/task authority or observed evidence disproves a directive, record \`KNOWLEDGE_CONTRADICTED:<trace_id>:<entry_id> reason=<observable conflict>\` and follow current authority.
+- If runtime evidence shows a directive was violated (reviewer rejection, failing test, scope breach), record \`KNOWLEDGE_VIOLATED:<trace_id>:<entry_id> reason=<reason>\` and re-plan.
 - NEVER silently ignore a \`priority: critical\` directive. The knowledge_application gate may run in 'enforce' mode; in that mode an omitted ack on a critical directive blocks the action for a bounded number of retries and time window (\`max_gate_denials\`, \`gate_staleness_ms\`), after which it auto-clears and logs the bypass \u2014 do not attempt out-of-band workarounds (editing .swarm/ state files, restarting sessions) to escape it; retry the ack with a correctly-terminated marker instead.
 
 Chat-text markers (KNOWLEDGE_APPLIED/IGNORED/CONTRADICTED/VIOLATED) are the sole mechanism that satisfies the knowledge-application enforcement gate. The \`knowledge_receipt\` tool records knowledge-usage receipts for audit but does NOT satisfy the gate.
@@ -59943,7 +60072,8 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - RUN THE MECHANICAL GATES: after fixes, call \`run_pr_feedback_stage_a\` with distinct repository-valid array-form build, typecheck, lint, exact \`["git", "diff", "--check"]\`, and reproduction commands; the reproduction declares exact selected test/package/path \`targets\`. Arbitrary/no-op, mutating, publishing, fix/update, wrapper/eval, selector-free, or duplicate commands fail closed, and content plus HEAD/index/refs/upstream/Git-config state must remain unchanged around every command. Then dispatch exactly one fresh lane at a time, in order, with \`max_concurrent: 1\`: \`swarm-pr-feedback:stage-b-reviewer\`, \`:stage-b-test\`, \`:closeout-reviewer\`, and \`:closeout-critic\`. Every lane owns the complete immutable \`feedback_item_ids\` and uses the matching \`workflow_lane\`. Free-form verdicts, direct Task calls, parallel or out-of-order lanes, stale digests, missing or duplicate item rows, and speed/time rationalizations do not satisfy the gate.
 - RESTART AFTER EDITS: any content change after Stage A invalidates Stage A and all later verdicts. Restart the entire mechanical gate sequence; do not reuse a prior reviewer or critic conversation.
 - DO NOT PUBLISH EARLY: commits, pushes, PR comments/updates, review-thread mutations, and other remote writes remain blocked until every ordered feedback gate settles positively on the same revision digest.
-- After every local gate passes, create the reviewed commit with one standalone \`git commit\`, then call \`complete_pr_workflow\` once. It requires a clean index/worktree and a non-merge direct child whose sole parent is the immutable intake head before binding that post-commit HEAD and arming publication. Push only with \`git push <bound-remote> <bound-commit>:refs/heads/<bound-branch>\`; the literal bound commit and exact bound branch are required, and force flags, wrappers, aliases, fetch-based local-ref forgery, extra refspecs, \`git -C\`, and other remote writes fail closed. Perform read-only remote checks, then call \`complete_pr_workflow\` a second time with the same immutable verification \`pr_head_sha\`; the second call clears only after both the actual remote ref and its local tracking ref resolve to the exact bound commit. Only then perform any explicitly authorized PR comment/body/thread writes.
+- After every local gate passes, EITHER path terminates: (a) content changes \u2014 create the reviewed commit with one standalone \`git commit\`, then call \`complete_pr_workflow\` once. It requires a clean index/worktree and a non-merge direct child whose sole parent is the immutable intake head before binding that post-commit HEAD and arming publication. Push only with \`git push <bound-remote> <bound-commit>:refs/heads/<bound-branch>\`; the literal bound commit and exact bound branch are required, and force flags, wrappers, aliases, fetch-based local-ref forgery, extra refspecs, \`git -C\`, and other remote writes fail closed. Perform read-only remote checks, then call \`complete_pr_workflow\` a second time with the same immutable verification \`pr_head_sha\`; the second call clears only after both the actual remote ref and its local tracking ref resolve to the exact bound commit. Only then perform any explicitly authorized PR comment/body/thread writes. (b) verified no-change \u2014 when EVERY ledger item is verified DISPROVED, PRE_EXISTING, NEEDS_MORE_EVIDENCE, or NEEDS_USER_DECISION in the settled verification lanes, call \`complete_pr_workflow\` with the intake head while HEAD equals it and the tree is clean; it returns \`verified-no-change\` and clears the gate terminally with no commit and no push (an empty commit is still forbidden).
+- BASE-SYNC REBIND: when base drift or merge conflicts force a merge/rebase, do NOT abort ad-hoc \u2014 finish the repair, fetch and check out the new authoritative PR head, then call \`rebind_pr_feedback_head\` with the new full SHA. It moves the immutable intake head, keeps the inventory, and invalidates Stage A plus every gate receipt; re-run the entire mechanical ladder on the new ancestry. It refuses a no-op rebind, an armed gate, and in-flight lanes.
 - Patch only confirmed items plus the tests/docs they require; report closure status for every ledger item including disproved ones.
 - ABORT IF UNRECOVERABLE (pre-armed only): if the PR head cannot be fetched/checked out, the verification bind is unreachable, or bounded recovery is exhausted, call \`abort_pr_workflow\` with \`mode: "PR_FEEDBACK"\`, \`kind: "recovery"\`, and a one-line \`reason\` instead of looping. The tool accepts unbound and bound workflows, refuses while PR workflow lanes are in flight (collect their results first), and refuses once \`prFeedbackReadyToPublish\` is armed \u2014 after arming, you MUST complete the workflow with \`complete_pr_workflow\` (or push the bound commit first); aborting an armed gate would drop the immutable-commit binding and leave a half-published commit. Do NOT abort while useful bounded recovery work remains.
 - Do NOT resolve or mark GitHub review threads resolved unless the user explicitly instructs it.
@@ -61007,6 +61137,13 @@ Do not pad responses with hedging when confidence is HIGH. A precise answer is m
 - Cross-platform and version-specific constraints must be flagged explicitly
 `;
 
+// src/agents/reviewer-directive-compliance.ts
+var DIRECTIVE_COMPLIANCE_OUTPUT_SPEC = `DIRECTIVE_COMPLIANCE: one line per retrieval membership shown during this phase. Copy the encoded trace_id and entry_id tokens exactly from the DIRECTIVES TO VERIFY block. Use exactly one of:
+  VERIFIED:<trace_id>:<entry_id> evidence=<file:line | predicate_passed>
+  VIOLATED:<trace_id>:<entry_id> evidence=<file:line | failing_predicate>
+  N/A:<trace_id>:<entry_id> reason=<why it does not apply to this change>
+Every listed trace_id + entry_id pair MUST appear exactly once. The same entry_id may appear under more than one trace_id and requires one verdict per pair. If a directive carries a verification_predicate, you MUST run it and report predicate_passed / failing_predicate as the evidence. Omitting a listed CRITICAL pair is itself a VIOLATED verdict.`;
+
 // src/agents/reviewer.ts
 var LEGACY_REVIEWER_PROMPT = `## PRESSURE IMMUNITY
 
@@ -61248,11 +61385,8 @@ ISSUES: list with line numbers, grouped by CHECK dimension
 ACCEPTANCE_SATISFACTION: SATISFIED | PARTIAL | NOT_SATISFIED \u2014 one line per item in the input ACCEPTANCE field, stating explicitly whether the diff satisfies it (with evidence: file:line or "no corresponding implementation found"). This is a distinct question from "does the diff look correct" \u2014 assess conformance to ACCEPTANCE even when the diff is otherwise well-written. NOT_SATISFIED on any item forces VERDICT: REJECTED.
 TASK: [task id being reviewed, or "unknown"]
 SKILL_COMPLIANCE: COMPLIANT | PARTIAL | VIOLATED \u2014 [list of violations or "all rules followed"]
-DIRECTIVE_COMPLIANCE: one line per knowledge directive shown during this phase (IDs listed in the DIRECTIVES TO VERIFY block of your prompt, when present). Use exactly one of:
-  VERIFIED:<id> evidence=<file:line | predicate_passed>
-  VIOLATED:<id> evidence=<file:line | failing_predicate>
-  N/A:<id> reason=<why it does not apply>
-Every listed directive ID MUST appear exactly once. If a directive carries a verification_predicate, RUN it and report predicate_passed / failing_predicate as evidence. Omitting a listed directive ID counts as VIOLATED. If no DIRECTIVES TO VERIFY block was provided, output "DIRECTIVE_COMPLIANCE: none".
+${DIRECTIVE_COMPLIANCE_OUTPUT_SPEC}
+If no DIRECTIVES TO VERIFY block was provided, output "DIRECTIVE_COMPLIANCE: none".
 FIXES: required changes if rejected
 Use INFO only inside ISSUES for non-blocking suggestions. RISK reflects the highest blocking severity, so it never uses INFO.
 
@@ -61603,4 +61737,4 @@ function createCuratorLLMDelegate(directory, mode = "init", sessionId) {
   };
 }
 
-export { handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcExtractRecursiveRmTargets, dcEvaluateRecursiveDeleteTargets, 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, _internals27 as _internals, normalizeRecommendationEntryIdToken, parseKnowledgeRecommendations, parseKnowledgeRecommendationsWithDiagnostics, parseStructuredCuratorBlocks, readCuratorSummary, writeCuratorSummary, appendCuratorRecommendation, mergeCuratorPhaseSummary, filterPhaseEvents, checkPhaseCompliance, runCuratorInit, runCuratorPhase, applyCuratorKnowledgeUpdates, isHiveEligible, countDistinctProjects, checkHivePromotions, _internals30 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, _internals18 as _internals2, resolveCommand };
+export { handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcExtractRecursiveRmTargets, dcEvaluateRecursiveDeleteTargets, 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, _internals27 as _internals, normalizeRecommendationEntryIdToken, parseKnowledgeRecommendations, parseKnowledgeRecommendationsWithDiagnostics, parseStructuredCuratorBlocks, readCuratorSummary, writeCuratorSummary, appendCuratorRecommendation, mergeCuratorPhaseSummary, filterPhaseEvents, checkPhaseCompliance, runCuratorInit, runCuratorPhase, applyCuratorKnowledgeUpdates, isHiveEligible, countDistinctProjects, checkHivePromotions, _internals31 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, _internals18 as _internals2, resolveCommand };