opencode-swarm 7.139.0 → 7.139.1

package/dist/cli/{index-r3pth9a7.js → index-xr07r80d.js}

@@ -13,16 +13,16 @@ import {
   resolveExecutableFromPath,
   runEvaluation,
   runExternalTool
-} from "./index-ddmnhv4h.js";
+} from "./index-wrt6m5ze.js";
 import {
   stableCanonicalStringify
-} from "./index-5bkpyvdf.js";
+} from "./index-y1zcsf2a.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-zd15ya1w.js";
+} from "./index-91s653xx.js";
 import {
   MAX_TRANSIENT_RETRIES,
   archiveEvidence,
@@ -61,7 +61,7 @@ import {
   savePlan,
   transientBackoff,
   validateProjectRoot
-} from "./index-4ft523nb.js";
+} from "./index-0wp67gqj.js";
 import {
   EvaluationTaskV1Schema,
   GateAuditManifestV1Schema,
@@ -78,7 +78,7 @@ import {
   saveGateAuditResult,
   savePromotionDecision,
   saveTaskSetSnapshot
-} from "./index-z1tkxzq4.js";
+} from "./index-s608d3hw.js";
 import {
   canonicalHash,
   canonicalJson,
@@ -116,15 +116,15 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-3nr2sn32.js";
+} from "./index-en6qq954.js";
 import {
   readRecentEscalations
-} from "./index-84s6x604.js";
+} from "./index-vxbppwvf.js";
 import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   resolveCohortId
-} from "./index-s428dmy6.js";
+} from "./index-0ymhx85c.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
@@ -177,11 +177,11 @@ import {
   validateActionableFields,
   validateLesson,
   validateSkillPath
-} from "./index-0tsetsxs.js";
+} from "./index-ywysg26s.js";
 import {
   authorizeCuration,
   buildConfigFingerprintInput
-} from "./index-67yqywan.js";
+} from "./index-xec724kg.js";
 import {
   cohortConfigFingerprint
 } from "./index-rtry5xyf.js";
@@ -214,7 +214,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-t31cc7kv.js";
+} from "./index-db7wf6ke.js";
 import {
   MAX_EVENT_LOG_ENTRIES,
   _internals,
@@ -224,7 +224,7 @@ import {
   recordHiveKnowledgeEvent,
   recordKnowledgeEvent,
   resolveKnowledgeEventsPath
-} from "./index-kv36s0x0.js";
+} from "./index-aymt7hzw.js";
 import {
   resolveHiveDataDir,
   resolveHiveEventsPath,
@@ -240,16 +240,16 @@ import {
   resolveLinkDir,
   sanitizeLinkId,
   writeLinkPointer
-} from "./index-tyh0p5e8.js";
+} from "./index-668dpw5e.js";
 import {
   atomicWriteFile
-} from "./index-nc544sfw.js";
+} from "./index-gvhvz176.js";
 import {
   exports_loader,
   init_loader,
   loadPluginConfig,
   loadPluginConfigWithMeta
-} from "./index-q3qtgtd0.js";
+} from "./index-dw09fz3w.js";
 import {
   RetrospectiveEvidenceSchema
 } from "./index-gprxjmm7.js";
@@ -260,12 +260,13 @@ import {
   MemoryConfigSchema,
   SkillImproverConfigSchema,
   getCanonicalAgentRole,
+  init_context_window,
   init_package,
   init_schema,
   package_default,
   resolveAutoReviewConfig,
   stripKnownSwarmPrefix
-} from "./index-rtetrxxq.js";
+} from "./index-15526t16.js";
 import {
   KNOWLEDGE_SCHEMA_VERSION,
   OUTCOME_BLOCK_THRESHOLD,
@@ -281,13 +282,13 @@ import {
   listActive,
   subscribe,
   unsubscribe
-} from "./index-nbgw5dxa.js";
+} from "./index-5zyk8qgv.js";
 import {
   MAX_PENDING_SCOPE_BINDINGS,
   clearAllScopes,
   clearScopeBindingFromDisk,
   clearScopeBindings
-} from "./index-ymszzvnr.js";
+} from "./index-3eddtgxt.js";
 import {
   appendLedgerEvent,
   computePlanHash,
@@ -295,7 +296,7 @@ import {
   derivePlanId,
   initLedger,
   takeSnapshotEvent
-} from "./index-p2dz85tv.js";
+} from "./index-4xbyy6aw.js";
 import {
   PlanSchema
 } from "./index-1kz6da87.js";
@@ -322,16 +323,20 @@ import {
 import {
   findByBatchId,
   readDelegations
-} from "./index-t26nfmcs.js";
+} from "./index-prmb5qfp.js";
 import {
   readSwarmFileAsync,
   safeHook,
   validateSwarmPath
-} from "./index-4qzeef9h.js";
+} from "./index-x9q4bbhd.js";
+import {
+  invalidateCachedArtifact,
+  resetSwarmArtifactCache
+} from "./index-ed5ykebp.js";
 import {
   tryAcquireLock,
   withEvidenceLock
-} from "./index-a614s16f.js";
+} from "./index-5j6chvj8.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
@@ -339,7 +344,7 @@ import {
   emit,
   getLastHeartbeat,
   telemetry
-} from "./index-chvqee1j.js";
+} from "./index-a5eba0t8.js";
 import {
   exports_external,
   init_zod
@@ -5681,6 +5686,8 @@ var swarmState = {
   gateDenialCounts: new Map,
   generatedAgentNames: [],
   lastBudgetPct: 0,
+  lastBudgetTokens: 0,
+  liveContextWindows: new Map,
   agentSessions: defaultRunContext.agentSessions,
   pendingRehydrations: new Set,
   fullAutoEnabledInConfig: false,
@@ -5693,6 +5700,8 @@ function resetSwarmState() {
   swarmState.delegationChains.clear();
   swarmState.pendingEvents = 0;
   swarmState.lastBudgetPct = 0;
+  swarmState.lastBudgetTokens = 0;
+  swarmState.liveContextWindows.clear();
   swarmState.agentSessions.clear();
   _lastIdleSweepAtMs = 0;
   clearTrajectoryCache();
@@ -6523,7 +6532,7 @@ function hasActiveEpicMode(sessionID) {
 async function rehydratePrSubscriptions(sessionID, directory) {
   const map = new Map;
   try {
-    const { listActive: listActive2 } = await import("./pr-subscriptions-xbrfr51c.js");
+    const { listActive: listActive2 } = await import("./pr-subscriptions-hhx6yk24.js");
     const records = await listActive2(directory);
     for (const record of records) {
       if (record.sessionID !== sessionID)
@@ -6685,7 +6694,7 @@ async function listLaneBranches(directory) {
   }
   return [...branches];
 }
-async function cleanupOrphanedBranches(directory, activeSessionIds = []) {
+async function cleanupOrphanedBranches(directory, activeSessionIds = [], options = {}) {
   const removed = [];
   const skipped = [];
   const skippedRecoveryBranches = [];
@@ -6713,7 +6722,7 @@ async function cleanupOrphanedBranches(directory, activeSessionIds = []) {
       skippedRecoveryBranches.push(branch);
       continue;
     }
-    const deleteResult = await runGit(["branch", "-D", branch], directory);
+    const deleteResult = await runGit(["branch", options.preserveUnmerged ? "-d" : "-D", branch], directory);
     if (deleteResult.exitCode === 0) {
       removed.push(branch);
     } else {
@@ -11988,6 +11997,7 @@ init_constants();
 init_schema();
 
 // src/hooks/model-limits.ts
+init_context_window();
 var loggedFirstCalls = new Set;
 
 // src/hooks/guardrails/nontransient-circuit.ts
@@ -18978,7 +18988,7 @@ function planMerges(active, threshold, maxComparisons, maxMerges) {
   };
 }
 async function sweepActiveNearDuplicates(directory, options = {}) {
-  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-gytyqv1d.js");
+  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-ht4q3548.js");
   const { config } = loadPluginConfigWithMeta2(directory);
   const sweepConfig = config.learning?.dedup_sweep;
   if (sweepConfig?.enabled === false)
@@ -20020,6 +20030,7 @@ async function writeCuratorSummaryState(filePath, state) {
   if (!state.summary)
     return;
   await bunWrite(filePath, JSON.stringify(state.summary, null, 2));
+  invalidateCachedArtifact(filePath);
 }
 async function transactCuratorSummary(directory, mutate) {
   const resolvedPath = validateSwarmPath(directory, "curator-summary.json");
@@ -20554,6 +20565,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
         fs12.mkdirSync(evidenceDir, { recursive: true });
         const findingsPath = path32.join(evidenceDir, "curator-findings.json");
         await bunWrite(findingsPath, JSON.stringify({ findings: knowledgeApplicationFindings }, null, 2));
+        invalidateCachedArtifact(findingsPath);
       } catch (err) {
         warn(`[curator] failed to persist application findings: ${err instanceof Error ? err.message : String(err)}`);
       }
@@ -20571,7 +20583,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-5px81476.js");
+        const skillModule = await import("./skill-generator-20czn4kd.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -21031,7 +21043,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-6473ey4c.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-pjg2x75c.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -21850,7 +21862,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push("Failed to collect knowledge summary.");
     }
     try {
-      const { getScanStatus } = await import("./scan-cursor-39zxpw34.js");
+      const { getScanStatus } = await import("./scan-cursor-apbz9eez.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.`);
@@ -22022,9 +22034,9 @@ var _internals24 = {
   verifyPostMortemKnowledgeActions,
   repairPostMortemActions,
   loadDefaultKnowledgeConfig: async (directory) => {
-    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-xhfwr6b2.js");
+    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-x9fr2ey8.js");
     try {
-      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-gytyqv1d.js");
+      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-ht4q3548.js");
       const loaded = loadPluginConfigWithMeta2(directory);
       return KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
     } catch {
@@ -22032,11 +22044,11 @@ var _internals24 = {
     }
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig, generation) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-zxjqcc8r.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-nbsag633.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig, generation);
   },
   checkHivePromotions: async (entries, knowledgeConfig, directory) => {
-    const { checkHivePromotions } = await import("./hive-promoter-jc5vym27.js");
+    const { checkHivePromotions } = await import("./hive-promoter-bpt26yew.js");
     return checkHivePromotions(entries, knowledgeConfig, directory);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -22045,7 +22057,7 @@ var _internals24 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-5px81476.js");
+    } = await import("./skill-generator-20czn4kd.js");
     const result = {
       approved: [],
       rejected: [],
@@ -22087,7 +22099,7 @@ var _internals24 = {
     return result;
   },
   readPriorDriftReports: async (directory) => {
-    const { readPriorDriftReports } = await import("./curator-drift-jpap6hv4.js");
+    const { readPriorDriftReports } = await import("./curator-drift-vfh07mqy.js");
     return readPriorDriftReports(directory);
   },
   readSwarmKnowledge: (directory) => readKnowledge(resolveSwarmKnowledgePath(directory))
@@ -24312,6 +24324,7 @@ ${newSection}`;
           _internals28.mkdirSync(swarmDir, { recursive: true });
         }
         _internals28.writeFileSync(contextPath, updatedContent, "utf-8");
+        invalidateCachedArtifact(contextPath);
       }
     } catch (err) {
       warn(`[skill-propagation-gate] failed to write skill index to context.md: ${err instanceof Error ? err.message : String(err)}`);
@@ -24672,9 +24685,9 @@ function hashContent(content) {
   return createHash9("sha1").update(content).digest("hex");
 }
 async function loadConfigForPolicyCurator(directory) {
-  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-xhfwr6b2.js");
+  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-x9fr2ey8.js");
   try {
-    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-gytyqv1d.js");
+    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-ht4q3548.js");
     const { config: loadedConfig } = loadPluginConfigWithMeta2(directory);
     return KnowledgeConfigSchema2.parse(loadedConfig.knowledge ?? {});
   } catch {
@@ -25774,6 +25787,53 @@ import * as path41 from "path";
 // src/hooks/skill-improver-llm-factory.ts
 init_schema();
 
+// src/utils/ephemeral-session-teardown.ts
+init_logger();
+var DEFAULT_EPHEMERAL_ABORT_TIMEOUT_MS = 5000;
+var DEFAULT_EPHEMERAL_TEARDOWN_DELETE_TIMEOUT_MS = 2000;
+async function boundedSessionCall(call, timeoutMs, timeoutLabel, failureLabel, sessionId) {
+  let timer;
+  try {
+    await Promise.race([
+      call(),
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error(`${timeoutLabel} after ${timeoutMs}ms`)), Math.max(1, timeoutMs));
+      })
+    ]);
+  } catch (error2) {
+    _internals31.log(`${failureLabel} for ephemeral session`, {
+      sessionId,
+      error: error2 instanceof Error ? error2.message : String(error2)
+    });
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+async function boundedAbortEphemeralSession(session, sessionId, timeoutMs = DEFAULT_EPHEMERAL_ABORT_TIMEOUT_MS) {
+  if (typeof session.abort !== "function")
+    return;
+  await _internals31.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 _internals31.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 _internals31.boundedAbort(session, sessionId, abortTimeoutMs);
+  }
+  await _internals31.boundedDelete(session, sessionId, deleteTimeoutMs);
+}
+var _internals31 = {
+  boundedSessionCall,
+  boundedAbort: boundedAbortEphemeralSession,
+  boundedDelete: boundedDeleteEphemeralSession,
+  log
+};
+
 // src/utils/model-dispatch-fallback.ts
 function parseModelString(model) {
   if (!model || !model.trim())
@@ -25889,11 +25949,11 @@ function createSkillImproverLLMDelegate(directory, sessionId) {
     return;
   return async (systemPrompt, userInput, signal) => {
     let ephemeralSessionId;
-    const cleanup = () => {
+    const cleanup = async () => {
       if (ephemeralSessionId) {
         const id = ephemeralSessionId;
         ephemeralSessionId = undefined;
-        client.session.delete({ path: { id } }).catch(() => {});
+        await teardownEphemeralSession(client.session, id);
       }
     };
     if (signal?.aborted) {
@@ -25963,7 +26023,7 @@ ${userInput}` : userInput;
         throw new Error("SKILL_IMPROVER_LLM_TIMEOUT");
       throw err;
     } finally {
-      cleanup();
+      await cleanup();
     }
   };
 }
@@ -26090,7 +26150,7 @@ function gatherSkillViolations(directory, sessionId) {
   if (!sessionId)
     return [];
   try {
-    const entries = _internals31.readSkillUsageEntriesTail(directory, {
+    const entries = _internals32.readSkillUsageEntriesTail(directory, {
       sessionID: sessionId
     });
     const bySkill = new Map;
@@ -26123,7 +26183,7 @@ async function gatherContradictionCandidates(directory, sessionStart, dedupThres
   if (!Number.isFinite(sessionStartMs))
     return [];
   try {
-    const all = await _internals31.readKnowledge(resolveSwarmKnowledgePath(directory));
+    const all = await _internals32.readKnowledge(resolveSwarmKnowledgePath(directory));
     const sessionCreated = all.filter((e) => {
       if (typeof e.created_at !== "string")
         return false;
@@ -26171,7 +26231,7 @@ async function gatherRealtimeAdmissionCounts(directory, sessionStart) {
   if (!Number.isFinite(sessionStartMs))
     return;
   try {
-    const entries = await _internals31.readKnowledge(resolveSwarmKnowledgePath(directory));
+    const entries = await _internals32.readKnowledge(resolveSwarmKnowledgePath(directory));
     let admitted = 0;
     let reinforced = 0;
     for (const e of entries) {
@@ -26190,7 +26250,7 @@ async function gatherRealtimeAdmissionCounts(directory, sessionStart) {
     }
     let rejected = 0;
     try {
-      const rejectedLessons = await _internals31.readRejectedLessons(directory);
+      const rejectedLessons = await _internals32.readRejectedLessons(directory);
       rejected = rejectedLessons.filter((r) => {
         const ms = Date.parse(r.rejected_at ?? "");
         return Number.isFinite(ms) && ms >= sessionStartMs;
@@ -26486,9 +26546,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 = _internals31.gatherSkillViolations(input.directory, input.sessionId);
-  const contradictionCandidates = await _internals31.gatherContradictionCandidates(input.directory, input.sessionStart, input.dedupThreshold ?? DEFAULT_DEDUP_THRESHOLD2);
-  const realtimeCounts = await _internals31.gatherRealtimeAdmissionCounts(input.directory, input.sessionStart);
+  const skillViolations = _internals32.gatherSkillViolations(input.directory, input.sessionId);
+  const contradictionCandidates = await _internals32.gatherContradictionCandidates(input.directory, input.sessionStart, input.dedupThreshold ?? DEFAULT_DEDUP_THRESHOLD2);
+  const realtimeCounts = await _internals32.gatherRealtimeAdmissionCounts(input.directory, input.sessionStart);
   const knowledgeDelta = input.knowledgeDelta ? {
     ...input.knowledgeDelta,
     admitted: realtimeCounts?.admitted ?? input.knowledgeDelta.admitted,
@@ -26548,7 +26608,7 @@ async function writeSessionReflection(directory, result) {
   await fs15.writeFile(reflectionPath, content, "utf-8");
   return reflectionPath;
 }
-var _internals31 = {
+var _internals32 = {
   gatherToolProblems,
   gatherAgentDispatches,
   gatherRetroLessonsAndTaxonomy,
@@ -26734,9 +26794,9 @@ async function writeMotifProposals(directory, opts = {}) {
       return result;
     const max = opts.maxProposals ?? 10;
     const selected = motifs.slice(0, max);
-    const producedAt = _internals32.now().toISOString();
+    const producedAt = _internals33.now().toISOString();
     const candidates = selected.map((motif) => buildMotifCandidate(motif, opts.sessionId));
-    const dedupCheck = await _internals32.checkRecommendations(directory, candidates);
+    const dedupCheck = await _internals33.checkRecommendations(directory, candidates);
     const emitted = dedupCheck.decisions.filter((decision) => decision.emit);
     result.duplicatesSuppressed = dedupCheck.decisions.length - emitted.length;
     if (emitted.length === 0)
@@ -26758,7 +26818,7 @@ async function writeMotifProposals(directory, opts = {}) {
       result.proposalsWritten.push(filePath);
       written.push(candidate);
     }
-    await _internals32.recordEmittedRecommendations(directory, written, {
+    await _internals33.recordEmittedRecommendations(directory, written, {
       producedAt
     });
     return result;
@@ -26924,9 +26984,9 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
       return result;
     const max = opts.maxProposals ?? 10;
     const selected = motifs.slice(0, max);
-    const producedAt = _internals32.now().toISOString();
+    const producedAt = _internals33.now().toISOString();
     const candidates = selected.map((motif) => buildWorkflowCandidate(motif, opts.sessionId));
-    const dedupCheck = await _internals32.checkRecommendations(directory, candidates);
+    const dedupCheck = await _internals33.checkRecommendations(directory, candidates);
     const emitted = dedupCheck.decisions.filter((decision) => decision.emit);
     result.duplicatesSuppressed = dedupCheck.decisions.length - emitted.length;
     if (emitted.length === 0)
@@ -26948,7 +27008,7 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
       result.proposalsWritten.push(filePath);
       written.push(candidate);
     }
-    await _internals32.recordEmittedRecommendations(directory, written, {
+    await _internals33.recordEmittedRecommendations(directory, written, {
       producedAt
     });
     return result;
@@ -26957,7 +27017,7 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
     return result;
   }
 }
-var _internals32 = {
+var _internals33 = {
   now: () => new Date,
   checkRecommendations,
   recordEmittedRecommendations
@@ -27286,7 +27346,7 @@ async function reconcileStaleActiveSkills(directory, options = {}) {
       continue;
     }
     try {
-      const regen = await _internals33.regenerateSkill(directory, skill.slug, {
+      const regen = await _internals34.regenerateSkill(directory, skill.slug, {
         evaluate: false
       });
       if (regen.regenerated) {
@@ -27542,7 +27602,7 @@ async function runSkillImprover(req) {
     autoApply
   };
 }
-var _internals33 = {
+var _internals34 = {
   runSkillImprover,
   buildDeterministicProposal,
   buildLLMProposalFrame,
@@ -27904,13 +27964,13 @@ var write_retro = createSwarmTool({
         task_id: args.task_id !== undefined ? String(args.task_id) : undefined,
         metadata: args.metadata
       };
-      return await _internals34.executeWriteRetro(writeRetroArgs, directory);
+      return await _internals35.executeWriteRetro(writeRetroArgs, directory);
     } catch {
       return JSON.stringify({ success: false, phase: rawPhase, message: "Invalid arguments" }, null, 2);
     }
   }
 });
-var _internals34 = {
+var _internals35 = {
   executeWriteRetro,
   write_retro
 };
@@ -27923,7 +27983,7 @@ import * as fsSync2 from "fs";
 import path45 from "path";
 var DEFAULT_MAX_SOURCE_BYTES = 2 * 1024 * 1024 * 1024;
 var DEFAULT_BUSY_TIMEOUT_MS = 5000;
-var _internals35 = {
+var _internals36 = {
   existsSync: fsSync2.existsSync,
   statSync: fsSync2.statSync,
   renameSync: fsSync2.renameSync,
@@ -27933,11 +27993,11 @@ var _internals35 = {
   DatabaseCtor: null
 };
 function resolveDatabaseCtor() {
-  return _internals35.DatabaseCtor ?? loadDatabaseCtor();
+  return _internals36.DatabaseCtor ?? loadDatabaseCtor();
 }
 function safeRemoveTemp(tempPath) {
   try {
-    _internals35.rmSync(tempPath, {
+    _internals36.rmSync(tempPath, {
       force: true,
       recursive: true,
       maxRetries: 3,
@@ -27993,7 +28053,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 (!_internals35.existsSync(opts.sourcePath)) {
+  if (!_internals36.existsSync(opts.sourcePath)) {
     return {
       requiredness: "required",
       attempt: "not_attempted",
@@ -28006,10 +28066,10 @@ async function archiveSqliteSnapshot(opts) {
   let sourceBytes = 0;
   for (const suffix of ["", "-wal", "-shm"]) {
     const sidecar = opts.sourcePath + suffix;
-    if (!_internals35.existsSync(sidecar))
+    if (!_internals36.existsSync(sidecar))
       continue;
     try {
-      sourceBytes += _internals35.statSync(sidecar).size;
+      sourceBytes += _internals36.statSync(sidecar).size;
     } catch (err) {
       if (suffix === "") {
         return {
@@ -28036,7 +28096,7 @@ async function archiveSqliteSnapshot(opts) {
     };
   }
   const destFinal = path45.join(opts.destDir, opts.destName);
-  const destTemp = path45.join(opts.destDir, `.${opts.destName}.tmp.${_internals35.now()}.${_internals35.randomSuffix()}`);
+  const destTemp = path45.join(opts.destDir, `.${opts.destName}.tmp.${_internals36.now()}.${_internals36.randomSuffix()}`);
   let Db;
   try {
     Db = resolveDatabaseCtor();
@@ -28135,7 +28195,7 @@ async function archiveSqliteSnapshot(opts) {
     };
   }
   try {
-    _internals35.renameSync(destTemp, destFinal);
+    _internals36.renameSync(destTemp, destFinal);
   } catch (err) {
     safeRemoveTemp(destTemp);
     return {
@@ -28501,8 +28561,8 @@ async function runFinalizeStage(ctx) {
   ];
   ctx.curationSucceeded = false;
   try {
-    ctx.curationResult = await _internals36.curateAndStoreSwarm(ctx.allLessons, ctx.projectName, { phase_number: 0 }, ctx.directory, ctx.config, {
-      llmDelegate: _internals36.createCuratorLLMDelegate(ctx.directory, "phase", ctx.options.sessionID),
+    ctx.curationResult = await _internals37.curateAndStoreSwarm(ctx.allLessons, ctx.projectName, { phase_number: 0 }, ctx.directory, ctx.config, {
+      llmDelegate: _internals37.createCuratorLLMDelegate(ctx.directory, "phase", ctx.options.sessionID),
       enrichmentQuota: {
         maxCalls: ctx.config.enrichment.max_calls_per_day,
         window: ctx.config.enrichment.quota_window
@@ -28521,7 +28581,7 @@ async function runFinalizeStage(ctx) {
     if (ctx.config.hive_enabled === false) {} else {
       try {
         const entries = await readKnowledge(resolveSwarmKnowledgePath(ctx.directory));
-        const result = await _internals36.checkHivePromotions(entries, ctx.config, ctx.directory);
+        const result = await _internals37.checkHivePromotions(entries, ctx.config, ctx.directory);
         ctx.hivePromoted = result.new_promotions;
       } catch (hiveErr) {
         const msg = hiveErr instanceof Error ? hiveErr.message : String(hiveErr);
@@ -28542,7 +28602,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 } = _internals36.loadPluginConfigWithMeta(ctx.directory);
+      const { config: loadedConfig } = _internals37.loadPluginConfigWithMeta(ctx.directory);
       const skillImproverConfig = SkillImproverConfigSchema.parse(loadedConfig.skill_improver ?? {});
       const skillReviewResult = await runAbortableSkillReview({
         directory: ctx.directory,
@@ -28620,7 +28680,7 @@ async function runFinalizeStage(ctx) {
     }
     if (!ctx.planAlreadyDone || ctx.guaranteeResult.closedPhaseIds.length > 0 || ctx.guaranteeResult.closedTaskIds.length > 0) {
       try {
-        await _internals36.closePlanTerminalState(ctx.directory, ctx.planData, {
+        await _internals37.closePlanTerminalState(ctx.directory, ctx.planData, {
           closedPhaseIds: ctx.guaranteeResult.closedPhaseIds,
           closedTaskIds: ctx.guaranteeResult.closedTaskIds,
           originalStatuses: ctx.originalStatuses
@@ -28636,12 +28696,12 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-xhfwr6b2.js");
-    const { config: pmLoadedConfig } = _internals36.loadPluginConfigWithMeta(ctx.directory);
+    const { CuratorConfigSchema: CCS } = await import("./schema-x9fr2ey8.js");
+    const { config: pmLoadedConfig } = _internals37.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
-      const pmResult = await _internals36.runCuratorPostMortem(ctx.directory, {
-        llmDelegate: _internals36.createCuratorLLMDelegate(ctx.directory, "postmortem", ctx.options.sessionID),
+      const pmResult = await _internals37.runCuratorPostMortem(ctx.directory, {
+        llmDelegate: _internals37.createCuratorLLMDelegate(ctx.directory, "postmortem", ctx.options.sessionID),
         scope: "project",
         sessionID: ctx.options.sessionID
       });
@@ -28664,7 +28724,7 @@ async function runArchiveStage(ctx) {
   try {
     await fs16.mkdir(ctx.archiveDir, { recursive: true });
     try {
-      await _internals36.flushAndDrainTelemetry();
+      await _internals37.flushAndDrainTelemetry();
     } catch (flushErr) {
       const msg = flushErr instanceof Error ? flushErr.message : String(flushErr);
       ctx.warnings.push(`Telemetry flush before archive failed: ${msg}`);
@@ -28843,7 +28903,7 @@ async function runArchiveEvidenceRetention(ctx) {
   let cacheMaxBytes;
   let cacheMaxRecords;
   try {
-    const { config: evidenceLoadedConfig } = _internals36.loadPluginConfigWithMeta(ctx.directory);
+    const { config: evidenceLoadedConfig } = _internals37.loadPluginConfigWithMeta(ctx.directory);
     const evidenceCfg = evidenceLoadedConfig.evidence ?? {};
     if (typeof evidenceCfg.max_age_days === "number") {
       maxAgeDays = evidenceCfg.max_age_days;
@@ -28859,7 +28919,7 @@ async function runArchiveEvidenceRetention(ctx) {
     }
   } catch {}
   try {
-    await _internals36.archiveEvidence(ctx.directory, maxAgeDays, maxBundles, {
+    await _internals37.archiveEvidence(ctx.directory, maxAgeDays, maxBundles, {
       report: true,
       cacheMaxBytes,
       cacheMaxRecords
@@ -29052,6 +29112,7 @@ async function runCleanStage(ctx) {
   try {
     await fs16.writeFile(contextTempPath, contextContent, "utf-8");
     fsSync3.renameSync(contextTempPath, contextPath);
+    invalidateCachedArtifact(contextPath);
   } catch (error2) {
     try {
       fsSync3.unlinkSync(contextTempPath);
@@ -29071,9 +29132,9 @@ async function runAlignStage(ctx) {
   const pruneBranches = ctx.args.includes("--prune-branches");
   let gitAlignResult = "";
   const prunedBranches = [];
-  const gitStatus = _internals36.getGitRepositoryStatus(ctx.directory);
+  const gitStatus = _internals37.getGitRepositoryStatus(ctx.directory);
   if (gitStatus.isRepo) {
-    const aggressiveResult = await _internals36.resetToMainAfterMerge(ctx.directory, {
+    const aggressiveResult = await _internals37.resetToMainAfterMerge(ctx.directory, {
       pruneBranches
     });
     if (aggressiveResult.success) {
@@ -29085,7 +29146,7 @@ async function runAlignStage(ctx) {
         ctx.warnings.push("Uncommitted changes were discarded during git alignment");
       }
     } else {
-      const alignResult = await _internals36.resetToRemoteBranch(ctx.directory, {
+      const alignResult = await _internals37.resetToRemoteBranch(ctx.directory, {
         pruneBranches
       });
       gitAlignResult = alignResult.message;
@@ -29121,7 +29182,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 = _internals36.getGitRepositoryStatus(directory);
+  const gitStatus = _internals37.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)",
@@ -29193,12 +29254,12 @@ async function handleCloseCommand(directory, args, options = {}) {
     }
   }
   if (args.includes("--dry-run")) {
-    return _internals36.runFinalizeDryRun(directory, swarmDir, planData, planExists);
+    return _internals37.runFinalizeDryRun(directory, swarmDir, planData, planExists);
   }
   let finalizeLock = {
     acquired: false
   };
-  finalizeLock = await _internals36.acquireFinalizeLock(directory);
+  finalizeLock = await _internals37.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.`;
   }
@@ -29229,7 +29290,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 } = _internals36.loadPluginConfigWithMeta(directory);
+    const { config: loadedConfig } = _internals37.loadPluginConfigWithMeta(directory);
     const config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     const ctx = {
       directory,
@@ -29278,9 +29339,9 @@ This project was already finalized in a previous /swarm close run. The plan has
       archiveSuffix: "",
       args
     };
-    ctx.fullAuto = options.sessionID ? _internals36.detectFullAuto(directory, options.sessionID) : false;
+    ctx.fullAuto = options.sessionID ? _internals37.detectFullAuto(directory, options.sessionID) : false;
     await runFinalizeStage(ctx);
-    await _internals36.runFinalizeRewardSweep({
+    await _internals37.runFinalizeRewardSweep({
       directory,
       closedTaskIds: ctx.guaranteeResult.closedTaskIds,
       memoryConfig: loadedConfig.memory
@@ -29352,6 +29413,7 @@ This project was already finalized in a previous /swarm close run. The plan has
     try {
       await fs16.writeFile(closeSummaryTempPath, summaryContent, "utf-8");
       fsSync3.renameSync(closeSummaryTempPath, closeSummaryPath);
+      invalidateCachedArtifact(closeSummaryPath);
     } catch (error2) {
       try {
         fsSync3.unlinkSync(closeSummaryTempPath);
@@ -29363,9 +29425,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) {
-        _internals36.endAgentSession(sessionId);
+        _internals37.endAgentSession(sessionId);
       }
-      _internals36.resetSwarmStatePreservingSingletons();
+      _internals37.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}`);
@@ -29462,7 +29524,7 @@ function detectFullAuto(directory, sessionID) {
     return false;
   }
 }
-var _internals36 = {
+var _internals37 = {
   ACTIVE_STATE_DIRS_TO_CLEAN,
   countSessionKnowledgeEntries,
   CLOSE_SKILL_REVIEW_TIMEOUT_MS,
@@ -29491,7 +29553,7 @@ var _internals36 = {
   closePlanTerminalState,
   endAgentSession,
   flushAndDrainTelemetry: async () => {
-    const { flushAndDrainTelemetry } = await import("./telemetry-7nt7zhyp.js");
+    const { flushAndDrainTelemetry } = await import("./telemetry-4tgrfhaz.js");
     return flushAndDrainTelemetry();
   }
 };
@@ -29958,7 +30020,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 _internals37 = {
+var _internals38 = {
   appendFileSync: fs17.appendFileSync,
   readFileSync: fs17.readFileSync,
   existsSync: fs17.existsSync,
@@ -29971,10 +30033,10 @@ function readTelemetry(directory) {
   const filePath = telemetryFilePath(directory);
   const entries = [];
   try {
-    if (!_internals37.existsSync(filePath)) {
+    if (!_internals38.existsSync(filePath)) {
       return entries;
     }
-    const raw = _internals37.readFileSync(filePath, "utf-8");
+    const raw = _internals38.readFileSync(filePath, "utf-8");
     const lines = raw.split(`
 `);
     for (const line of lines) {
@@ -30411,9 +30473,9 @@ async function detectDarkMatter(directory, options) {
   } catch {
     return [];
   }
-  const commitMap = await _internals38.parseGitLog(directory, maxCommitsToAnalyze);
-  const matrix = _internals38.buildCoChangeMatrix(commitMap, maxFilesPerCommit);
-  const staticEdges = await _internals38.getStaticEdges(directory);
+  const commitMap = await _internals39.parseGitLog(directory, maxCommitsToAnalyze);
+  const matrix = _internals39.buildCoChangeMatrix(commitMap, maxFilesPerCommit);
+  const staticEdges = await _internals39.getStaticEdges(directory);
   const results = [];
   for (const entry of matrix.values()) {
     const key = `${entry.fileA}::${entry.fileB}`;
@@ -30529,11 +30591,11 @@ var co_change_analyzer = createSwarmTool({
       npmiThreshold,
       maxCommitsToAnalyze
     };
-    const pairs = await _internals38.detectDarkMatter(directory, options);
-    return _internals38.formatDarkMatterOutput(pairs);
+    const pairs = await _internals39.detectDarkMatter(directory, options);
+    return _internals39.formatDarkMatterOutput(pairs);
   }
 });
-var _internals38 = {
+var _internals39 = {
   parseGitLog,
   buildCoChangeMatrix,
   getStaticEdges,
@@ -30550,7 +30612,7 @@ var DEFAULT_MAX_COMMITS = 500;
 var cache = new Map;
 async function readGitHead(directory) {
   try {
-    const { stdout } = await _internals39.execFile("git", ["rev-parse", "HEAD"], {
+    const { stdout } = await _internals40.execFile("git", ["rev-parse", "HEAD"], {
       cwd: directory,
       timeout: GIT_HEAD_TIMEOUT_MS
     });
@@ -30576,9 +30638,9 @@ async function getCoChangeData(directory, options) {
   let entries;
   let commitsObserved;
   try {
-    const commitMap = await _internals39.parseGitLog(directory, maxCommits);
+    const commitMap = await _internals40.parseGitLog(directory, maxCommits);
     commitsObserved = commitMap.size;
-    const matrix = _internals39.buildCoChangeMatrix(commitMap);
+    const matrix = _internals40.buildCoChangeMatrix(commitMap);
     entries = Array.from(matrix.values());
   } catch {
     return { pairs: [], commitsObserved: 0 };
@@ -30602,10 +30664,10 @@ async function getCoChangePairs(directory, options) {
   const data = await getCoChangeData(directory, options);
   return data.pairs;
 }
-var _internals39 = {
+var _internals40 = {
   execFile: execFileAsync,
-  parseGitLog: _internals38.parseGitLog,
-  buildCoChangeMatrix: _internals38.buildCoChangeMatrix
+  parseGitLog: _internals39.parseGitLog,
+  buildCoChangeMatrix: _internals39.buildCoChangeMatrix
 };
 
 // src/turbo/epic/coupling-report.ts
@@ -30829,7 +30891,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 _internals40.loadPlanJsonOnly(directory);
+  const plan = await _internals41.loadPlanJsonOnly(directory);
   if (plan === null) {
     return "No plan found at `.swarm/plan.json`. Run `/swarm plan` to create one before measuring coupling.";
   }
@@ -30853,7 +30915,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 _internals40.getCoChangePairs(directory);
+  const cochangePairs = await _internals41.getCoChangePairs(directory);
   const report = computeCouplingReport(tasks, cochangePairs, {
     npmi: parsed.threshold,
     minCoChanges: parsed.minCoChanges
@@ -30892,14 +30954,14 @@ _Warning: failed to persist report (${persistStatus.error})._`;
   }
   return `${formatCouplingReportMarkdown(report)}${persistTrailer}`;
 }
-var _internals40 = {
+var _internals41 = {
   loadPlanJsonOnly,
   getCoChangePairs
 };
 
 // src/commands/curate.ts
 init_schema();
-var _internals41 = {
+var _internals42 = {
   checkHivePromotions,
   readKnowledge,
   resolveSwarmKnowledgePath,
@@ -30907,9 +30969,9 @@ var _internals41 = {
   loadPluginConfigWithMeta,
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
-      import("./schema-xhfwr6b2.js"),
-      import("./curator-zxjqcc8r.js"),
-      import("./curator-llm-factory-e8ngwyjm.js")
+      import("./schema-x9fr2ey8.js"),
+      import("./curator-nbsag633.js"),
+      import("./curator-llm-factory-1ftzece0.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -30918,20 +30980,20 @@ async function handleCurateCommand(directory, _args, options) {
   try {
     let config;
     try {
-      const { config: loadedConfig } = _internals41.loadPluginConfigWithMeta(directory);
+      const { config: loadedConfig } = _internals42.loadPluginConfigWithMeta(directory);
       config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     } catch {
       config = KnowledgeConfigSchema.parse({});
     }
-    const swarmPath = _internals41.resolveSwarmKnowledgePath(directory);
-    const swarmEntries = await _internals41.readKnowledge(swarmPath) ?? [];
-    const summary = await _internals41.checkHivePromotions(swarmEntries, config, directory);
+    const swarmPath = _internals42.resolveSwarmKnowledgePath(directory);
+    const swarmEntries = await _internals42.readKnowledge(swarmPath) ?? [];
+    const summary = await _internals42.checkHivePromotions(swarmEntries, config, directory);
     if (options?.sessionID) {
       let onDemandPhase = 1;
       try {
-        const { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 } = await _internals41.loadCuratorDeps();
+        const { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 } = await _internals42.loadCuratorDeps();
         const curatorConfig = CuratorConfigSchema.parse({});
-        const priorSummary = await _internals41.readSwarmFileAsync(directory, "curator-summary.json");
+        const priorSummary = await _internals42.readSwarmFileAsync(directory, "curator-summary.json");
         if (priorSummary) {
           try {
             const parsed = JSON.parse(priorSummary);
@@ -30942,7 +31004,7 @@ async function handleCurateCommand(directory, _args, options) {
         }
         let planPhaseCount = Infinity;
         try {
-          const planRaw = await _internals41.readSwarmFileAsync(directory, "plan.json");
+          const planRaw = await _internals42.readSwarmFileAsync(directory, "plan.json");
           if (planRaw) {
             const plan = JSON.parse(planRaw);
             if (Array.isArray(plan.phases))
@@ -30961,8 +31023,8 @@ async function handleCurateCommand(directory, _args, options) {
           summary.knowledge_skipped = applied.skipped;
           summary.curator_phase = onDemandPhase;
           try {
-            const updatedEntries = await _internals41.readKnowledge(swarmPath) ?? [];
-            const postUpdateHive = await _internals41.checkHivePromotions(updatedEntries, config, directory);
+            const updatedEntries = await _internals42.readKnowledge(swarmPath) ?? [];
+            const postUpdateHive = await _internals42.checkHivePromotions(updatedEntries, config, directory);
             summary.new_promotions += postUpdateHive.new_promotions;
             summary.encounters_incremented += postUpdateHive.encounters_incremented;
             summary.advancements += postUpdateHive.advancements;
@@ -31028,7 +31090,7 @@ async function handleDarkMatterCommand(directory, args) {
   }
   let pairs;
   try {
-    pairs = await _internals38.detectDarkMatter(directory, options);
+    pairs = await _internals39.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Dark Matter Analysis Failed
@@ -31293,7 +31355,7 @@ ${USAGE7}`;
 // src/commands/design-docs.ts
 init_warning_buffer();
 var MAX_DESC_LEN = 2000;
-var _internals42 = { loadPluginConfigWithMeta };
+var _internals43 = { 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:
@@ -31389,7 +31451,7 @@ async function handleDesignDocsCommand(directory, args) {
 ${USAGE8}`;
   }
   try {
-    const { config } = _internals42.loadPluginConfigWithMeta(directory);
+    const { config } = _internals43.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.
 
@@ -31814,7 +31876,7 @@ async function computeCurationDiagnostics(directory, entries) {
   let scanCompleted = false;
   let scanRemaining = 0;
   try {
-    const { getScanStatus } = await import("./scan-cursor-39zxpw34.js");
+    const { getScanStatus } = await import("./scan-cursor-apbz9eez.js");
     const status = await getScanStatus(directory);
     scanGeneration = status.generation;
     scanCompleted = status.completed;
@@ -31822,19 +31884,19 @@ async function computeCurationDiagnostics(directory, entries) {
   } catch {}
   let configMatch = null;
   try {
-    const { isLinked: isLinked2 } = await import("./knowledge-link-trfydkzm.js");
+    const { isLinked: isLinked2 } = await import("./knowledge-link-3tq8w6gs.js");
     if (isLinked2(directory)) {
-      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-xhfwr6b2.js");
+      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-x9fr2ey8.js");
       let config;
       try {
-        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-gytyqv1d.js");
+        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-ht4q3548.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-a3hs73f7.js");
+      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-2qnhgdtt.js");
       const currentFp = cohortConfigFingerprint2(buildConfigFingerprintInput2(config));
       const cohortFp = await readCohortConfigFingerprint(directory);
       configMatch = cohortFp === null ? null : currentFp === cohortFp;
@@ -31996,7 +32058,7 @@ function resolveCachePackageRoot(cachePath) {
   const nestedPackageRoot = path54.join(cachePath, "node_modules", "opencode-swarm");
   return existsSync31(nestedPackageRoot) ? nestedPackageRoot : cachePath;
 }
-var _internals43 = {
+var _internals44 = {
   detectSandboxCapability: () => sandboxCapabilityProbe.detect(),
   getSandboxExecutor: getExecutor
 };
@@ -32580,9 +32642,9 @@ async function checkCurator(directory) {
 }
 async function getSandboxStatus() {
   try {
-    const capability = await _internals43.detectSandboxCapability();
+    const capability = await _internals44.detectSandboxCapability();
     const mechanism = capability.mechanism ?? "none";
-    const executor = await _internals43.getSandboxExecutor();
+    const executor = await _internals44.getSandboxExecutor();
     const hasExecutor = executor !== null;
     if (hasExecutor) {
       const executorStrength = executor?.strength;
@@ -33045,7 +33107,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-aszp7z1h.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-tgnr91q3.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true, {
       applyLossy: true
     });
@@ -33390,7 +33452,7 @@ function readPromotionEvidence(directory) {
 }
 
 // src/commands/epic.ts
-var _internals44 = {
+var _internals45 = {
   loadPluginConfigWithMeta,
   loadPlanJsonOnly,
   getCoChangeData,
@@ -33412,7 +33474,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 = _internals44.ensureAgentSession(sessionID, undefined, directory);
+  const session = _internals45.ensureAgentSession(sessionID, undefined, directory);
   const arg0 = args[0]?.toLowerCase();
   switch (arg0) {
     case "status":
@@ -33439,7 +33501,7 @@ Usage:
 }
 function enableAndAck(directory, sessionID, session) {
   try {
-    _internals44.enableEpicMode(directory, sessionID);
+    _internals45.enableEpicMode(directory, sessionID);
   } catch (err) {
     return `Error enabling Epic Mode: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -33455,7 +33517,7 @@ function enableAndAck(directory, sessionID, session) {
 }
 function disableAndAck(directory, sessionID, session) {
   try {
-    _internals44.disableEpicMode(directory, sessionID);
+    _internals45.disableEpicMode(directory, sessionID);
   } catch (err) {
     return `Error disabling Epic Mode: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -33464,12 +33526,12 @@ function disableAndAck(directory, sessionID, session) {
 }
 function renderStatus(directory, sessionID) {
   const lines = ["## Epic Mode \u2014 Status", ""];
-  if (_internals44.isStateUnreadable(directory)) {
+  if (_internals45.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 = _internals44.loadEpicSessionState(directory, sessionID);
+  const state = _internals45.loadEpicSessionState(directory, sessionID);
   if (!state) {
     lines.push("Epic Mode has not been toggled for this session.");
     return lines.join(`
@@ -33521,7 +33583,7 @@ function formatGreenfieldDetail(input) {
 function renderLast(directory) {
   let records;
   try {
-    records = _internals44.readPromotionEvidence(directory);
+    records = _internals45.readPromotionEvidence(directory);
   } catch (err) {
     return `Error reading epic-promotions.jsonl: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -33576,7 +33638,7 @@ function renderLast(directory) {
 `);
 }
 function renderCalibration(directory) {
-  if (_internals44.isCalibrationStateUnreadable(directory)) {
+  if (_internals45.isCalibrationStateUnreadable(directory)) {
     return [
       "## Epic Mode \u2014 Calibration",
       "",
@@ -33588,11 +33650,11 @@ function renderCalibration(directory) {
   }
   let state;
   try {
-    state = _internals44.loadCalibrationState(directory);
+    state = _internals45.loadCalibrationState(directory);
   } catch (err) {
     return `Error reading calibration state: ${err instanceof Error ? err.message : String(err)}`;
   }
-  const { config } = _internals44.loadPluginConfigWithMeta(directory);
+  const { config } = _internals45.loadPluginConfigWithMeta(directory);
   const staticThreshold = config.turbo?.epic?.mode?.activation_threshold ?? 0.3;
   const calibrationCfg = config.turbo?.epic?.calibration;
   const loosenWindow = calibrationCfg?.loosen_window ?? 10;
@@ -33640,7 +33702,7 @@ function renderCalibration(directory) {
   lines.push("");
   let recentDivergent = [];
   try {
-    const all = _internals44.readDivergenceHistory(directory, { limit: 50 });
+    const all = _internals45.readDivergenceHistory(directory, { limit: 50 });
     recentDivergent = all.filter((r) => !r.isClean).slice(-5);
   } catch {}
   lines.push("### Recent divergent tasks (tightened the threshold)");
@@ -33657,11 +33719,11 @@ function renderCalibration(directory) {
 `);
 }
 async function renderDecide(directory) {
-  const plan = await _internals44.loadPlanJsonOnly(directory);
+  const plan = await _internals45.loadPlanJsonOnly(directory);
   if (!plan) {
     return "No plan found at `.swarm/plan.json`. Run `/swarm plan` first.";
   }
-  const { config } = _internals44.loadPluginConfigWithMeta(directory);
+  const { config } = _internals45.loadPluginConfigWithMeta(directory);
   const modeCfg = config.turbo?.epic?.mode;
   const cochangeCfg = config.turbo?.epic?.cochange;
   const activationThreshold = modeCfg?.activation_threshold ?? 0.3;
@@ -33671,20 +33733,20 @@ async function renderDecide(directory) {
   const tasks = [];
   for (const phase of plan.phases) {
     for (const task of phase.tasks) {
-      const scopeFiles = _internals44.readTaskScopes(directory, task.id);
+      const scopeFiles = _internals45.readTaskScopes(directory, task.id);
       const scope = scopeFiles ?? task.files_touched ?? [];
       tasks.push({ id: task.id, scope });
     }
   }
-  const { pairs, commitsObserved } = await _internals44.getCoChangeData(directory);
+  const { pairs, commitsObserved } = await _internals45.getCoChangeData(directory);
   const isGitProject = (() => {
     try {
-      return _internals44.isGitRepo(directory);
+      return _internals45.isGitRepo(directory);
     } catch {
       return false;
     }
   })();
-  const verdict = _internals44.decideEpicActivation(tasks, pairs, commitsObserved, {
+  const verdict = _internals45.decideEpicActivation(tasks, pairs, commitsObserved, {
     activationThreshold,
     minCommitsForSignal,
     cochangeNpmiThreshold,
@@ -33728,7 +33790,7 @@ function formatVerdict(verdict) {
 }
 
 // src/services/evidence-service.ts
-var _internals45 = {
+var _internals46 = {
   loadEvidence,
   listEvidenceTaskIds
 };
@@ -33773,7 +33835,7 @@ function getVerdictEmoji(verdict) {
   return getVerdictIcon(verdict);
 }
 async function getTaskEvidenceData(directory, taskId) {
-  const result = await _internals45.loadEvidence(directory, taskId);
+  const result = await _internals46.loadEvidence(directory, taskId);
   if (result.status !== "found") {
     return {
       hasEvidence: false,
@@ -33796,13 +33858,13 @@ async function getTaskEvidenceData(directory, taskId) {
   };
 }
 async function getEvidenceListData(directory) {
-  const taskIds = await _internals45.listEvidenceTaskIds(directory);
+  const taskIds = await _internals46.listEvidenceTaskIds(directory);
   if (taskIds.length === 0) {
     return { hasEvidence: false, tasks: [] };
   }
   const tasks = [];
   for (const taskId of taskIds) {
-    const result = await _internals45.loadEvidence(directory, taskId);
+    const result = await _internals46.loadEvidence(directory, taskId);
     if (result.status === "found") {
       tasks.push({
         taskId,
@@ -33882,7 +33944,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-qfhjfxdz.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-kzxr71yd.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -34238,7 +34300,7 @@ function isStaticallyEquivalent(originalCode, mutatedCode) {
   const strippedMutated = stripCode(mutatedCode);
   return strippedOriginal === strippedMutated;
 }
-var _internals46 = {
+var _internals47 = {
   isStaticallyEquivalent,
   checkEquivalence,
   batchCheckEquivalence
@@ -34278,7 +34340,7 @@ async function batchCheckEquivalence(patches, llmJudge) {
   const results = [];
   for (const { patch, originalCode, mutatedCode } of patches) {
     try {
-      const result = await _internals46.checkEquivalence(patch, originalCode, mutatedCode, llmJudge);
+      const result = await _internals47.checkEquivalence(patch, originalCode, mutatedCode, llmJudge);
       results.push(result);
     } catch (err) {
       results.push({
@@ -34352,10 +34414,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 = _internals47.resolveExecutableFromPath([
+  const resolvedExecutable = _internals48.resolveExecutableFromPath([
     args.executable
   ]);
-  const result = await _internals47.runExternalTool({
+  const result = await _internals48.runExternalTool({
     executable: resolvedExecutable ?? args.executable,
     args: args.args,
     cwd: args.cwd,
@@ -34374,7 +34436,7 @@ var runMutationCommand = async (args) => {
 };
 var runLegacyTestSeam = async (args) => {
   try {
-    const result = _internals47.spawnSync(args.executable, args.args, {
+    const result = _internals48.spawnSync(args.executable, args.args, {
       cwd: args.cwd,
       timeout: args.timeoutMs,
       stdio: "pipe"
@@ -34408,11 +34470,11 @@ var runLegacyTestSeam = async (args) => {
 function selectRunner(options) {
   if (options.runner)
     return options.runner;
-  if (_internals47.spawnSync !== defaultLegacySpawnSync)
+  if (_internals48.spawnSync !== defaultLegacySpawnSync)
     return runLegacyTestSeam;
-  return _internals47.runCommand;
+  return _internals48.runCommand;
 }
-var _internals47 = {
+var _internals48 = {
   executeMutation,
   computeReport,
   executeMutationSuite,
@@ -35656,11 +35718,11 @@ var quality_budget = createSwarmTool({
     }).optional().describe("Quality budget thresholds")
   },
   async execute(args, directory) {
-    const result = await _internals48.qualityBudget(args, directory);
+    const result = await _internals49.qualityBudget(args, directory);
     return JSON.stringify(result);
   }
 });
-var _internals48 = {
+var _internals49 = {
   qualityBudget
 };
 
@@ -36529,7 +36591,7 @@ var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
 var DEFAULT_TIMEOUT_MS2 = 30000;
 var MAX_OUTPUT_BYTES = 10 * 1024 * 1024;
 var KILL_GRACE_MS = 2000;
-var _internals49 = {
+var _internals50 = {
   isSemgrepAvailable,
   checkSemgrepAvailable,
   resetSemgrepCache,
@@ -36555,7 +36617,7 @@ function isSemgrepAvailable() {
   }
 }
 async function checkSemgrepAvailable() {
-  return _internals49.isSemgrepAvailable();
+  return _internals50.isSemgrepAvailable();
 }
 function resetSemgrepCache() {
   semgrepAvailableCache = null;
@@ -36742,12 +36804,12 @@ async function runSemgrep(options) {
   const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS2;
   if (files.length === 0) {
     return {
-      available: _internals49.isSemgrepAvailable(),
+      available: _internals50.isSemgrepAvailable(),
       findings: [],
       engine: "tier_a"
     };
   }
-  if (!_internals49.isSemgrepAvailable()) {
+  if (!_internals50.isSemgrepAvailable()) {
     return {
       available: false,
       findings: [],
@@ -36909,7 +36971,7 @@ function assignOccurrenceIndices(findings, directory) {
     }
     const occIdx = countMap.get(baseKey) ?? 0;
     countMap.set(baseKey, occIdx + 1);
-    const fp = _internals50.fingerprintFinding(finding, directory, occIdx);
+    const fp = _internals51.fingerprintFinding(finding, directory, occIdx);
     return {
       finding,
       index: occIdx,
@@ -36923,6 +36985,7 @@ async function acquireLock2(lockPath) {
     try {
       const fd = fs25.openSync(lockPath, "wx");
       fs25.closeSync(fd);
+      invalidateCachedArtifact(lockPath);
       return () => {
         try {
           fs25.unlinkSync(lockPath);
@@ -36978,7 +37041,7 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       }
     } catch {}
     const scannedRelFiles = new Set(scannedFiles.map((f) => normalizeFindingPath(directory, f)));
-    const indexed = _internals50.assignOccurrenceIndices(findings, directory);
+    const indexed = _internals51.assignOccurrenceIndices(findings, directory);
     if (existing && !opts?.force) {
       const prunedFingerprints = existing.fingerprints.filter((fp) => {
         const relFile = fp.slice(0, fp.indexOf("|"));
@@ -37033,6 +37096,7 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       }
       fs25.writeFileSync(tempPath, json2, "utf-8");
       fs25.renameSync(tempPath, baselinePath);
+      invalidateCachedArtifact(baselinePath);
       return {
         status: "merged",
         path: baselinePath,
@@ -37065,6 +37129,7 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
     }
     fs25.writeFileSync(tempPath, json, "utf-8");
     fs25.renameSync(tempPath, baselinePath);
+    invalidateCachedArtifact(baselinePath);
     return {
       status: "written",
       path: baselinePath,
@@ -37118,7 +37183,7 @@ function loadBaseline(directory, phase) {
     };
   }
 }
-var _internals50 = {
+var _internals51 = {
   fingerprintFinding,
   assignOccurrenceIndices,
   captureOrMergeBaseline,
@@ -37232,7 +37297,7 @@ async function sastScan(input, directory, config) {
   let filesScanned = 0;
   let _filesSkipped = 0;
   const scannedFilePaths = [];
-  const semgrepAvailable = !offline_only && _internals51.isSemgrepAvailable();
+  const semgrepAvailable = !offline_only && _internals52.isSemgrepAvailable();
   const engine = semgrepAvailable ? "tier_a+tier_b" : "tier_a";
   const filesByLanguage = new Map;
   for (const filePath of changed_files) {
@@ -37295,13 +37360,13 @@ async function sastScan(input, directory, config) {
         let semgrepResult;
         if (bucketKey.startsWith("auto:")) {
           const lang = bucketKey.slice("auto:".length);
-          semgrepResult = await _internals51.runSemgrep({
+          semgrepResult = await _internals52.runSemgrep({
             files: bucketFiles,
             lang,
             useAutoConfig: true
           });
         } else {
-          semgrepResult = await _internals51.runSemgrep({
+          semgrepResult = await _internals52.runSemgrep({
             files: bucketFiles
           });
         }
@@ -37543,11 +37608,11 @@ var sast_scan = createSwarmTool({
       capture_baseline: safeArgs.capture_baseline,
       phase: safeArgs.phase
     };
-    const result = await _internals51.sastScan(input, directory);
+    const result = await _internals52.sastScan(input, directory);
     return JSON.stringify(result, null, 2);
   }
 });
-var _internals51 = {
+var _internals52 = {
   sastScan,
   sast_scan,
   isSemgrepAvailable: () => isSemgrepAvailable(),
@@ -38378,7 +38443,7 @@ function extractCurrentPhaseFromPlan2(plan) {
   if (!plan) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
-  if (!_internals52.validatePlanPhases(plan)) {
+  if (!_internals53.validatePlanPhases(plan)) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
   let currentPhase = null;
@@ -38520,9 +38585,9 @@ function extractPhaseMetrics(content) {
 async function getHandoffData(directory) {
   const now = new Date().toISOString();
   const sessionContent = await readSwarmFileAsync(directory, "session/state.json");
-  const sessionState = _internals52.parseSessionState(sessionContent);
+  const sessionState = _internals53.parseSessionState(sessionContent);
   const plan = await loadPlanJsonOnly(directory);
-  const planInfo = _internals52.extractCurrentPhaseFromPlan(plan);
+  const planInfo = _internals53.extractCurrentPhaseFromPlan(plan);
   if (!plan) {
     const planMdContent = await readSwarmFileAsync(directory, "plan.md");
     if (planMdContent) {
@@ -38541,8 +38606,8 @@ async function getHandoffData(directory) {
     }
   }
   const contextContent = await readSwarmFileAsync(directory, "context.md");
-  const recentDecisions = _internals52.extractDecisions(contextContent);
-  const rawPhaseMetrics = _internals52.extractPhaseMetrics(contextContent);
+  const recentDecisions = _internals53.extractDecisions(contextContent);
+  const rawPhaseMetrics = _internals53.extractPhaseMetrics(contextContent);
   const phaseMetrics = sanitizeString(rawPhaseMetrics, 1000);
   let delegationState = null;
   if (sessionState?.delegationState) {
@@ -38706,7 +38771,7 @@ ${lines.join(`
 `)}
 \`\`\``;
 }
-var _internals52 = {
+var _internals53 = {
   getHandoffData,
   formatHandoffMarkdown,
   formatContinuationPrompt,
@@ -38865,6 +38930,7 @@ async function writeSnapshot(directory, state) {
       }
     } catch {}
     renameSync12(tempPath, resolvedPath);
+    invalidateCachedArtifact(resolvedPath);
   } catch (error2) {
     log("[snapshot-writer] write failed", {
       error: error2 instanceof Error ? error2.message : String(error2)
@@ -38873,15 +38939,15 @@ async function writeSnapshot(directory, state) {
 }
 function createSnapshotWriterHook(directory) {
   return (_input, _output) => {
-    _writeInFlight = _writeInFlight.then(() => _internals53.writeSnapshot(directory, swarmState), () => _internals53.writeSnapshot(directory, swarmState));
+    _writeInFlight = _writeInFlight.then(() => _internals54.writeSnapshot(directory, swarmState), () => _internals54.writeSnapshot(directory, swarmState));
     return _writeInFlight;
   };
 }
 async function flushPendingSnapshot(directory) {
-  _writeInFlight = _writeInFlight.then(() => _internals53.writeSnapshot(directory, swarmState), () => _internals53.writeSnapshot(directory, swarmState));
+  _writeInFlight = _writeInFlight.then(() => _internals54.writeSnapshot(directory, swarmState), () => _internals54.writeSnapshot(directory, swarmState));
   await _writeInFlight;
 }
-var _internals53 = {
+var _internals54 = {
   writeSnapshot,
   createSnapshotWriterHook,
   flushPendingSnapshot
@@ -38911,6 +38977,7 @@ async function handleHandoffCommand(directory, _args, sessionID) {
       } catch {}
       throw renameErr;
     }
+    invalidateCachedArtifact(resolvedPath);
     const continuationPrompt = formatContinuationPrompt(handoffData);
     const promptPath = validateSwarmPath(directory, "handoff-prompt.md");
     const promptTempPath = `${promptPath}.tmp.${crypto5.randomUUID()}`;
@@ -39166,7 +39233,7 @@ function parseIssueRef(input, directory) {
   }
   return null;
 }
-var _internals54 = {
+var _internals55 = {
   writeFileSync: fs28.writeFileSync,
   mkdirSync: fs28.mkdirSync,
   renameSync: fs28.renameSync,
@@ -39177,18 +39244,18 @@ var _internals54 = {
 function atomicWriteFileSync(dir, filename, content) {
   const tmpPath = path67.join(dir, `.tmp-${filename}-${Date.now()}-${process.pid}`);
   const finalPath = path67.join(dir, filename);
-  _internals54.writeFileSync(tmpPath, content, "utf-8");
+  _internals55.writeFileSync(tmpPath, content, "utf-8");
   try {
-    _internals54.renameSync(tmpPath, finalPath);
+    _internals55.renameSync(tmpPath, finalPath);
   } catch {
     try {
-      _internals54.unlinkSync(finalPath);
+      _internals55.unlinkSync(finalPath);
     } catch {}
     try {
-      _internals54.renameSync(tmpPath, finalPath);
+      _internals55.renameSync(tmpPath, finalPath);
     } catch (retryErr) {
       try {
-        _internals54.unlinkSync(tmpPath);
+        _internals55.unlinkSync(tmpPath);
       } catch {}
       throw retryErr;
     }
@@ -39241,10 +39308,10 @@ ${USAGE9}`;
   };
   let oldTraceState = null;
   try {
-    oldTraceState = _internals54.readFileSync(path67.join(swarmDir, "issue-trace-state.json"), "utf-8");
+    oldTraceState = _internals55.readFileSync(path67.join(swarmDir, "issue-trace-state.json"), "utf-8");
   } catch {}
   try {
-    _internals54.mkdirSync(swarmDir, { recursive: true });
+    _internals55.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) {
@@ -39254,11 +39321,11 @@ ${USAGE9}`;
       } catch {}
     } else {
       try {
-        _internals54.unlinkSync(path67.join(swarmDir, "issue-trace-state.json"));
+        _internals55.unlinkSync(path67.join(swarmDir, "issue-trace-state.json"));
       } catch {}
     }
     try {
-      _internals54.unlinkSync(path67.join(swarmDir, "issue-reference.json"));
+      _internals55.unlinkSync(path67.join(swarmDir, "issue-reference.json"));
     } catch {}
     const errMsg = e instanceof Error ? e.message : String(e);
     return `Error: Failed to persist issue reference durably: ${errMsg}
@@ -39291,7 +39358,7 @@ init_knowledge_types();
 async function migrateKnowledgeToExternal(_directory, _config) {
   const externalSentinelPath = path68.join(_directory, ".swarm", ".knowledge-external-migrated");
   const contextPath = path68.join(_directory, ".swarm", "context.md");
-  if (_internals55.existsSync(externalSentinelPath)) {
+  if (_internals56.existsSync(externalSentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -39300,7 +39367,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
       skippedReason: "external-sentinel-exists"
     };
   }
-  if (!_internals55.existsSync(contextPath)) {
+  if (!_internals56.existsSync(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -39309,7 +39376,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
       skippedReason: "no-context-file"
     };
   }
-  const contextContent = await _internals55.readFile(contextPath, "utf-8");
+  const contextContent = await _internals56.readFile(contextPath, "utf-8");
   if (contextContent.trim().length === 0) {
     return {
       migrated: false,
@@ -39327,7 +39394,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
       entriesCount++;
     }
   }
-  await _internals55.writeSentinel(externalSentinelPath, entriesCount, entriesCount);
+  await _internals56.writeSentinel(externalSentinelPath, entriesCount, entriesCount);
   return {
     migrated: true,
     entriesMigrated: entriesCount,
@@ -39335,7 +39402,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
     entriesTotal: entriesCount
   };
 }
-var _internals55 = {
+var _internals56 = {
   appendKnowledge,
   migrateContextToKnowledge,
   migrateKnowledgeToExternal,
@@ -39386,9 +39453,9 @@ async function migrateContextToKnowledge(directory, config) {
       skippedReason: "empty-context"
     };
   }
-  const rawEntries = _internals55.parseContextMd(contextContent);
+  const rawEntries = _internals56.parseContextMd(contextContent);
   if (rawEntries.length === 0) {
-    await _internals55.writeSentinel(sentinelPath, 0, 0);
+    await _internals56.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -39399,10 +39466,10 @@ async function migrateContextToKnowledge(directory, config) {
   const existing = await readKnowledge(knowledgePath);
   let migrated = 0;
   let dropped = 0;
-  const projectName = _internals55.inferProjectName(directory);
+  const projectName = _internals56.inferProjectName(directory);
   for (const raw of rawEntries) {
     if (config.validation_enabled !== false) {
-      const category = raw.categoryHint ?? _internals55.inferCategoryFromText(raw.text);
+      const category = raw.categoryHint ?? _internals56.inferCategoryFromText(raw.text);
       const result = validateLesson(raw.text, existing.map((e) => e.lesson), {
         category,
         scope: "global",
@@ -39422,8 +39489,8 @@ async function migrateContextToKnowledge(directory, config) {
     const entry = {
       id: randomUUID8(),
       tier: "swarm",
-      lesson: _internals55.truncateLesson(raw.text),
-      category: raw.categoryHint ?? _internals55.inferCategoryFromText(raw.text),
+      lesson: _internals56.truncateLesson(raw.text),
+      category: raw.categoryHint ?? _internals56.inferCategoryFromText(raw.text),
       tags: [...inferredTags, `migration:${raw.sourceSection}`],
       scope: "global",
       confidence: 0.3,
@@ -39446,7 +39513,7 @@ async function migrateContextToKnowledge(directory, config) {
   if (migrated > 0) {
     await rewriteKnowledge(knowledgePath, existing);
   }
-  await _internals55.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals56.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -39456,7 +39523,7 @@ async function migrateContextToKnowledge(directory, config) {
   };
 }
 async function migrateHiveKnowledgeLegacy(config) {
-  const legacyHivePath = _internals55.resolveLegacyHiveKnowledgePath();
+  const legacyHivePath = _internals56.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath2();
   const sentinelPath = path68.join(path68.dirname(canonicalHivePath), ".hive-knowledge-migrated");
   if (existsSync39(sentinelPath)) {
@@ -39479,7 +39546,7 @@ async function migrateHiveKnowledgeLegacy(config) {
   }
   const legacyEntries = await readKnowledge(legacyHivePath);
   if (legacyEntries.length === 0) {
-    await _internals55.writeSentinel(sentinelPath, 0, 0);
+    await _internals56.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -39527,7 +39594,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       const newHiveEntry = {
         id: resolvedId,
         tier: "hive",
-        lesson: _internals55.truncateLesson(lesson),
+        lesson: _internals56.truncateLesson(lesson),
         category,
         tags: ["migration:legacy-hive"],
         scope: scopeTag,
@@ -39546,7 +39613,7 @@ async function migrateHiveKnowledgeLegacy(config) {
         encounter_score: 1
       };
       try {
-        await _internals55.appendKnowledge(canonicalHivePath, newHiveEntry);
+        await _internals56.appendKnowledge(canonicalHivePath, newHiveEntry);
         existingHiveEntries.push(newHiveEntry);
         migrated++;
       } catch (appendError) {
@@ -39562,7 +39629,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       dropped++;
     }
   }
-  await _internals55.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals56.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} legacy hive entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -39573,7 +39640,7 @@ async function migrateHiveKnowledgeLegacy(config) {
   };
 }
 function parseContextMd(content) {
-  const sections = _internals55.splitIntoSections(content);
+  const sections = _internals56.splitIntoSections(content);
   const entries = [];
   const seen = new Set;
   const sectionPatterns = [
@@ -39589,7 +39656,7 @@ function parseContextMd(content) {
     const match = sectionPatterns.find((sp) => sp.pattern.test(section.heading));
     if (!match)
       continue;
-    const bullets = _internals55.extractBullets(section.body);
+    const bullets = _internals56.extractBullets(section.body);
     for (const bullet of bullets) {
       if (bullet.length < 15)
         continue;
@@ -39598,9 +39665,9 @@ function parseContextMd(content) {
         continue;
       seen.add(normalized);
       entries.push({
-        text: _internals55.truncateLesson(bullet),
+        text: _internals56.truncateLesson(bullet),
         sourceSection: match.sourceSection,
-        categoryHint: _internals55.inferCategoryFromText(bullet)
+        categoryHint: _internals56.inferCategoryFromText(bullet)
       });
     }
   }
@@ -39690,8 +39757,8 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await _internals55.mkdir(path68.dirname(sentinelPath), { recursive: true });
-  await _internals55.writeFile(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
+  await _internals56.mkdir(path68.dirname(sentinelPath), { recursive: true });
+  await _internals56.writeFile(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 function resolveLegacyHiveKnowledgePath() {
   const platform = process.platform;
@@ -40103,7 +40170,7 @@ function timeoutMessage(timeoutMs) {
 async function computeWithTimeout(directory, currentPhase, timeoutMs) {
   const controller = new AbortController;
   let timeout;
-  const metricsPromise = _internals56.computeLearningMetrics(directory, {
+  const metricsPromise = _internals57.computeLearningMetrics(directory, {
     currentPhase,
     signal: controller.signal
   });
@@ -40160,7 +40227,7 @@ ${JSON.stringify({
     return `Error computing learning metrics: ${message}. Run /swarm diagnose to check .swarm/ health.`;
   }
 }
-var _internals56 = {
+var _internals57 = {
   computeLearningMetrics
 };
 
@@ -40681,7 +40748,7 @@ async function readLatestLoopState(directory) {
     return null;
   }
 }
-var _internals57 = {
+var _internals58 = {
   readLatestLoopState
 };
 var USAGE10 = `Usage: /swarm loop <objective> [--max-cycles 1..5] [--autonomy checkpoint|auto] [--depth standard|exhaustive] [--resume]
@@ -40794,7 +40861,7 @@ ${USAGE10}`;
   }
   let autonomy = parsed.autonomy;
   if (parsed.resume && !parsed.autonomyExplicit) {
-    const state = await _internals57.readLatestLoopState(_directory);
+    const state = await _internals58.readLatestLoopState(_directory);
     if (state?.autonomy && AUTONOMY_LEVELS.has(state.autonomy)) {
       autonomy = state.autonomy;
     }
@@ -42348,15 +42415,15 @@ async function handleMemoryUnlinkCommand(directory, args) {
 }
 
 // src/services/plan-service.ts
-var _internals58 = {
+var _internals59 = {
   loadPlanJsonOnly,
   derivePlanMarkdown,
   readSwarmFileAsync
 };
 async function getPlanData(directory, phaseArg) {
-  const plan = await _internals58.loadPlanJsonOnly(directory);
+  const plan = await _internals59.loadPlanJsonOnly(directory);
   if (plan) {
-    const fullMarkdown = _internals58.derivePlanMarkdown(plan);
+    const fullMarkdown = _internals59.derivePlanMarkdown(plan);
     if (phaseArg === undefined || phaseArg === null || phaseArg === "") {
       return {
         hasPlan: true,
@@ -42399,7 +42466,7 @@ async function getPlanData(directory, phaseArg) {
       isLegacy: false
     };
   }
-  const planContent = await _internals58.readSwarmFileAsync(directory, "plan.md");
+  const planContent = await _internals59.readSwarmFileAsync(directory, "plan.md");
   if (!planContent) {
     return {
       hasPlan: false,
@@ -42496,7 +42563,7 @@ async function handlePlanCommand(directory, args) {
   return formatPlanMarkdown(planData);
 }
 // src/commands/post-mortem.ts
-var _internals59 = {
+var _internals60 = {
   createCuratorLLMDelegate,
   runCuratorPostMortem
 };
@@ -42544,10 +42611,10 @@ async function handlePostMortemCommand(directory, args, options) {
     };
     if (options?.sessionID) {
       try {
-        pmOptions.llmDelegate = _internals59.createCuratorLLMDelegate(directory, "postmortem", options.sessionID);
+        pmOptions.llmDelegate = _internals60.createCuratorLLMDelegate(directory, "postmortem", options.sessionID);
       } catch {}
     }
-    const result = await _internals59.runCuratorPostMortem(directory, pmOptions);
+    const result = await _internals60.runCuratorPostMortem(directory, pmOptions);
     const lines = [];
     if (result.success) {
       lines.push("## Post-Mortem Report Generated");
@@ -42805,7 +42872,7 @@ function formatMergeGroupStatus(status, conclusion, htmlUrl) {
   }
   return parts.join(" ");
 }
-var _internals60 = {
+var _internals61 = {
   formatRelativeTime,
   formatMergeGroupStatus,
   listActive,
@@ -42813,7 +42880,7 @@ var _internals60 = {
   parseMergeGroupRuns
 };
 async function handlePrMonitorStatusCommand(directory, _args, sessionID, source) {
-  const allActive = await _internals60.listActive(directory);
+  const allActive = await _internals61.listActive(directory);
   const allSessions = source === "cli";
   const subs = allSessions ? allActive : allActive.filter((record) => record.sessionID === sessionID);
   if (subs.length === 0) {
@@ -42829,7 +42896,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 _internals60.listMergeGroupRuns(directory, sub.repoFullName, sub.prNumber);
+    const mergeGroupRuns = await _internals61.listMergeGroupRuns(directory, sub.repoFullName, sub.prNumber);
     if (mergeGroupRuns.runs.length > 0) {
       lines.push("     Merge-group runs:");
       for (const run of mergeGroupRuns.runs) {
@@ -42970,7 +43037,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 = _internals61.loadPluginConfig(directory);
+    const config = _internals62.loadPluginConfig(directory);
     const prMonitorConfig = config.pr_monitor;
     if (!prMonitorConfig?.enabled) {
       return [
@@ -42980,7 +43047,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
       ].join(`
 `);
     }
-    await _internals61.subscribe(directory, {
+    await _internals62.subscribe(directory, {
       sessionID,
       prNumber: prInfo.number,
       repoFullName,
@@ -43008,7 +43075,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals61 = {
+var _internals62 = {
   loadPluginConfig,
   subscribe
 };
@@ -43031,9 +43098,9 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
   const refToken = rest[0];
-  const prInfo = _internals62.parsePrRef(refToken, directory);
+  const prInfo = _internals63.parsePrRef(refToken, directory);
   if (!prInfo) {
-    if (_internals62.looksLikePrRef(refToken)) {
+    if (_internals63.looksLikePrRef(refToken)) {
       return [
         `Error: Could not resolve PR reference from "${refToken}".`,
         "",
@@ -43054,8 +43121,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 = _internals62.buildCorrelationId(sessionID, repoFullName, prInfo.number);
-    const result = await _internals62.unsubscribe(directory, correlationId);
+    const correlationId = _internals63.buildCorrelationId(sessionID, repoFullName, prInfo.number);
+    const result = await _internals63.unsubscribe(directory, correlationId);
     if (!result) {
       return [
         `Not subscribed to ${prUrl}`,
@@ -43082,7 +43149,7 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals62 = {
+var _internals63 = {
   unsubscribe,
   buildCorrelationId,
   parsePrRef,
@@ -43522,15 +43589,15 @@ var lint = createSwarmTool({
     }
     const { mode } = args;
     const cwd = directory;
-    const linter = await _internals63.detectAvailableLinter(directory);
+    const linter = await _internals64.detectAvailableLinter(directory);
     if (linter) {
-      const result = await _internals63.runLint(linter, mode, directory);
+      const result = await _internals64.runLint(linter, mode, directory);
       return JSON.stringify(result, null, 2);
     }
-    const additionalLinter = _internals63.detectAdditionalLinter(cwd);
+    const additionalLinter = _internals64.detectAdditionalLinter(cwd);
     if (additionalLinter) {
       warn(`[lint] Using ${additionalLinter} linter for this project`);
-      const result = await _internals63.runAdditionalLint(additionalLinter, mode, cwd);
+      const result = await _internals64.runAdditionalLint(additionalLinter, mode, cwd);
       return JSON.stringify(result, null, 2);
     }
     const errorResult = {
@@ -43544,7 +43611,7 @@ For Rust: rustup component add clippy`
     return JSON.stringify(errorResult, null, 2);
   }
 });
-var _internals63 = {
+var _internals64 = {
   detectAvailableLinter,
   runLint,
   detectAdditionalLinter,
@@ -43916,13 +43983,13 @@ function readBoundedFile(filePath) {
   let fd;
   try {
     const flags = fs31.constants.O_RDONLY | (O_NOFOLLOW !== undefined ? O_NOFOLLOW : 0);
-    fd = _internals64.openFile(filePath, flags);
+    fd = _internals65.openFile(filePath, flags);
   } catch {
     return { status: "incomplete", reason: "read_error" };
   }
   let outcome;
   try {
-    const stat6 = _internals64.fstatFile(fd);
+    const stat6 = _internals65.fstatFile(fd);
     const initialSize = stat6.size;
     if (!stat6.isFile()) {
       outcome = { status: "incomplete", reason: "non_file" };
@@ -43931,12 +43998,12 @@ function readBoundedFile(filePath) {
       const buffer = Buffer.allocUnsafe(bufferLength);
       let bytesRead = 0;
       while (bytesRead < buffer.length) {
-        const count = _internals64.readFileChunk(fd, buffer, bytesRead, buffer.length - bytesRead, null);
+        const count = _internals65.readFileChunk(fd, buffer, bytesRead, buffer.length - bytesRead, null);
         if (count === 0)
           break;
         bytesRead += count;
       }
-      const postStat = _internals64.fstatFile(fd);
+      const postStat = _internals65.fstatFile(fd);
       if (postStat.size !== initialSize) {
         outcome = {
           status: "incomplete",
@@ -43954,7 +44021,7 @@ function readBoundedFile(filePath) {
     outcome = { status: "incomplete", reason: "read_error" };
   }
   try {
-    _internals64.closeFile(fd);
+    _internals65.closeFile(fd);
   } catch {
     return { status: "incomplete", reason: "read_error" };
   }
@@ -44142,8 +44209,8 @@ async function collectScannableFiles(dir, excludeExact, excludeGlobs, scanDir, v
       while (true) {
         if (state.entriesSinceYield >= DISCOVERY_YIELD_INTERVAL) {
           state.entriesSinceYield = 0;
-          await _internals64.yieldToEventLoop();
-          if (_internals64.now() >= state.deadline) {
+          await _internals65.yieldToEventLoop();
+          if (_internals65.now() >= state.deadline) {
             state.deadlineExceeded = true;
             recordIncompletePath(state.incompletePaths, scanDir, currentDir, "deadline");
             stoppedEarly = true;
@@ -44206,7 +44273,7 @@ async function collectScannableFiles(dir, excludeExact, excludeGlobs, scanDir, v
       }
     } finally {
       try {
-        _internals64.closeDirectory(directory);
+        _internals65.closeDirectory(directory);
       } catch (error2) {
         if (error2.code !== "ERR_DIR_CLOSED") {
           state.cleanupFailed = true;
@@ -44328,7 +44395,7 @@ var secretscan = createSwarmTool({
         symlinkSkipped: 0
       };
       const visited = new Set;
-      const deadline = _internals64.now() + SCAN_TIME_BUDGET_MS;
+      const deadline = _internals65.now() + SCAN_TIME_BUDGET_MS;
       const discovery = {
         files: [],
         totalCandidates: 0,
@@ -44340,7 +44407,7 @@ var secretscan = createSwarmTool({
         directoriesQueued: 1,
         unexaminedDirectories: 0
       };
-      await _internals64.yieldToEventLoop();
+      await _internals65.yieldToEventLoop();
       await collectScannableFiles(scanDir, excludeExact, excludeGlobs, scanDir, visited, stats, discovery);
       const files = discovery.files;
       files.sort(compareFilePaths);
@@ -44359,7 +44426,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 (_internals64.now() >= deadline) {
+        if (_internals65.now() >= deadline) {
           for (const remaining of filesToScan.slice(index)) {
             recordIncompletePath(discovery.incompletePaths, scanDir, remaining, "deadline");
           }
@@ -44395,7 +44462,7 @@ var secretscan = createSwarmTool({
           }
         }
         if (index + 1 < filesToScan.length) {
-          await _internals64.yieldToEventLoop();
+          await _internals65.yieldToEventLoop();
         }
       }
       allFindings.sort((a, b) => {
@@ -44458,7 +44525,7 @@ var secretscan = createSwarmTool({
 });
 async function runSecretscan(directory) {
   try {
-    const result = await _internals64.secretscan.execute({ directory }, {});
+    const result = await _internals65.secretscan.execute({ directory }, {});
     const jsonStr = typeof result === "string" ? result : result.output;
     return JSON.parse(jsonStr);
   } catch (e) {
@@ -44509,10 +44576,10 @@ async function runSecretscanOnFiles(files, directory) {
     if (files.length > filesToScan.length) {
       recordIncompletePath(incompletePaths, canonicalRoot, canonicalRoot, "max_files");
     }
-    const deadline = _internals64.now() + SCAN_TIME_BUDGET_MS;
-    await _internals64.yieldToEventLoop();
+    const deadline = _internals65.now() + SCAN_TIME_BUDGET_MS;
+    await _internals65.yieldToEventLoop();
     for (let index = 0;index < filesToScan.length; index++) {
-      if (_internals64.now() >= deadline) {
+      if (_internals65.now() >= deadline) {
         for (const remaining of filesToScan.slice(index)) {
           const remainingPath = path77.isAbsolute(remaining) ? path77.resolve(remaining) : path77.resolve(rawRoot, remaining);
           recordIncompletePath(incompletePaths, canonicalRoot, remainingPath, "deadline");
@@ -44539,7 +44606,7 @@ async function runSecretscanOnFiles(files, directory) {
       }
       let lstat3;
       try {
-        lstat3 = _internals64.lstatFile(resolvedPath);
+        lstat3 = _internals65.lstatFile(resolvedPath);
       } catch (error2) {
         const err = error2;
         if (err.code === "ENOENT") {
@@ -44608,7 +44675,7 @@ async function runSecretscanOnFiles(files, directory) {
           assertNever(outcome);
       }
       if (index + 1 < filesToScan.length) {
-        await _internals64.yieldToEventLoop();
+        await _internals65.yieldToEventLoop();
       }
     }
     findings.sort((a, b) => {
@@ -44638,7 +44705,7 @@ async function runSecretscanOnFiles(files, directory) {
     };
   }
 }
-var _internals64 = {
+var _internals65 = {
   secretscan,
   runSecretscan,
   runSecretscanOnFiles,
@@ -44922,7 +44989,7 @@ async function buildImpactMapInternal(cwd) {
   }
   return impactMap;
 }
-var _internals65 = {
+var _internals66 = {
   validateProjectRoot,
   normalizePath: normalizePath2,
   isCacheStale,
@@ -44937,8 +45004,8 @@ var _internals65 = {
   _clearGoModuleCache
 };
 async function buildImpactMap(cwd) {
-  const impactMap = await _internals65.buildImpactMapInternal(cwd);
-  await _internals65.saveImpactMap(cwd, impactMap);
+  const impactMap = await _internals66.buildImpactMapInternal(cwd);
+  await _internals66.saveImpactMap(cwd, impactMap);
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
@@ -44952,7 +45019,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 (!_internals65.isCacheStale(map, generatedAt)) {
+          if (!_internals66.isCacheStale(map, generatedAt)) {
             return map;
           }
           if (options?.skipRebuild) {
@@ -44972,13 +45039,13 @@ async function loadImpactMap(cwd, options) {
   if (options?.skipRebuild) {
     return {};
   }
-  return _internals65.buildImpactMap(cwd);
+  return _internals66.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
   if (!path78.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
-  _internals65.validateProjectRoot(cwd);
+  _internals66.validateProjectRoot(cwd);
   const cacheDir2 = path78.join(cwd, ".swarm", "cache");
   const cachePath = path78.join(cacheDir2, "impact-map.json");
   if (!fs32.existsSync(cacheDir2)) {
@@ -45002,7 +45069,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
     };
   }
   const validFiles = changedFiles.filter((f) => typeof f === "string" && f.length > 0 && !f.includes("\x00"));
-  const impactMap = await _internals65.loadImpactMap(cwd);
+  const impactMap = await _internals66.loadImpactMap(cwd);
   const impactedTestsSet = new Set;
   const untestedFiles = [];
   let visitedCount = 0;
@@ -45279,7 +45346,7 @@ function batchAppendTestRuns(records, workingDir) {
   }
   const historyPath = getHistoryPath(workingDir);
   const historyDir = path79.dirname(historyPath);
-  _internals66.validateProjectRoot(workingDir);
+  _internals67.validateProjectRoot(workingDir);
   if (!fs33.existsSync(historyDir)) {
     fs33.mkdirSync(historyDir, { recursive: true });
   }
@@ -45402,7 +45469,7 @@ function getAllHistory(workingDir) {
   records.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
   return records;
 }
-var _internals66 = {
+var _internals67 = {
   validateProjectRoot
 };
 
@@ -45494,7 +45561,7 @@ var MAX_SAFE_TEST_FILES = 50;
 var MAX_SAFE_SOURCE_FILES = 1;
 async function estimateFanOut(sourceFiles, cwd) {
   try {
-    const impactMap = await _internals67.loadImpactMap(cwd, {
+    const impactMap = await _internals68.loadImpactMap(cwd, {
       skipRebuild: true
     });
     const uniqueTestFiles = new Set;
@@ -45584,45 +45651,45 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return _internals67.existsSync(path81.join(cwd, "go.mod")) && _internals67.isCommandAvailable("go");
+  return _internals68.existsSync(path81.join(cwd, "go.mod")) && _internals68.isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return _internals67.existsSync(path81.join(cwd, "pom.xml")) && _internals67.isCommandAvailable("mvn");
+  return _internals68.existsSync(path81.join(cwd, "pom.xml")) && _internals68.isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = _internals67.existsSync(path81.join(cwd, "build.gradle")) || _internals67.existsSync(path81.join(cwd, "build.gradle.kts"));
-  const hasGradlew = _internals67.existsSync(path81.join(cwd, "gradlew")) || _internals67.existsSync(path81.join(cwd, "gradlew.bat"));
-  return hasBuildFile && (hasGradlew || _internals67.isCommandAvailable("gradle"));
+  const hasBuildFile = _internals68.existsSync(path81.join(cwd, "build.gradle")) || _internals68.existsSync(path81.join(cwd, "build.gradle.kts"));
+  const hasGradlew = _internals68.existsSync(path81.join(cwd, "gradlew")) || _internals68.existsSync(path81.join(cwd, "gradlew.bat"));
+  return hasBuildFile && (hasGradlew || _internals68.isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
   try {
-    const files = _internals67.readdirSync(cwd);
+    const files = _internals68.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj"));
-    return hasCsproj && _internals67.isCommandAvailable("dotnet");
+    return hasCsproj && _internals68.isCommandAvailable("dotnet");
   } catch {
     return false;
   }
 }
 function detectCTest(cwd) {
-  const hasSource = _internals67.existsSync(path81.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = _internals67.existsSync(path81.join(cwd, "CMakeCache.txt")) || _internals67.existsSync(path81.join(cwd, "build", "CMakeCache.txt"));
-  return (hasSource || hasBuildCache) && _internals67.isCommandAvailable("ctest");
+  const hasSource = _internals68.existsSync(path81.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = _internals68.existsSync(path81.join(cwd, "CMakeCache.txt")) || _internals68.existsSync(path81.join(cwd, "build", "CMakeCache.txt"));
+  return (hasSource || hasBuildCache) && _internals68.isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return _internals67.existsSync(path81.join(cwd, "Package.swift")) && _internals67.isCommandAvailable("swift");
+  return _internals68.existsSync(path81.join(cwd, "Package.swift")) && _internals68.isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return _internals67.existsSync(path81.join(cwd, "pubspec.yaml")) && (_internals67.isCommandAvailable("dart") || _internals67.isCommandAvailable("flutter"));
+  return _internals68.existsSync(path81.join(cwd, "pubspec.yaml")) && (_internals68.isCommandAvailable("dart") || _internals68.isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = _internals67.existsSync(path81.join(cwd, ".rspec"));
-  const hasGemfile = _internals67.existsSync(path81.join(cwd, "Gemfile"));
-  const hasSpecDir = _internals67.existsSync(path81.join(cwd, "spec"));
+  const hasRSpecFile = _internals68.existsSync(path81.join(cwd, ".rspec"));
+  const hasGemfile = _internals68.existsSync(path81.join(cwd, "Gemfile"));
+  const hasSpecDir = _internals68.existsSync(path81.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
-  return hasRSpec && (_internals67.isCommandAvailable("bundle") || _internals67.isCommandAvailable("rspec"));
+  return hasRSpec && (_internals68.isCommandAvailable("bundle") || _internals68.isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return _internals67.existsSync(path81.join(cwd, "test")) && (_internals67.existsSync(path81.join(cwd, "Gemfile")) || _internals67.existsSync(path81.join(cwd, "Rakefile"))) && _internals67.isCommandAvailable("ruby");
+  return _internals68.existsSync(path81.join(cwd, "test")) && (_internals68.existsSync(path81.join(cwd, "Gemfile")) || _internals68.existsSync(path81.join(cwd, "Rakefile"))) && _internals68.isCommandAvailable("ruby");
 }
 var DISPATCH_FRAMEWORK_MAP = {
   bun: "bun",
@@ -45713,8 +45780,8 @@ async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
     const packageJsonPath = path81.join(baseDir, "package.json");
-    if (_internals67.existsSync(packageJsonPath)) {
-      const content = _internals67.readFileSync(packageJsonPath, "utf-8");
+    if (_internals68.existsSync(packageJsonPath)) {
+      const content = _internals68.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       const _deps = pkg.dependencies || {};
       const devDeps = pkg.devDependencies || {};
@@ -45733,7 +45800,7 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (_internals67.existsSync(path81.join(baseDir, "bun.lockb")) || _internals67.existsSync(path81.join(baseDir, "bun.lock"))) {
+      if (_internals68.existsSync(path81.join(baseDir, "bun.lockb")) || _internals68.existsSync(path81.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
@@ -45743,28 +45810,28 @@ async function detectTestFramework(cwd) {
     const pyprojectTomlPath = path81.join(baseDir, "pyproject.toml");
     const setupCfgPath = path81.join(baseDir, "setup.cfg");
     const requirementsTxtPath = path81.join(baseDir, "requirements.txt");
-    if (_internals67.existsSync(pyprojectTomlPath)) {
-      const content = _internals67.readFileSync(pyprojectTomlPath, "utf-8");
+    if (_internals68.existsSync(pyprojectTomlPath)) {
+      const content = _internals68.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
         return "pytest";
       if (content.includes("pytest"))
         return "pytest";
     }
-    if (_internals67.existsSync(setupCfgPath)) {
-      const content = _internals67.readFileSync(setupCfgPath, "utf-8");
+    if (_internals68.existsSync(setupCfgPath)) {
+      const content = _internals68.readFileSync(setupCfgPath, "utf-8");
       if (content.includes("[pytest]"))
         return "pytest";
     }
-    if (_internals67.existsSync(requirementsTxtPath)) {
-      const content = _internals67.readFileSync(requirementsTxtPath, "utf-8");
+    if (_internals68.existsSync(requirementsTxtPath)) {
+      const content = _internals68.readFileSync(requirementsTxtPath, "utf-8");
       if (content.includes("pytest"))
         return "pytest";
     }
   } catch {}
   try {
     const cargoTomlPath = path81.join(baseDir, "Cargo.toml");
-    if (_internals67.existsSync(cargoTomlPath)) {
-      const content = _internals67.readFileSync(cargoTomlPath, "utf-8");
+    if (_internals68.existsSync(cargoTomlPath)) {
+      const content = _internals68.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
         if (content.includes("tokio") || content.includes("mockall") || content.includes("pretty_assertions")) {
           return "cargo";
@@ -45776,7 +45843,7 @@ async function detectTestFramework(cwd) {
     const pesterConfigPath = path81.join(baseDir, "pester.config.ps1");
     const pesterConfigJsonPath = path81.join(baseDir, "pester.config.ps1.json");
     const pesterPs1Path = path81.join(baseDir, "tests.ps1");
-    if (_internals67.existsSync(pesterConfigPath) || _internals67.existsSync(pesterConfigJsonPath) || _internals67.existsSync(pesterPs1Path)) {
+    if (_internals68.existsSync(pesterConfigPath) || _internals68.existsSync(pesterConfigJsonPath) || _internals68.existsSync(pesterPs1Path)) {
       return "pester";
     }
   } catch {}
@@ -45804,12 +45871,12 @@ async function detectTestFramework(cwd) {
   return "none";
 }
 function detectPhpTest(cwd) {
-  if (_internals67.existsSync(path81.join(cwd, "artisan")) && _internals67.existsSync(path81.join(cwd, "composer.json"))) {
+  if (_internals68.existsSync(path81.join(cwd, "artisan")) && _internals68.existsSync(path81.join(cwd, "composer.json"))) {
     return "php-artisan";
   }
-  if (_internals67.existsSync(path81.join(cwd, "Pest.php")))
+  if (_internals68.existsSync(path81.join(cwd, "Pest.php")))
     return "pest";
-  if (_internals67.existsSync(path81.join(cwd, "phpunit.xml")) || _internals67.existsSync(path81.join(cwd, "phpunit.xml.dist"))) {
+  if (_internals68.existsSync(path81.join(cwd, "phpunit.xml")) || _internals68.existsSync(path81.join(cwd, "phpunit.xml.dist"))) {
     return "phpunit";
   }
   return null;
@@ -46191,9 +46258,9 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
     case "swift-test":
       return ["swift", "test"];
     case "dart-test":
-      return _internals67.isCommandAvailable("flutter") ? ["flutter", "test", ...files] : ["dart", "test", ...files];
+      return _internals68.isCommandAvailable("flutter") ? ["flutter", "test", ...files] : ["dart", "test", ...files];
     case "rspec": {
-      const args = _internals67.isCommandAvailable("bundle") ? ["bundle", "exec", "rspec"] : ["rspec"];
+      const args = _internals68.isCommandAvailable("bundle") ? ["bundle", "exec", "rspec"] : ["rspec"];
       if (bail)
         args.push("--fail-fast");
       if (scope !== "all" && files.length > 0) {
@@ -47206,7 +47273,7 @@ var test_runner = createSwarmTool({
         return JSON.stringify(errorResult, null, 2);
       }
       try {
-        const impactResult = await _internals67.analyzeImpact(sourceFiles, workingDir, MAX_SAFE_TEST_FILES);
+        const impactResult = await _internals68.analyzeImpact(sourceFiles, workingDir, MAX_SAFE_TEST_FILES);
         if (impactResult.budgetExceeded) {
           const errorResult = {
             success: false,
@@ -47296,7 +47363,7 @@ var test_runner = createSwarmTool({
     return JSON.stringify(result, null, 2);
   }
 });
-var _internals67 = {
+var _internals68 = {
   analyzeImpact,
   loadImpactMap,
   isCommandAvailable,
@@ -47398,9 +47465,9 @@ function getVersionFileVersion(dir) {
 async function runVersionCheck(dir, _timeoutMs) {
   const startTime = Date.now();
   try {
-    const packageVersion = _internals68.getPackageVersion(dir);
-    const changelogVersion = _internals68.getChangelogVersion(dir);
-    const versionFileVersion = _internals68.getVersionFileVersion(dir);
+    const packageVersion = _internals69.getPackageVersion(dir);
+    const changelogVersion = _internals69.getChangelogVersion(dir);
+    const versionFileVersion = _internals69.getVersionFileVersion(dir);
     const versions = [];
     if (packageVersion)
       versions.push(`package.json: ${packageVersion}`);
@@ -47589,7 +47656,7 @@ async function runTestsCheck(_dir, scope, timeoutMs) {
 async function runSecretsCheck(dir, timeoutMs) {
   const startTime = Date.now();
   try {
-    const secretsPromise = _internals68.runSecretscan(dir);
+    const secretsPromise = _internals69.runSecretscan(dir);
     const timeoutPromise = new Promise((_, reject) => {
       setTimeout(() => {
         reject(new Error(`Secrets check timed out after ${timeoutMs}ms`));
@@ -47811,7 +47878,7 @@ async function runPreflight(dir, phase, config) {
   const reportId = `preflight-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   let validatedDir;
   try {
-    validatedDir = _internals68.validateDirectoryPath(dir);
+    validatedDir = _internals69.validateDirectoryPath(dir);
   } catch (error2) {
     return {
       id: reportId,
@@ -47831,7 +47898,7 @@ async function runPreflight(dir, phase, config) {
   }
   let validatedTimeout;
   try {
-    validatedTimeout = _internals68.validateTimeout(config?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
+    validatedTimeout = _internals69.validateTimeout(config?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
   } catch (error2) {
     return {
       id: reportId,
@@ -47872,12 +47939,12 @@ async function runPreflight(dir, phase, config) {
   });
   const checks = [];
   log("[Preflight] Running lint check...");
-  const lintResult = await _internals68.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
+  const lintResult = await _internals69.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 _internals68.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
+    const testsResult = await _internals69.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
     checks.push(testsResult);
     log(`[Preflight] Tests check: ${testsResult.status} ${testsResult.message}`);
   } else {
@@ -47889,7 +47956,7 @@ async function runPreflight(dir, phase, config) {
   }
   if (!cfg.skipSecrets) {
     log("[Preflight] Running secrets check...");
-    const secretsResult = await _internals68.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
+    const secretsResult = await _internals69.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
     checks.push(secretsResult);
     log(`[Preflight] Secrets check: ${secretsResult.status} ${secretsResult.message}`);
   } else {
@@ -47901,7 +47968,7 @@ async function runPreflight(dir, phase, config) {
   }
   if (!cfg.skipEvidence) {
     log("[Preflight] Running evidence check...");
-    const evidenceResult = await _internals68.runEvidenceCheck(validatedDir);
+    const evidenceResult = await _internals69.runEvidenceCheck(validatedDir);
     checks.push(evidenceResult);
     log(`[Preflight] Evidence check: ${evidenceResult.status} ${evidenceResult.message}`);
   } else {
@@ -47912,12 +47979,12 @@ async function runPreflight(dir, phase, config) {
     });
   }
   log("[Preflight] Running requirement coverage check...");
-  const reqCoverageResult = await _internals68.runRequirementCoverageCheck(validatedDir, phase);
+  const reqCoverageResult = await _internals69.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 _internals68.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
+    const versionResult = await _internals69.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
     checks.push(versionResult);
     log(`[Preflight] Version check: ${versionResult.status} ${versionResult.message}`);
   } else {
@@ -47980,10 +48047,10 @@ function formatPreflightMarkdown(report) {
 async function handlePreflightCommand(directory, _args) {
   const plan = await loadPlan(directory);
   const phase = plan?.current_phase ?? 1;
-  const report = await _internals68.runPreflight(directory, phase);
-  return _internals68.formatPreflightMarkdown(report);
+  const report = await _internals69.runPreflight(directory, phase);
+  return _internals69.formatPreflightMarkdown(report);
 }
-var _internals68 = {
+var _internals69 = {
   runPreflight,
   formatPreflightMarkdown,
   handlePreflightCommand,
@@ -48977,7 +49044,7 @@ function pruneOldResetBackups(backupsRoot, warnings) {
 }
 
 // src/commands/reset.ts
-var _internals69 = {
+var _internals70 = {
   backupSwarmStateBeforeReset
 };
 async function handleResetCommand(directory, args) {
@@ -49012,7 +49079,7 @@ async function handleResetCommand(directory, args) {
   ];
   const results = [];
   try {
-    const backup = _internals69.backupSwarmStateBeforeReset(directory, "reset", [
+    const backup = _internals70.backupSwarmStateBeforeReset(directory, "reset", [
       ...filesToReset,
       "summaries"
     ]);
@@ -49564,7 +49631,7 @@ async function recordReplayEntry(artifactPath, sessionID, entry) {
 }
 
 // src/prm/index.ts
-var _internals70 = {
+var _internals71 = {
   getAgentSession,
   readTrajectory,
   getInMemoryTrajectory,
@@ -49592,12 +49659,12 @@ function resetPrmSessionState(session, sessionId) {
   session.prmInjectedAdvisoryKeys = new Set;
   session.replayArtifactPath = null;
   if (sessionId) {
-    _internals70.clearTrajectoryCache(sessionId);
+    _internals71.clearTrajectoryCache(sessionId);
   }
 }
 
 // src/commands/reset-session.ts
-var _internals71 = {
+var _internals72 = {
   cleanupOrphanedBranches,
   backupSwarmStateBeforeReset
 };
@@ -49609,7 +49676,7 @@ function errorMessage(err) {
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
-    const backup = _internals71.backupSwarmStateBeforeReset(directory, "reset-session", ["session"]);
+    const backup = _internals72.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/)`);
@@ -49676,7 +49743,7 @@ async function handleResetSessionCommand(directory, _args) {
     results.push(`\u26A0\uFE0F Failed to remove .swarm-worktrees/: ${errorMessage(err)}`);
   }
   try {
-    const branchResult = await _internals71.cleanupOrphanedBranches(directory, []);
+    const branchResult = await _internals72.cleanupOrphanedBranches(directory, []);
     if (branchResult.removed.length > 0) {
       results.push(`\u2705 Removed ${branchResult.removed.length} orphan swarm-lane branch(es)`);
     }
@@ -49835,7 +49902,7 @@ function resolveReceiptsDir(directory) {
 function resolveReceiptIndexPath(directory) {
   return path88.join(resolveReceiptsDir(directory), "index.json");
 }
-var _internals72 = {
+var _internals73 = {
   openSync: fs41.openSync,
   lstatBigIntSync: (path89) => fs41.lstatSync(path89, { bigint: true }),
   fstatBigIntSync: (fd) => fs41.fstatSync(fd, { bigint: true })
@@ -49847,7 +49914,7 @@ function pathsEqual(left, right) {
 }
 function captureCanonicalDirectory(directory, label, expected) {
   const resolved = path88.resolve(directory);
-  const stat6 = _internals72.lstatBigIntSync(resolved);
+  const stat6 = _internals73.lstatBigIntSync(resolved);
   if (!stat6.isDirectory() || stat6.isSymbolicLink()) {
     throw new Error(`${label} must be a real directory`);
   }
@@ -49933,7 +50000,7 @@ function assertDirectReceiptFile(context, filePath, mustExist) {
     throw new Error("review receipt file escapes its expected directory");
   }
   try {
-    const stat6 = _internals72.lstatBigIntSync(resolved);
+    const stat6 = _internals73.lstatBigIntSync(resolved);
     if (!stat6.isFile() || stat6.isSymbolicLink()) {
       throw new Error("review receipt path must be a real file");
     }
@@ -49957,7 +50024,7 @@ function readReviewReceiptText(directory, receiptPath, maxBytes = 1048576) {
     const resolved = assertDirectReceiptFile(context, receiptPath, true);
     if (path88.extname(resolved) !== ".json")
       return null;
-    const pathBeforeOpen = _internals72.lstatBigIntSync(resolved);
+    const pathBeforeOpen = _internals73.lstatBigIntSync(resolved);
     if (!pathBeforeOpen.isFile() || pathBeforeOpen.isSymbolicLink() || pathBeforeOpen.size < 0n || pathBeforeOpen.size > BigInt(maxBytes)) {
       return null;
     }
@@ -49965,10 +50032,10 @@ function readReviewReceiptText(directory, receiptPath, maxBytes = 1048576) {
     if (!pathsEqual(canonicalBeforeOpen, resolved))
       return null;
     assertReceiptContextCurrent(context);
-    descriptor = _internals72.openSync(canonicalBeforeOpen, "r");
-    const openedBeforeRead = _internals72.fstatBigIntSync(descriptor);
+    descriptor = _internals73.openSync(canonicalBeforeOpen, "r");
+    const openedBeforeRead = _internals73.fstatBigIntSync(descriptor);
     assertReceiptContextCurrent(context);
-    const pathAfterOpen = _internals72.lstatBigIntSync(resolved);
+    const pathAfterOpen = _internals73.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;
@@ -49981,9 +50048,9 @@ function readReviewReceiptText(directory, receiptPath, maxBytes = 1048576) {
         break;
       bytesRead += count;
     }
-    const openedAfterRead = _internals72.fstatBigIntSync(descriptor);
+    const openedAfterRead = _internals73.fstatBigIntSync(descriptor);
     assertReceiptContextCurrent(context);
-    const pathAfterRead = _internals72.lstatBigIntSync(resolved);
+    const pathAfterRead = _internals73.lstatBigIntSync(resolved);
     const canonicalAfterRead = fs41.realpathSync(resolved);
     if (bytesRead !== buffer.length || !sameFileSnapshot2(openedBeforeRead, openedAfterRead) || !sameFileSnapshot2(openedAfterRead, pathAfterRead) || !pathsEqual(canonicalBeforeOpen, canonicalAfterRead)) {
       return null;
@@ -50527,7 +50594,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 _internals73 = {
+var _internals74 = {
   spawn: child_process7.spawn,
   realpath: fs42.promises.realpath,
   lstatBigInt: (path90) => fs42.promises.lstat(path90, { bigint: true }),
@@ -50567,7 +50634,7 @@ async function missingPathParentIsContained(root, absolutePath2) {
   let current = path89.dirname(absolutePath2);
   for (;; ) {
     try {
-      const canonical = await _internals73.realpath(current);
+      const canonical = await _internals74.realpath(current);
       return samePath2(root, canonical) || isContained2(root, canonical);
     } catch (error2) {
       if (error2.code !== "ENOENT")
@@ -50594,7 +50661,7 @@ async function resolveHeadSha(directory) {
   let child;
   let timeoutHandle;
   try {
-    child = _internals73.spawn("git", ["rev-parse", "--verify", "HEAD"], {
+    child = _internals74.spawn("git", ["rev-parse", "--verify", "HEAD"], {
       cwd: directory,
       stdio: ["ignore", "pipe", "ignore"],
       timeout: HEAD_TIMEOUT_MS,
@@ -50657,7 +50724,7 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
   let realRoot;
   try {
     lexicalRoot = path89.resolve(directory);
-    realRoot = await _internals73.realpath(lexicalRoot);
+    realRoot = await _internals74.realpath(lexicalRoot);
   } catch {
     return null;
   }
@@ -50698,7 +50765,7 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
   for (const candidate of ordered) {
     let before;
     try {
-      before = await _internals73.lstatBigInt(candidate.absolutePath);
+      before = await _internals74.lstatBigInt(candidate.absolutePath);
     } catch (error2) {
       if (error2.code === "ENOENT") {
         if (!await missingPathParentIsContained(realRoot, candidate.absolutePath)) {
@@ -50717,7 +50784,7 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
       return null;
     let realCandidate;
     try {
-      realCandidate = await _internals73.realpath(candidate.absolutePath);
+      realCandidate = await _internals74.realpath(candidate.absolutePath);
     } catch {
       return null;
     }
@@ -50729,15 +50796,15 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
     let bytes;
     let openedBefore;
     try {
-      handle = await _internals73.open(realCandidate, "r");
-      openedBefore = await _internals73.fileHandleStatBigInt(handle);
-      const canonicalAfterOpen = await _internals73.realpath(candidate.absolutePath);
+      handle = await _internals74.open(realCandidate, "r");
+      openedBefore = await _internals74.fileHandleStatBigInt(handle);
+      const canonicalAfterOpen = await _internals74.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 _internals73.fileHandleStatBigInt(handle);
-      const canonicalAfterRead = await _internals73.realpath(candidate.absolutePath);
+      const openedAfter = await _internals74.fileHandleStatBigInt(handle);
+      const canonicalAfterRead = await _internals74.realpath(candidate.absolutePath);
       if (!sameFileSnapshot3(openedBefore, openedAfter) || !samePath2(realCandidate, canonicalAfterRead) || !isContained2(realRoot, canonicalAfterRead) || BigInt(bytes.byteLength) !== openedBefore.size) {
         return null;
       }
@@ -50761,8 +50828,8 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
   }
   for (const stable of stableFiles) {
     try {
-      const current = await _internals73.lstatBigInt(stable.absolutePath);
-      const canonical = await _internals73.realpath(stable.absolutePath);
+      const current = await _internals74.lstatBigInt(stable.absolutePath);
+      const canonical = await _internals74.realpath(stable.absolutePath);
       if (!current.isFile() || current.isSymbolicLink() || !sameFileSnapshot3(stable.stat, current) || !samePath2(stable.canonicalPath, canonical) || !isContained2(realRoot, canonical)) {
         return null;
       }
@@ -50772,7 +50839,7 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
   }
   for (const deletedPath of deletedPaths) {
     try {
-      await _internals73.lstatBigInt(deletedPath);
+      await _internals74.lstatBigInt(deletedPath);
       return null;
     } catch (error2) {
       if (error2.code !== "ENOENT" || !await missingPathParentIsContained(realRoot, deletedPath)) {
@@ -50935,7 +51002,7 @@ function parseReviewerOutput(text, options = {}) {
     outputMode: "legacy"
   };
 }
-var _internals74 = {
+var _internals75 = {
   delegationEnd: telemetry.delegationEnd,
   resolveReviewerTaskScope,
   buildReviewerTaskScope,
@@ -50974,6 +51041,7 @@ async function persistAutoReviewEvidence(directory, evidence2, options = {}) {
       throw new Error("auto-review evidence temp path changed before commit");
     }
     fs43.renameSync(revalidatedTemp, safeTarget);
+    invalidateCachedArtifact(safeTarget);
     return safeTarget;
   } finally {
     try {
@@ -51140,7 +51208,7 @@ function scopeFreshnessMismatches(reviewed, current) {
 }
 function createScopeVerifier(input, reviewed, maxBytes) {
   return async () => {
-    const current = await _internals75.collectReviewDiff({
+    const current = await _internals76.collectReviewDiff({
       directory: input.directory,
       selector: input.selector,
       maxBytes
@@ -51149,7 +51217,7 @@ function createScopeVerifier(input, reviewed, maxBytes) {
   };
 }
 async function stalePersistenceResult(input, maxBytes, message, modelCalls) {
-  const current = await _internals75.collectReviewDiff({
+  const current = await _internals76.collectReviewDiff({
     directory: input.directory,
     selector: input.selector,
     maxBytes
@@ -51528,7 +51596,7 @@ async function persistErrorResult(input, diff, result, error2, dispatches, promp
   evidence2.review.error = error2;
   addCost(evidence2, dispatches);
   try {
-    result.evidencePath = await _internals75.persistEvidence(input.directory, evidence2);
+    result.evidencePath = await _internals76.persistEvidence(input.directory, evidence2);
   } catch {
     if (input.config.final_review.mode === "gate") {
       result.blocked = true;
@@ -51544,7 +51612,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 _internals75.collectReviewDiff({
+  const diff = await _internals76.collectReviewDiff({
     directory: input.directory,
     selector: input.selector,
     maxBytes
@@ -51558,7 +51626,7 @@ async function runReviewEngine(input) {
     const evidence3 = baseEvidence(input, diff, "clean");
     let evidencePath2;
     try {
-      evidencePath2 = await _internals75.persistEvidence(input.directory, evidence3, { verifyCurrent: createScopeVerifier(input, diff, maxBytes) });
+      evidencePath2 = await _internals76.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);
@@ -51580,7 +51648,7 @@ async function runReviewEngine(input) {
     phase: input.phase
   });
   if (input.phase !== undefined && (input.trigger === "phase_completion" || input.trigger === "plan_completion")) {
-    const existing = _internals75.readPhaseEvidence(input.directory, input.phase);
+    const existing = _internals76.readPhaseEvidence(input.directory, input.phase);
     const integrity = existing ? validateAutoReviewEvidenceIntegrity(input.directory, existing, {
       scopeHash: diff.scopeHash,
       phase: input.phase,
@@ -51706,7 +51774,7 @@ async function runReviewEngine(input) {
       validation: byId.get(finding.finding_id)
     }));
   }
-  const currentScope = await _internals75.collectReviewDiff({
+  const currentScope = await _internals76.collectReviewDiff({
     directory: input.directory,
     selector: input.selector,
     maxBytes
@@ -51785,7 +51853,7 @@ async function runReviewEngine(input) {
       findingValidations: findings.map((finding) => finding.validation).filter((item) => Boolean(item))
     });
     receiptId = receipt.id;
-    receiptPath = await _internals75.persistReceipt(input.directory, receipt, {
+    receiptPath = await _internals76.persistReceipt(input.directory, receipt, {
       verifyCurrent: createScopeVerifier(input, diff, maxBytes)
     });
     evidence2.receipt_path = receiptPath;
@@ -51815,7 +51883,7 @@ async function runReviewEngine(input) {
   }
   let evidencePath;
   try {
-    evidencePath = await _internals75.persistEvidence(input.directory, evidence2, {
+    evidencePath = await _internals76.persistEvidence(input.directory, evidence2, {
       verifyCurrent: createScopeVerifier(input, diff, maxBytes)
     });
   } catch (error2) {
@@ -51852,7 +51920,7 @@ async function runReviewEngine(input) {
   input.injectAdvisory?.(input.sessionID, advisoryMessage(input, result));
   return result;
 }
-var _internals75 = {
+var _internals76 = {
   collectReviewDiff,
   persistEvidence: persistAutoReviewEvidence,
   persistReceipt: persistReviewReceipt,
@@ -52123,7 +52191,7 @@ async function handleReviewCommand(ctx) {
   } catch (error2) {
     return `Review configuration error: ${error2 instanceof Error ? error2.message : String(error2)}`;
   }
-  const result = await _internals76.runReviewEngine({
+  const result = await _internals77.runReviewEngine({
     directory: ctx.directory,
     sessionID: ctx.sessionID,
     trigger: "manual",
@@ -52137,10 +52205,10 @@ async function handleReviewCommand(ctx) {
     validatorModel,
     validatorFallbackModels
   });
-  const evidence2 = _internals76.readEvidence(result.evidencePath, ctx.directory);
+  const evidence2 = _internals77.readEvidence(result.evidencePath, ctx.directory);
   return parsed.json ? renderJson(result, evidence2, parsed.selector) : renderHuman(result, evidence2, parsed.selector);
 }
-var _internals76 = {
+var _internals77 = {
   runReviewEngine,
   readEvidence
 };
@@ -52291,7 +52359,7 @@ async function handleRollbackCommand(directory, args) {
   if (checkpointFiles.length === 0) {
     return `Error: Checkpoint for phase ${targetPhase} is empty. Cannot rollback.`;
   }
-  const swarmDir = validateSwarmPath(directory, "");
+  const swarmDir = path93.dirname(validateSwarmPath(directory, ".keep"));
   const EXCLUDE_FILES = new Set([
     "plan-ledger.jsonl",
     "plan-ledger.quarantine"
@@ -52312,6 +52380,7 @@ async function handleRollbackCommand(directory, args) {
       failures.push({ file, error: error2.message });
     }
   }
+  resetSwarmArtifactCache();
   if (failures.length > 0) {
     return [
       `Rollback partially completed. Successfully restored ${successes.length} files.`,
@@ -52385,7 +52454,7 @@ async function handleRollbackCommand(directory, args) {
 // src/commands/sdd.ts
 import * as fs47 from "fs";
 import * as path94 from "path";
-var _internals77 = {
+var _internals78 = {
   writeProjectedSpecSync
 };
 var SWARM_SPEC_REL = path94.join(".swarm", "spec.md");
@@ -52781,7 +52850,7 @@ ${USAGE12}`;
 
 ${USAGE12}`;
     }
-    const result2 = _internals77.writeProjectedSpecSync(directory, {
+    const result2 = _internals78.writeProjectedSpecSync(directory, {
       source: "speckit",
       feature: resolution.feature,
       dryRun: parsed.dryRun,
@@ -52839,7 +52908,7 @@ ${formatList(result2.projection.warnings)}` : ""
     ].join(`
 `);
   }
-  const result = _internals77.writeProjectedSpecSync(directory, {
+  const result = _internals78.writeProjectedSpecSync(directory, {
     changeId: parsed.changeId,
     dryRun: parsed.dryRun,
     overwrite: parsed.overwrite
@@ -52920,7 +52989,7 @@ async function handleSimulateCommand(directory, args) {
   }
   let darkMatterPairs;
   try {
-    darkMatterPairs = await _internals38.detectDarkMatter(directory, options);
+    darkMatterPairs = await _internals39.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Simulate Report
@@ -53078,7 +53147,7 @@ function writeFileFsyncedThenRename(tempPath, targetPath, data) {
     throw err;
   }
 }
-var _internals78 = {
+var _internals79 = {
   withEvidenceLock,
   writeFileFsyncedThenRename,
   writeFileSync: writeFileSyncAsync,
@@ -53097,7 +53166,7 @@ async function appendEvent(directory, eventInput) {
   }
   const filePath = ledgerPath(directory, eventInput.skillSlug, eventInput.candidateId);
   ensureCandidateDir(directory, eventInput.skillSlug, eventInput.candidateId);
-  return _internals78.withEvidenceLock(directory, path95.join(".swarm", "evolution", "skills", eventInput.skillSlug, eventInput.candidateId, "lifecycle.jsonl"), "skill-opt-ledger", "append-skill-opt-event", async () => {
+  return _internals79.withEvidenceLock(directory, path95.join(".swarm", "evolution", "skills", eventInput.skillSlug, eventInput.candidateId, "lifecycle.jsonl"), "skill-opt-ledger", "append-skill-opt-event", async () => {
     const existing = existsSync53(filePath) ? readFileSync39(filePath, "utf8") : "";
     const events = parseEventsFromText(existing);
     const nextSeq = events.length === 0 ? 1 : events[events.length - 1].seq + 1;
@@ -53128,8 +53197,8 @@ async function appendEvent(directory, eventInput) {
     const validContent = events.map((e) => JSON.stringify(e)).join(`
 `) + (events.length > 0 ? `
 ` : "");
-    _internals78.writeFileFsyncedThenRename(tempPath, filePath, validContent + line);
-    const verify = parseEventsFromText(_internals78.readFileSync(filePath, "utf8"));
+    _internals79.writeFileFsyncedThenRename(tempPath, filePath, validContent + line);
+    const verify = parseEventsFromText(_internals79.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}`);
@@ -53231,14 +53300,14 @@ function writeStateProjection(directory, skillSlug, candidateId2, replay) {
     updatedAt: new Date().toISOString()
   };
   const tempPath = `${target}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
-  _internals78.writeFileFsyncedThenRename(tempPath, target, `${JSON.stringify(projection, null, 2)}
+  _internals79.writeFileFsyncedThenRename(tempPath, target, `${JSON.stringify(projection, null, 2)}
 `);
 }
 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)}`;
-  _internals78.writeFileFsyncedThenRename(tempPath, target, content);
+  _internals79.writeFileFsyncedThenRename(tempPath, target, content);
   return target;
 }
 function readArtifact(directory, skillSlug, candidateId2, fileName) {
@@ -53331,16 +53400,16 @@ function currentCandidateState(directory, skillSlug, candidateId2) {
 function writeSkillFileAtomic(targetPath, content) {
   const tempPath = `${targetPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   try {
-    _internals79.writeFileSync(tempPath, content, "utf8");
-    _internals79.renameSync(tempPath, targetPath);
+    _internals80.writeFileSync(tempPath, content, "utf8");
+    _internals80.renameSync(tempPath, targetPath);
   } finally {
     try {
       if (existsSync54(tempPath))
-        _internals79.unlinkSync(tempPath);
+        _internals80.unlinkSync(tempPath);
     } catch {}
   }
 }
-var _internals79 = {
+var _internals80 = {
   writeFileSync: writeFileSync18,
   renameSync: renameSync19,
   unlinkSync: unlinkSync21
@@ -53797,7 +53866,7 @@ function buildGeneratorInputs(args) {
     }
   };
 }
-var _internals80 = {
+var _internals81 = {
   draftDeterministic: defaultDeterministicDraft
 };
 function defaultDeterministicDraft(inputs) {
@@ -53867,7 +53936,7 @@ function countChangedLines(a, b) {
   return changed;
 }
 function draftCandidate(inputs) {
-  const candidate2 = _internals80.draftDeterministic(inputs);
+  const candidate2 = _internals81.draftDeterministic(inputs);
   enforceTrustRegion(candidate2, inputs.budget);
   return candidate2;
 }
@@ -53910,7 +53979,7 @@ import * as path98 from "path";
 // src/hooks/spawn-helper.ts
 import * as child_process8 from "child_process";
 var WIN32_CMD_BINARIES = new Set(["npm", "npx", "pnpm", "yarn"]);
-var _internals81 = {
+var _internals82 = {
   spawn: child_process8.spawn
 };
 function spawnAsync(command, cwd, timeoutMs) {
@@ -53918,7 +53987,7 @@ function spawnAsync(command, cwd, timeoutMs) {
     try {
       const [rawCmd, ...args] = command;
       const cmd = process.platform === "win32" && WIN32_CMD_BINARIES.has(rawCmd) && !rawCmd.includes(".") ? `${rawCmd}.cmd` : rawCmd;
-      const proc = _internals81.spawn(cmd, args, {
+      const proc = _internals82.spawn(cmd, args, {
         cwd,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -53984,7 +54053,7 @@ function spawnAsync(command, cwd, timeoutMs) {
 }
 
 // src/services/skill-optimizer/smoke.ts
-var _internals82 = {
+var _internals83 = {
   validateSkillPath,
   isSymbolicLink: (p) => {
     try {
@@ -54005,7 +54074,7 @@ var _internals82 = {
 async function validateSkillSmoke(input) {
   const notes = [];
   const repoRel = path98.join(".opencode", "skills", "generated", input.skillSlug, "SKILL.md");
-  if (!_internals82.validateSkillPath(repoRel)) {
+  if (!_internals83.validateSkillPath(repoRel)) {
     return {
       ok: false,
       verdict: "VIOLATED",
@@ -54014,16 +54083,16 @@ async function validateSkillSmoke(input) {
   }
   const skillRoot = path98.join(input.directory, ".opencode", "skills", "generated", input.skillSlug);
   if (existsSync55(skillRoot)) {
-    if (_internals82.isSymbolicLink(skillRoot)) {
+    if (_internals83.isSymbolicLink(skillRoot)) {
       return {
         ok: false,
         verdict: "VIOLATED",
         notes: ["skill root is a symlink (reparse denied)"]
       };
     }
-    const realRoot = _internals82.realpath(skillRoot);
-    const realProjectDir = _internals82.realpath(input.directory);
-    if (_internals82.escapedRoot(realProjectDir, realRoot)) {
+    const realRoot = _internals83.realpath(skillRoot);
+    const realProjectDir = _internals83.realpath(input.directory);
+    if (_internals83.escapedRoot(realProjectDir, realRoot)) {
       return {
         ok: false,
         verdict: "VIOLATED",
@@ -54041,7 +54110,7 @@ async function validateSkillSmoke(input) {
       notes: [`frontmatter: ${fmError}`]
     };
   }
-  const rejected = await _internals82.isRejectedSkillContent(input.directory, input.skillSlug, input.candidateContent);
+  const rejected = await _internals83.isRejectedSkillContent(input.directory, input.skillSlug, input.candidateContent);
   if (rejected) {
     return {
       ok: false,
@@ -54051,7 +54120,7 @@ async function validateSkillSmoke(input) {
       ]
     };
   }
-  const evalResult = await _internals82.evaluateSkillChange({
+  const evalResult = await _internals83.evaluateSkillChange({
     directory: input.directory,
     slug: input.skillSlug,
     candidateContent: input.candidateContent,
@@ -54070,7 +54139,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 _internals82.spawnAsync(input.checkCommand, input.directory, input.checkTimeoutMs ?? 60000);
+    const cmdResult = await _internals83.spawnAsync(input.checkCommand, input.directory, input.checkTimeoutMs ?? 60000);
     if (!cmdResult || cmdResult.exitCode !== 0) {
       return {
         ok: false,
@@ -54140,14 +54209,14 @@ async function prepareCandidatePayloads(inputRoot, candidateId2, skillSlug, base
   candidate2.contentHash = await computeCandidateInputContentHash2(inputRoot, candidate2);
   return { baseline, candidate: candidate2 };
 }
-var _internals83 = {
+var _internals84 = {
   tryAcquireLock,
   emitTelemetry: emit,
   evaluateCandidateV1,
   prepareCandidatePayloads
 };
 async function acquireProjectLock(directory) {
-  const result = await _internals83.tryAcquireLock(directory, PROJECT_LOCK_PATH, "skill-opt-controller", "project-run");
+  const result = await _internals84.tryAcquireLock(directory, PROJECT_LOCK_PATH, "skill-opt-controller", "project-run");
   if (!result.acquired)
     return null;
   return async () => {
@@ -54160,7 +54229,7 @@ async function acquireProjectLock(directory) {
 }
 async function acquireSkillLock(directory, skillSlug) {
   const lockPath = path99.join(".swarm", "evolution", "skills", skillSlug, ".skill.lock");
-  const result = await _internals83.tryAcquireLock(directory, lockPath, "skill-opt-controller", `skill-${skillSlug}`);
+  const result = await _internals84.tryAcquireLock(directory, lockPath, "skill-opt-controller", `skill-${skillSlug}`);
   if (!result.acquired)
     return null;
   return async () => {
@@ -54357,13 +54426,13 @@ async function runValidationWithTransientRetry(input, candidateContent, baseline
   while (true) {
     try {
       const evalInputRoot = input.inputRoot ?? input.directory;
-      const { baseline, candidate: candidate2 } = await _internals83.prepareCandidatePayloads(evalInputRoot, candidateId2, input.skillSlug, input.baselineModel, input.candidateModel, baselineContent, candidateContent);
+      const { baseline, candidate: candidate2 } = await _internals84.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-9an52tmz.js");
+      const { createModelEvaluationExecutor: createModelEvaluationExecutor2 } = await import("./runner-w30gazew.js");
       const executor = createModelEvaluationExecutor2(input.dispatcher, input.sessionId);
-      const result = await _internals83.evaluateCandidateV1({
+      const result = await _internals84.evaluateCandidateV1({
         projectRoot: input.directory,
         inputRoot: input.inputRoot ?? input.directory,
         tasks: input.validationTasks,
@@ -54421,7 +54490,7 @@ async function runValidationWithTransientRetry(input, candidateContent, baseline
           deadband: input.config.deadband
         };
       }
-      _internals83.emitTelemetry?.("loop_detected", {
+      _internals84.emitTelemetry?.("loop_detected", {
         skillSlug: input.skillSlug,
         reason: message.slice(0, 160),
         source: "skill-opt-controller"
@@ -55261,19 +55330,8 @@ function getCompactionMetrics(sessionId) {
   return { compactionCount: total, lastSnapshotAt: lastSnapshot };
 }
 
-// src/services/context-budget-service.ts
-init_logger();
-var DEFAULT_CONTEXT_BUDGET_CONFIG = {
-  enabled: true,
-  budgetTokens: 40000,
-  warningPct: 70,
-  criticalPct: 90,
-  warningMode: "once",
-  warningIntervalTurns: 20
-};
-
 // src/services/status-service.ts
-var _internals84 = {
+var _internals85 = {
   loadLeanTurboRunState,
   hasActiveLeanTurbo,
   hasActiveFullAuto,
@@ -55335,6 +55393,7 @@ async function getStatusData(directory, agents, sessionId) {
       isLegacy: false,
       turboMode: hasActiveTurboMode(),
       contextBudgetPct: swarmState.lastBudgetPct > 0 ? swarmState.lastBudgetPct : null,
+      contextBudgetTokens: swarmState.lastBudgetTokens > 0 ? swarmState.lastBudgetTokens : null,
       compactionCount: metrics.compactionCount,
       lastSnapshotAt: metrics.lastSnapshotAt
     };
@@ -55351,6 +55410,7 @@ async function getStatusData(directory, agents, sessionId) {
         isLegacy: true,
         turboMode: hasActiveTurboMode(),
         contextBudgetPct: swarmState.lastBudgetPct > 0 ? swarmState.lastBudgetPct : null,
+        contextBudgetTokens: swarmState.lastBudgetTokens > 0 ? swarmState.lastBudgetTokens : null,
         compactionCount: metrics.compactionCount,
         lastSnapshotAt: metrics.lastSnapshotAt
       };
@@ -55370,6 +55430,7 @@ async function getStatusData(directory, agents, sessionId) {
         isLegacy: true,
         turboMode: hasActiveTurboMode(),
         contextBudgetPct: swarmState.lastBudgetPct > 0 ? swarmState.lastBudgetPct : null,
+        contextBudgetTokens: swarmState.lastBudgetTokens > 0 ? swarmState.lastBudgetTokens : null,
         compactionCount: metrics.compactionCount,
         lastSnapshotAt: metrics.lastSnapshotAt
       };
@@ -55449,11 +55510,11 @@ async function getStatusData(directory, agents, sessionId) {
   } catch {
     status.memoryCohort = { linked: false };
   }
-  status.fullAutoActive = _internals84.hasActiveFullAuto();
+  status.fullAutoActive = _internals85.hasActiveFullAuto();
   if (status.fullAutoActive) {
-    const sid = _internals84.getActiveFullAutoSessionID();
+    const sid = _internals85.getActiveFullAutoSessionID();
     if (sid) {
-      const runState = _internals84.loadFullAutoRunState(directory, sid);
+      const runState = _internals85.loadFullAutoRunState(directory, sid);
       if (runState?.lastEscalation) {
         status.fullAutoEscalation = {
           reason: runState.lastEscalation.reason,
@@ -55487,7 +55548,7 @@ async function getStatusData(directory, agents, sessionId) {
 }
 function enrichWithLeanTurbo(status, directory) {
   const turboMode = hasActiveTurboMode();
-  const leanActive = _internals84.hasActiveLeanTurbo();
+  const leanActive = _internals85.hasActiveLeanTurbo();
   let turboStrategy = "off";
   if (leanActive) {
     turboStrategy = "lean";
@@ -55518,7 +55579,7 @@ function enrichWithLeanTurbo(status, directory) {
     }
   }
   if (leanSessionID) {
-    const runState = _internals84.loadLeanTurboRunState(directory, leanSessionID);
+    const runState = _internals85.loadLeanTurboRunState(directory, leanSessionID);
     if (runState) {
       status.leanTurboPhase = runState.phase;
       status.leanMaxParallelCoders = runState.maxParallelCoders;
@@ -55618,9 +55679,13 @@ function formatStatusMarkdown(status) {
   }
   if (status.contextBudgetPct !== null && status.contextBudgetPct > 0) {
     const pct = status.contextBudgetPct.toFixed(1);
-    const budgetTokens = DEFAULT_CONTEXT_BUDGET_CONFIG.budgetTokens;
-    const est = Math.round(status.contextBudgetPct / 100 * budgetTokens);
-    lines.push("", `**Context**: ${pct}% used (est. ${est.toLocaleString()} / ${budgetTokens.toLocaleString()} tokens)`);
+    const budgetTokens = status.contextBudgetTokens;
+    if (budgetTokens !== undefined && budgetTokens !== null && budgetTokens > 0) {
+      const est = Math.round(status.contextBudgetPct / 100 * budgetTokens);
+      lines.push("", `**Context**: ${pct}% used (est. ${est.toLocaleString()} / ${budgetTokens.toLocaleString()} tokens)`);
+    } else {
+      lines.push("", `**Context**: ${pct}% used`);
+    }
     if (status.compactionCount > 0) {
       lines.push(`**Compaction events**: ${status.compactionCount} triggered`);
     }
@@ -55769,7 +55834,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 _internals85 = {
+var _internals86 = {
   loadPluginConfigWithMeta
 };
 async function handleTurboCommand(directory, args, sessionID) {
@@ -55829,7 +55894,7 @@ async function handleTurboCommand(directory, args, sessionID) {
   if (arg0 === "on") {
     let strategy = "standard";
     try {
-      const { config } = _internals85.loadPluginConfigWithMeta(directory);
+      const { config } = _internals86.loadPluginConfigWithMeta(directory);
       if (config.turbo?.strategy === "lean") {
         strategy = "lean";
       }
@@ -55926,7 +55991,7 @@ function enableLeanTurbo(session, directory, sessionID) {
   let maxParallelCoders = 4;
   let conflictPolicy = "serialize";
   try {
-    const { config } = _internals85.loadPluginConfigWithMeta(directory);
+    const { config } = _internals86.loadPluginConfigWithMeta(directory);
     const leanConfig = config.turbo?.lean;
     if (leanConfig) {
       maxParallelCoders = leanConfig.max_parallel_coders ?? 4;
@@ -56189,7 +56254,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-y46anh5e.js");
+    const { buildHelpText } = await import("./index-xka8s8jw.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -56198,7 +56263,7 @@ async function handleHelpCommand(ctx) {
     return _internals14.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals14.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-y46anh5e.js");
+  const { buildHelpText: fullHelp } = await import("./index-xka8s8jw.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -56375,7 +56440,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-rqpmzxyy.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-vb9k9zwm.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -56385,7 +56450,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-rqpmzxyy.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-vb9k9zwm.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -56395,7 +56460,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-vd4a0ng5.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-0djnvfas.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -57865,10 +57930,11 @@ For every applicable directive in the block:
 - Cite \`KNOWLEDGE_APPLIED: <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.
 - 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/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.
+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.
 
 ## SKILL IMPROVER (low-frequency, expensive-model adviser)
 
@@ -59418,7 +59484,7 @@ WRONG: "I'll use the Task tool to call another agent to review this code"
 RIGHT: "I'll read the changed files and review them myself"
 
 ## KNOWLEDGE RECEIPTS
-If you call \`knowledge_recall\` or receive a knowledge directive block with a trace_id, file exactly one \`knowledge_receipt\` before final output: mark each relevant entry as applied, ignored, or contradicted with evidence, or set \`no_relevant_knowledge:true\`. The receipt records audit events; it does not replace any required \`KNOWLEDGE_APPLIED\`, \`KNOWLEDGE_IGNORED\`, or \`KNOWLEDGE_VIOLATED\` directive-compliance line.
+If you call \`knowledge_recall\` or receive a knowledge directive block with a trace_id, file exactly one \`knowledge_receipt\` before final output: mark each relevant entry as applied, ignored, or contradicted with evidence, or set \`no_relevant_knowledge:true\`. The receipt records audit events; it does not replace any required \`KNOWLEDGE_APPLIED\`, \`KNOWLEDGE_IGNORED\`, \`KNOWLEDGE_CONTRADICTED\`, or \`KNOWLEDGE_VIOLATED\` directive-compliance line.
 
 ${READ_ONLY_LANE_GUIDANCE}
 
@@ -59905,11 +59971,11 @@ function createCuratorLLMDelegate(directory, mode = "init", sessionId) {
     return;
   return async (_systemPrompt, userInput, signal) => {
     let ephemeralSessionId;
-    const cleanup = () => {
+    const cleanup = async () => {
       if (ephemeralSessionId) {
         const id = ephemeralSessionId;
         ephemeralSessionId = undefined;
-        client.session.delete({ path: { id } }).catch(() => {});
+        await teardownEphemeralSession(client.session, id);
       }
     };
     if (signal?.aborted) {
@@ -59979,7 +60045,7 @@ function createCuratorLLMDelegate(directory, mode = "init", sessionId) {
       }
       throw err;
     } finally {
-      cleanup();
+      await cleanup();
     }
   };
 }