opencode-swarm 7.113.3 → 7.113.4

package/dist/cli/{index-dh87tpc5.js → index-ct9e0y0q.js}

@@ -8235,6 +8235,11 @@ var _internals11 = {
   parseKnowledgeRecommendationsWithDiagnostics,
   readCuratorSummary,
   writeCuratorSummary,
+  appendCuratorRecommendation,
+  mergeCuratorPhaseSummary,
+  readCuratorSummaryState,
+  writeCuratorSummaryState,
+  transactFile,
   filterPhaseEvents,
   checkPhaseCompliance,
   normalizeAgentName,
@@ -8288,8 +8293,39 @@ function capPhaseDigests(digests) {
 function capComplianceObservations(observations) {
   return observations.slice(-MAX_CURATOR_COMPLIANCE_OBSERVATIONS);
 }
-function capKnowledgeRecommendations(recommendations) {
-  return recommendations.slice(-MAX_CURATOR_RECOMMENDATIONS);
+function canonicalizeJson(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalizeJson);
+  if (value === null || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, nested]) => [key, canonicalizeJson(nested)]));
+}
+function recommendationIdentity(recommendation) {
+  const stable = { ...recommendation };
+  if (recommendation.action === "promote" && recommendation.lesson.startsWith("Hive promotion:")) {
+    try {
+      const parsedReason = JSON.parse(recommendation.reason);
+      if (parsedReason !== null && typeof parsedReason === "object" && !Array.isArray(parsedReason)) {
+        const { timestamp: _volatileTimestamp, ...stableReason } = parsedReason;
+        stable.reason = stableReason;
+      }
+    } catch {}
+  }
+  return JSON.stringify(canonicalizeJson(stable));
+}
+function normalizeKnowledgeRecommendations(recommendations) {
+  const input = Array.isArray(recommendations) ? recommendations.filter((entry) => entry !== null && typeof entry === "object" && typeof entry.action === "string" && typeof entry.lesson === "string" && typeof entry.reason === "string") : [];
+  const seen = new Set;
+  const newestUnique = [];
+  for (let index = input.length - 1;index >= 0; index--) {
+    const recommendation = input[index];
+    const identity = recommendationIdentity(recommendation);
+    if (seen.has(identity))
+      continue;
+    seen.add(identity);
+    newestUnique.push(recommendation);
+  }
+  return newestUnique.reverse().slice(-MAX_CURATOR_RECOMMENDATIONS);
 }
 function buildDigestFromPhaseDigests(digests) {
   return digests.map((digest) => `### Phase ${digest.phase}
@@ -8564,27 +8600,166 @@ function clampConf(v) {
     return 1;
   return v;
 }
-async function readCuratorSummary(directory) {
-  const content = await readSwarmFileAsync(directory, "curator-summary.json");
-  if (content === null) {
-    return null;
+function normalizeCuratorSummary(summary) {
+  const recommendations = normalizeKnowledgeRecommendations(summary.knowledge_recommendations);
+  const original = Array.isArray(summary.knowledge_recommendations) ? summary.knowledge_recommendations : [];
+  const changed = !Array.isArray(summary.knowledge_recommendations) || original.length !== recommendations.length || original.some((entry, index) => entry !== recommendations[index]);
+  return {
+    summary: changed ? { ...summary, knowledge_recommendations: recommendations } : summary,
+    changed
+  };
+}
+async function readCuratorSummaryState(filePath) {
+  let content;
+  try {
+    content = await fs6.promises.readFile(filePath, "utf-8");
+  } catch (error2) {
+    if (error2.code === "ENOENT") {
+      return { summary: null, dirty: false };
+    }
+    throw error2;
   }
+  return parseCuratorSummaryContent(content);
+}
+function parseCuratorSummaryContent(content) {
   try {
     const parsed = JSON.parse(content);
     if (parsed.schema_version !== 1) {
       warn(`Curator summary has unsupported schema version: ${parsed.schema_version}. Expected 1.`);
-      return null;
+      return { summary: null, dirty: false };
     }
-    return parsed;
+    const normalized = normalizeCuratorSummary(parsed);
+    return { summary: normalized.summary, dirty: normalized.changed };
   } catch {
     warn("Failed to parse curator-summary.json: invalid JSON");
+    return { summary: null, dirty: false };
+  }
+}
+async function writeCuratorSummaryState(filePath, state) {
+  if (!state.summary)
+    return;
+  await bunWrite(filePath, JSON.stringify(state.summary, null, 2));
+}
+async function transactCuratorSummary(directory, mutate) {
+  const resolvedPath = validateSwarmPath(directory, "curator-summary.json");
+  let invoked = false;
+  let mutationResult;
+  await _internals11.transactFile(resolvedPath, _internals11.readCuratorSummaryState, _internals11.writeCuratorSummaryState, (state) => {
+    invoked = true;
+    const mutation = mutate(state.summary);
+    mutationResult = mutation.result;
+    if (mutation.next === null)
+      return null;
+    const candidate = mutation.next ?? state.summary;
+    if (!candidate)
+      return null;
+    const normalized = normalizeCuratorSummary(candidate).summary;
+    const explicitlyChanged = mutation.next !== undefined && JSON.stringify(normalized) !== JSON.stringify(state.summary);
+    if (!state.dirty && !explicitlyChanged)
+      return null;
+    return { summary: normalized, dirty: false };
+  });
+  return { invoked, result: mutationResult };
+}
+async function readCuratorSummary(directory) {
+  const content = await readSwarmFileAsync(directory, "curator-summary.json");
+  if (content === null)
     return null;
+  const initial = parseCuratorSummaryContent(content);
+  if (!initial.summary || !initial.dirty)
+    return initial.summary;
+  let normalized = initial.summary;
+  try {
+    await transactCuratorSummary(directory, (summary) => {
+      if (summary)
+        normalized = summary;
+      return { result: normalized };
+    });
+  } catch (error2) {
+    warn(`Failed to persist curator-summary cleanup: ${error2 instanceof Error ? error2.message : String(error2)}`);
   }
+  return normalized;
 }
 async function writeCuratorSummary(directory, summary) {
-  const resolvedPath = validateSwarmPath(directory, "curator-summary.json");
-  fs6.mkdirSync(path16.dirname(resolvedPath), { recursive: true });
-  await bunWrite(resolvedPath, JSON.stringify(summary, null, 2));
+  const transaction = await transactCuratorSummary(directory, () => ({
+    next: summary,
+    result: undefined
+  }));
+  if (!transaction.invoked) {
+    throw new Error("Failed to persist curator summary");
+  }
+}
+async function appendCuratorRecommendation(directory, recommendation) {
+  const transaction = await transactCuratorSummary(directory, (summary) => {
+    if (!summary)
+      return { next: null, result: false };
+    const recommendations = normalizeKnowledgeRecommendations([
+      ...normalizeKnowledgeRecommendations(summary.knowledge_recommendations),
+      recommendation
+    ]);
+    const current = normalizeKnowledgeRecommendations(summary.knowledge_recommendations);
+    const changed = current.length !== recommendations.length || current.some((entry, index) => entry !== recommendations[index]);
+    if (!changed)
+      return { result: false };
+    return {
+      next: {
+        ...summary,
+        last_updated: new Date().toISOString(),
+        knowledge_recommendations: recommendations
+      },
+      result: true
+    };
+  });
+  return transaction.invoked ? transaction.result ?? false : false;
+}
+async function mergeCuratorPhaseSummary(directory, merge) {
+  const transaction = await transactCuratorSummary(directory, (current) => {
+    if (current?.phase_digests?.some((digest) => digest.phase === merge.phase)) {
+      return { result: false };
+    }
+    if (current) {
+      const phaseDigests2 = capPhaseDigests([
+        ...Array.isArray(current.phase_digests) ? current.phase_digests : [],
+        merge.phaseDigest
+      ]);
+      return {
+        next: {
+          ...current,
+          last_updated: merge.timestamp,
+          last_phase_covered: Math.max(typeof current.last_phase_covered === "number" ? current.last_phase_covered : 0, merge.phase),
+          digest: buildDigestFromPhaseDigests(phaseDigests2),
+          phase_digests: phaseDigests2,
+          compliance_observations: capComplianceObservations([
+            ...Array.isArray(current.compliance_observations) ? current.compliance_observations : [],
+            ...merge.complianceObservations
+          ]),
+          knowledge_recommendations: normalizeKnowledgeRecommendations([
+            ...normalizeKnowledgeRecommendations(current.knowledge_recommendations),
+            ...merge.knowledgeRecommendations
+          ])
+        },
+        result: true
+      };
+    }
+    const phaseDigests = capPhaseDigests([merge.phaseDigest]);
+    return {
+      next: {
+        schema_version: 1,
+        session_id: merge.sessionId,
+        last_updated: merge.timestamp,
+        last_phase_covered: merge.phase,
+        digest: buildDigestFromPhaseDigests(phaseDigests),
+        phase_digests: phaseDigests,
+        compliance_observations: capComplianceObservations(merge.complianceObservations),
+        knowledge_recommendations: normalizeKnowledgeRecommendations(merge.knowledgeRecommendations)
+      },
+      result: true
+    };
+  });
+  if (!transaction.invoked) {
+    throw new Error("Failed to persist curator phase summary");
+  }
+  return transaction.result ?? false;
 }
 function normalizeAgentName(name) {
   const registry = swarmState.generatedAgentNames.length > 0 ? swarmState.generatedAgentNames : undefined;
@@ -8984,41 +9159,14 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     }
     const sessionId = `session-${Date.now()}`;
     const now = new Date().toISOString();
-    let updatedSummary;
-    if (priorSummary) {
-      const phaseDigests = capPhaseDigests([
-        ...priorSummary.phase_digests,
-        phaseDigest
-      ]);
-      updatedSummary = {
-        ...priorSummary,
-        last_updated: now,
-        last_phase_covered: Math.max(priorSummary.last_phase_covered, phase),
-        digest: buildDigestFromPhaseDigests(phaseDigests),
-        phase_digests: phaseDigests,
-        compliance_observations: capComplianceObservations([
-          ...priorSummary.compliance_observations,
-          ...complianceObservations
-        ]),
-        knowledge_recommendations: capKnowledgeRecommendations([
-          ...priorSummary.knowledge_recommendations,
-          ...knowledgeRecommendations
-        ])
-      };
-    } else {
-      const phaseDigests = capPhaseDigests([phaseDigest]);
-      updatedSummary = {
-        schema_version: 1,
-        session_id: sessionId,
-        last_updated: now,
-        last_phase_covered: phase,
-        digest: buildDigestFromPhaseDigests(phaseDigests),
-        phase_digests: phaseDigests,
-        compliance_observations: capComplianceObservations(complianceObservations),
-        knowledge_recommendations: capKnowledgeRecommendations(knowledgeRecommendations)
-      };
-    }
-    await _internals11.writeCuratorSummary(directory, updatedSummary);
+    const summaryUpdated = await _internals11.mergeCuratorPhaseSummary(directory, {
+      phase,
+      phaseDigest,
+      complianceObservations,
+      knowledgeRecommendations,
+      sessionId,
+      timestamp: now
+    });
     if (knowledgeApplicationFindings.length > 0) {
       try {
         const evidenceDir = path16.join(directory, ".swarm", "evidence", String(phase));
@@ -9163,14 +9311,14 @@ ${summary}`;
       digest: phaseDigest,
       compliance: complianceObservations,
       knowledge_recommendations: knowledgeRecommendations,
-      summary_updated: true,
+      summary_updated: summaryUpdated,
       knowledge_application_findings: knowledgeApplicationFindings,
       skill_candidates: skillCandidates
     };
     getGlobalEventBus().publish("curator.phase.completed", {
       phase,
       compliance_count: complianceObservations.length,
-      summary_updated: true
+      summary_updated: summaryUpdated
     });
     return result;
   } catch (err) {
@@ -10284,11 +10432,11 @@ var _internals12 = {
     return KnowledgeConfigSchema2.parse({});
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-ckzb8ww4.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-nh9raf1a.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig);
   },
   checkHivePromotions: async (entries, knowledgeConfig) => {
-    const { checkHivePromotions } = await import("./hive-promoter-h21wzpsr.js");
+    const { checkHivePromotions } = await import("./hive-promoter-c0fd3j02.js");
     return checkHivePromotions(entries, knowledgeConfig);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -10516,31 +10664,33 @@ async function checkHivePromotions(swarmEntries, config) {
     total_hive_entries: hiveEntries.length
   };
 }
+var _internals13 = {
+  readSwarmEntries: (directory) => readKnowledge(resolveSwarmKnowledgePath(directory)),
+  checkHivePromotions,
+  readCuratorSummary,
+  appendCuratorRecommendation
+};
 function createHivePromoterHook(directory, config) {
   const hook = async (_input, _output) => {
-    const swarmEntries = await readKnowledge(resolveSwarmKnowledgePath(directory));
-    const promotionSummary = await checkHivePromotions(swarmEntries, config);
-    const curatorSummary = await readCuratorSummary(directory);
-    if (curatorSummary) {
-      const existingRecommendations = Array.isArray(curatorSummary.knowledge_recommendations) ? curatorSummary.knowledge_recommendations : [];
-      const recommendation = {
-        action: "promote",
-        lesson: `Hive promotion: ${promotionSummary.new_promotions} new, ${promotionSummary.encounters_incremented} encounters, ${promotionSummary.advancements} advancements, ${promotionSummary.total_hive_entries} total entries`,
-        reason: JSON.stringify({
-          timestamp: promotionSummary.timestamp,
-          new_promotions: promotionSummary.new_promotions,
-          encounters_incremented: promotionSummary.encounters_incremented,
-          advancements: promotionSummary.advancements,
-          total_hive_entries: promotionSummary.total_hive_entries
-        })
-      };
-      const updatedSummary = {
-        ...curatorSummary,
-        knowledge_recommendations: [...existingRecommendations, recommendation],
-        last_updated: new Date().toISOString()
-      };
-      await writeCuratorSummary(directory, updatedSummary);
-    }
+    const swarmEntries = await _internals13.readSwarmEntries(directory);
+    const promotionSummary = await _internals13.checkHivePromotions(swarmEntries, config);
+    const curatorSummary = await _internals13.readCuratorSummary(directory);
+    if (!curatorSummary)
+      return;
+    const hasActivity = promotionSummary.new_promotions > 0 || promotionSummary.encounters_incremented > 0 || promotionSummary.advancements > 0;
+    if (!hasActivity)
+      return;
+    await _internals13.appendCuratorRecommendation(directory, {
+      action: "promote",
+      lesson: `Hive promotion: ${promotionSummary.new_promotions} new, ${promotionSummary.encounters_incremented} encounters, ${promotionSummary.advancements} advancements, ${promotionSummary.total_hive_entries} total entries`,
+      reason: JSON.stringify({
+        timestamp: promotionSummary.timestamp,
+        new_promotions: promotionSummary.new_promotions,
+        encounters_incremented: promotionSummary.encounters_incremented,
+        advancements: promotionSummary.advancements,
+        total_hive_entries: promotionSummary.total_hive_entries
+      })
+    });
   };
   return safeHook(hook);
 }
@@ -10629,7 +10779,13 @@ async function promoteFromSwarm(directory, lessonId) {
 // src/hooks/knowledge-curator.ts
 import { createHash as createHash4 } from "crypto";
 import { existsSync as existsSync14 } from "fs";
-import { appendFile as appendFile2, mkdir as mkdir6, readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
+import {
+  appendFile as appendFile2,
+  mkdir as mkdir6,
+  readFile as readFile7,
+  realpath,
+  writeFile as writeFile7
+} from "fs/promises";
 import * as path23 from "path";
 
 // src/services/synonym-map.ts
@@ -10865,7 +11021,7 @@ var SKILL_AUDIENCE_RUNNER_PATTERN = /^runner:(opencode|claude|codex)$/;
 var WORKFLOW_BOOST_MIN_CONTEXT = 0.05;
 var RECENCY_DECAY_MS = 30 * 24 * 60 * 60 * 1000;
 var SKILL_FRONTMATTER_READ_BYTES = 16 * 1024;
-var _internals13 = {
+var _internals14 = {
   computeSkillRelevanceScore: null,
   rankSkillsForContext: null,
   getSkillStats: null,
@@ -11232,7 +11388,7 @@ function rankSkillsForContext(skills, taskContext, directory) {
   const results = [];
   for (const skillPath of skills) {
     const skillEntries = allEntries.filter((e) => e.skillPath === skillPath);
-    const metadata = _internals13.readSkillMetadata(skillPath, directory);
+    const metadata = _internals14.readSkillMetadata(skillPath, directory);
     const score = computeSkillRelevanceScore(skillPath, taskContext, skillEntries, metadata);
     const entriesWithVerdict = skillEntries.filter((e) => e.complianceVerdict !== undefined && e.complianceVerdict !== "not_checked");
     const compliantCount = entriesWithVerdict.filter((e) => e.complianceVerdict === "compliant").length;
@@ -11291,7 +11447,7 @@ function formatSkillIndexWithContext(skills, directory, metadataBySkillPath) {
   } catch {}
   if (!hasHistory) {
     return skills.map((sp) => {
-      const meta = metadataBySkillPath?.get(sp) ?? _internals13.readSkillMetadata(sp, directory);
+      const meta = metadataBySkillPath?.get(sp) ?? _internals14.readSkillMetadata(sp, directory);
       return `  - file:${meta.path} - ${meta.name}: ${meta.description}`;
     }).join(`
 `);
@@ -11299,7 +11455,7 @@ function formatSkillIndexWithContext(skills, directory, metadataBySkillPath) {
   const lines = [];
   for (const skillPath of skills) {
     const stats = getSkillStats(skillPath, directory);
-    const meta = metadataBySkillPath?.get(skillPath) ?? _internals13.readSkillMetadata(skillPath, directory);
+    const meta = metadataBySkillPath?.get(skillPath) ?? _internals14.readSkillMetadata(skillPath, directory);
     const compliancePct = Math.round(stats.complianceRate * 100);
     const topAgentNames = stats.topAgents.slice(0, 3).map((a) => a.agent).join(", ");
     lines.push(`  - file:${meta.path} - ${meta.name}: ${meta.description} (used: ${stats.totalUsage}, compliance: ${compliancePct}%)` + (stats.topAgents.length > 0 ? ` \u2192 ${topAgentNames}` : ""));
@@ -11307,16 +11463,16 @@ function formatSkillIndexWithContext(skills, directory, metadataBySkillPath) {
   return lines.join(`
 `);
 }
-_internals13.computeSkillRelevanceScore = computeSkillRelevanceScore;
-_internals13.rankSkillsForContext = rankSkillsForContext;
-_internals13.getSkillStats = getSkillStats;
-_internals13.formatSkillIndexWithContext = formatSkillIndexWithContext;
-_internals13.parseSkillFrontmatter = parseSkillFrontmatter;
-_internals13.readSkillMetadata = readSkillMetadata;
-_internals13.extractSkillName = extractSkillName;
-_internals13.computeRecencyScore = computeRecencyScore;
-_internals13.computeContextMatchScore = computeContextMatchScore;
-_internals13.computeTriggerMatchBoost = computeTriggerMatchBoost;
+_internals14.computeSkillRelevanceScore = computeSkillRelevanceScore;
+_internals14.rankSkillsForContext = rankSkillsForContext;
+_internals14.getSkillStats = getSkillStats;
+_internals14.formatSkillIndexWithContext = formatSkillIndexWithContext;
+_internals14.parseSkillFrontmatter = parseSkillFrontmatter;
+_internals14.readSkillMetadata = readSkillMetadata;
+_internals14.extractSkillName = extractSkillName;
+_internals14.computeRecencyScore = computeRecencyScore;
+_internals14.computeContextMatchScore = computeContextMatchScore;
+_internals14.computeTriggerMatchBoost = computeTriggerMatchBoost;
 
 // src/hooks/skill-propagation-gate.ts
 function parseSimpleYaml(content) {
@@ -11418,10 +11574,10 @@ function parseYamlValue(value) {
 }
 function loadRoutingSkills(directory, targetAgent) {
   const routingPath = path21.join(directory, ".opencode", "skill-routing.yaml");
-  if (!_internals14.existsSync(routingPath))
+  if (!_internals15.existsSync(routingPath))
     return [];
   try {
-    const content = _internals14.readFileSync(routingPath, "utf-8");
+    const content = _internals15.readFileSync(routingPath, "utf-8");
     const config = parseSimpleYaml(content);
     if (!config?.routing)
       return [];
@@ -11448,7 +11604,7 @@ var SKILL_SEARCH_ROOTS = [
   ".claude/skills"
 ];
 var MAX_SCORING_SESSION_ENTRIES = 500;
-var _internals14 = {
+var _internals15 = {
   readdirSync: fs8.readdirSync.bind(fs8),
   existsSync: fs8.existsSync.bind(fs8),
   statSync: fs8.statSync.bind(fs8),
@@ -11481,11 +11637,11 @@ function discoverAvailableSkills(directory) {
   const results = [];
   for (const root of SKILL_SEARCH_ROOTS) {
     const rootPath = path21.join(directory, root);
-    if (!_internals14.existsSync(rootPath))
+    if (!_internals15.existsSync(rootPath))
       continue;
     let entries;
     try {
-      entries = _internals14.readdirSync(rootPath);
+      entries = _internals15.readdirSync(rootPath);
     } catch {
       continue;
     }
@@ -11493,11 +11649,11 @@ function discoverAvailableSkills(directory) {
       if (entry.startsWith("."))
         continue;
       const skillDir = path21.join(rootPath, entry);
-      if (_internals14.existsSync(path21.join(skillDir, "retired.marker")) || _internals14.existsSync(path21.join(skillDir, "stale.marker")))
+      if (_internals15.existsSync(path21.join(skillDir, "retired.marker")) || _internals15.existsSync(path21.join(skillDir, "stale.marker")))
         continue;
       const skillFile = path21.join(skillDir, "SKILL.md");
       try {
-        if (_internals14.statSync(skillDir).isDirectory() && _internals14.existsSync(skillFile)) {
+        if (_internals15.statSync(skillDir).isDirectory() && _internals15.existsSync(skillFile)) {
           results.push(path21.join(root, entry, "SKILL.md").replace(/\\/g, "/"));
         }
       } catch (err) {
@@ -11529,7 +11685,7 @@ function parseDelegationArgs(args) {
   }
   if (!targetAgent)
     return null;
-  const skillsField = prompt ? _internals14.extractSkillsFieldFromPrompt(prompt) : "";
+  const skillsField = prompt ? _internals15.extractSkillsFieldFromPrompt(prompt) : "";
   return { targetAgent, skillsField };
 }
 function extractSkillsFieldFromPrompt(prompt) {
@@ -11570,10 +11726,10 @@ function writeWarnEvent(directory, record) {
   const filePath = path21.join(directory, ".swarm", "events.jsonl");
   try {
     const dir = path21.dirname(filePath);
-    if (!_internals14.existsSync(dir)) {
-      _internals14.mkdirSync(dir, { recursive: true });
+    if (!_internals15.existsSync(dir)) {
+      _internals15.mkdirSync(dir, { recursive: true });
     }
-    _internals14.appendFileSync(filePath, `${JSON.stringify(record)}
+    _internals15.appendFileSync(filePath, `${JSON.stringify(record)}
 `, "utf-8");
   } catch (err) {
     warn(`[skill-propagation-gate] failed to write warning event: ${err instanceof Error ? err.message : String(err)}`);
@@ -11628,7 +11784,7 @@ function validateSkillReference(directory, reference, context, options) {
     };
   }
   try {
-    const root = _internals14.realpathSync(directory);
+    const root = _internals15.realpathSync(directory);
     const lexicalPath = path21.resolve(root, withoutPrefix);
     if (!isWithinRoot(root, lexicalPath)) {
       return {
@@ -11636,10 +11792,10 @@ function validateSkillReference(directory, reference, context, options) {
         reason: "skill path resolves outside the project"
       };
     }
-    if (!_internals14.existsSync(lexicalPath) || !_internals14.statSync(lexicalPath).isFile()) {
+    if (!_internals15.existsSync(lexicalPath) || !_internals15.statSync(lexicalPath).isFile()) {
       return { valid: false, reason: "skill file does not exist" };
     }
-    const realPath = _internals14.realpathSync(lexicalPath);
+    const realPath = _internals15.realpathSync(lexicalPath);
     if (!isWithinRoot(root, realPath)) {
       return {
         valid: false,
@@ -11648,7 +11804,7 @@ function validateSkillReference(directory, reference, context, options) {
     }
     const normalizedPath = withoutPrefix.replace(/^\.\//, "");
     const validatedMetadataPath = path21.relative(root, realPath).replace(/\\/g, "/");
-    const metadata = _internals14.readSkillMetadata(validatedMetadataPath, root);
+    const metadata = _internals15.readSkillMetadata(validatedMetadataPath, root);
     if (metadata.frontmatterStatus !== "valid" && metadata.frontmatterStatus !== "absent") {
       return {
         valid: false,
@@ -11680,18 +11836,18 @@ async function validateExplicitSkillReferencesBefore(directory, input, config) {
   if (!agentRaw || stripKnownSwarmPrefix(agentRaw) !== "architect") {
     return { blocked: false, reason: null };
   }
-  const parsed = _internals14.parseDelegationArgs(input.args);
+  const parsed = _internals15.parseDelegationArgs(input.args);
   if (!parsed)
     return { blocked: false, reason: null };
   const targetBase = stripKnownSwarmPrefix(parsed.targetAgent);
-  if (!_internals14.SKILL_CAPABLE_AGENTS.has(targetBase)) {
+  if (!_internals15.SKILL_CAPABLE_AGENTS.has(targetBase)) {
     return { blocked: false, reason: null };
   }
   const skillsValue = parsed.skillsField.trim();
   if (!skillsValue || skillsValue.toLowerCase() === "none") {
     return { blocked: false, reason: null };
   }
-  const fileReferences = _internals14.extractFileSkillReferences(skillsValue);
+  const fileReferences = _internals15.extractFileSkillReferences(skillsValue);
   if (fileReferences.length === 0) {
     return { blocked: false, reason: null, validatedSkillPaths: [] };
   }
@@ -11704,7 +11860,7 @@ async function validateExplicitSkillReferencesBefore(directory, input, config) {
   const context = resolveSkillAudienceContext(config);
   const validatedSkillPaths = [];
   for (const reference of fileReferences) {
-    const result = _internals14.validateSkillReference(directory, reference, context, {
+    const result = _internals15.validateSkillReference(directory, reference, context, {
       enforceAudience: true
     });
     if (!result.valid) {
@@ -11749,18 +11905,18 @@ async function skillPropagationGateBefore(directory, input, config) {
   const baseAgent = stripKnownSwarmPrefix(agentRaw);
   if (baseAgent !== "architect")
     return { blocked: false, reason: null, recommendedSkills: undefined };
-  const parsed = _internals14.parseDelegationArgs(input.args);
+  const parsed = _internals15.parseDelegationArgs(input.args);
   if (!parsed)
     return { blocked: false, reason: null, recommendedSkills: undefined };
   const targetBase = stripKnownSwarmPrefix(parsed.targetAgent);
-  if (!_internals14.SKILL_CAPABLE_AGENTS.has(targetBase))
+  if (!_internals15.SKILL_CAPABLE_AGENTS.has(targetBase))
     return { blocked: false, reason: null, recommendedSkills: undefined };
   const sessionID = typeof input.sessionID === "string" ? input.sessionID : "unknown";
   const audienceContext = resolveSkillAudienceContext(config);
   const availableSkills = [];
   const metadataBySkillPath = new Map;
-  for (const skillPath of _internals14.discoverAvailableSkills(directory)) {
-    const validation = _internals14.validateSkillReference(directory, skillPath, audienceContext, { enforceAudience: true, requireFilePrefix: false });
+  for (const skillPath of _internals15.discoverAvailableSkills(directory)) {
+    const validation = _internals15.validateSkillReference(directory, skillPath, audienceContext, { enforceAudience: true, requireFilePrefix: false });
     if (!validation.valid || !validation.skillPath)
       continue;
     availableSkills.push(validation.skillPath);
@@ -11771,7 +11927,7 @@ async function skillPropagationGateBefore(directory, input, config) {
   const skillsValue = parsed.skillsField.trim();
   if (skillsValue && skillsValue.toLowerCase() !== "none") {
     const prompt = typeof input.args?.prompt === "string" ? String(input.args.prompt) : "";
-    const taskId = _internals14.extractTaskIdFromPrompt(prompt);
+    const taskId = _internals15.extractTaskIdFromPrompt(prompt);
     const skillPaths = explicitIntegrity.validatedSkillPaths ?? [];
     let coderSkillPaths = [];
     if (prompt) {
@@ -11780,19 +11936,19 @@ async function skillPropagationGateBefore(directory, input, config) {
         const trimmed = line.trim();
         if (trimmed.startsWith("SKILLS_USED_BY_CODER:")) {
           const fieldVal = trimmed.slice("SKILLS_USED_BY_CODER:".length).trim();
-          coderSkillPaths = _internals14.parseSkillPaths(fieldVal);
+          coderSkillPaths = _internals15.parseSkillPaths(fieldVal);
           break;
         }
       }
     }
     const safeCoderSkillPaths = coderSkillPaths.flatMap((skillPath) => {
-      const validation = _internals14.validateSkillReference(directory, skillPath, audienceContext, { enforceAudience: false });
+      const validation = _internals15.validateSkillReference(directory, skillPath, audienceContext, { enforceAudience: false });
       return validation.valid && validation.skillPath ? [validation.skillPath] : [];
     });
     const allPaths = [...new Set([...skillPaths, ...safeCoderSkillPaths])];
     for (const skillPath of allPaths) {
       try {
-        _internals14.appendSkillUsageEntry(directory, {
+        _internals15.appendSkillUsageEntry(directory, {
           skillPath,
           agentName: targetBase,
           taskID: taskId,
@@ -11809,18 +11965,18 @@ async function skillPropagationGateBefore(directory, input, config) {
   let scored = [];
   if (skillsValue.toLowerCase() !== "none" && availableSkills.length > 0) {
     try {
-      const sessionEntries = _internals14.readSkillUsageEntriesTail(directory, {
+      const sessionEntries = _internals15.readSkillUsageEntriesTail(directory, {
         sessionID
       });
-      if (sessionEntries.length > _internals14.MAX_SCORING_SESSION_ENTRIES) {
+      if (sessionEntries.length > _internals15.MAX_SCORING_SESSION_ENTRIES) {
         scoringSkipped = true;
-        warn(`[skill-propagation-gate] skipping scoring \u2014 tail window has ${sessionEntries.length} session entries (limit: ${_internals14.MAX_SCORING_SESSION_ENTRIES})`);
+        warn(`[skill-propagation-gate] skipping scoring \u2014 tail window has ${sessionEntries.length} session entries (limit: ${_internals15.MAX_SCORING_SESSION_ENTRIES})`);
       } else {
         const prompt = typeof input.args?.prompt === "string" ? String(input.args.prompt) : "";
         scored = availableSkills.map((skillPath) => {
           const skillEntries = sessionEntries.filter((e) => e.skillPath === skillPath);
-          const metadata = metadataBySkillPath.get(skillPath) ?? _internals14.readSkillMetadata(skillPath, directory);
-          const score = _internals14.computeSkillRelevanceScore(skillPath, prompt, skillEntries, metadata);
+          const metadata = metadataBySkillPath.get(skillPath) ?? _internals15.readSkillMetadata(skillPath, directory);
+          const score = _internals15.computeSkillRelevanceScore(skillPath, prompt, skillEntries, metadata);
           return { skillPath, score, usageCount: skillEntries.length };
         }).sort((a, b) => b.score - a.score || b.usageCount - a.usageCount);
         if (scored.length > 0) {
@@ -11834,11 +11990,11 @@ async function skillPropagationGateBefore(directory, input, config) {
     }
   }
   try {
-    const routingPaths = _internals14.loadRoutingSkills(directory, targetBase);
+    const routingPaths = _internals15.loadRoutingSkills(directory, targetBase);
     if (routingPaths.length > 0) {
       const existingPaths = new Set(scored.map((s) => s.skillPath));
       for (const routingPath of routingPaths) {
-        const validation = _internals14.validateSkillReference(directory, routingPath, audienceContext, { enforceAudience: true, requireFilePrefix: false });
+        const validation = _internals15.validateSkillReference(directory, routingPath, audienceContext, { enforceAudience: true, requireFilePrefix: false });
         if (!validation.valid || !validation.skillPath)
           continue;
         const eligibleRoutingPath = validation.skillPath;
@@ -11846,7 +12002,7 @@ async function skillPropagationGateBefore(directory, input, config) {
           metadataBySkillPath.set(eligibleRoutingPath, validation.metadata);
         }
         const routedSkillDir = path21.dirname(path21.join(directory, eligibleRoutingPath));
-        if (_internals14.existsSync(path21.join(routedSkillDir, "retired.marker")) || _internals14.existsSync(path21.join(routedSkillDir, "stale.marker")))
+        if (_internals15.existsSync(path21.join(routedSkillDir, "retired.marker")) || _internals15.existsSync(path21.join(routedSkillDir, "stale.marker")))
           continue;
         if (!existingPaths.has(eligibleRoutingPath)) {
           scored.push({
@@ -11872,12 +12028,12 @@ async function skillPropagationGateBefore(directory, input, config) {
       } else if (typeof scored !== "undefined" && scored.length > 0) {
         skillsForIndex = scored.map((r) => r.skillPath);
       }
-      const formattedIndex = _internals14.formatSkillIndexWithContext(skillsForIndex, directory, metadataBySkillPath);
+      const formattedIndex = _internals15.formatSkillIndexWithContext(skillsForIndex, directory, metadataBySkillPath);
       if (formattedIndex.length > 0) {
         const contextPath = path21.join(directory, ".swarm", "context.md");
         let existingContent = "";
-        if (_internals14.existsSync(contextPath)) {
-          existingContent = _internals14.readFileSync(contextPath, "utf-8");
+        if (_internals15.existsSync(contextPath)) {
+          existingContent = _internals15.readFileSync(contextPath, "utf-8");
         }
         const sectionHeader = "## Available Skills";
         const newSection = `${sectionHeader}
@@ -11897,10 +12053,10 @@ ${newSection}`;
           }
         }
         const swarmDir = path21.dirname(contextPath);
-        if (!_internals14.existsSync(swarmDir)) {
-          _internals14.mkdirSync(swarmDir, { recursive: true });
+        if (!_internals15.existsSync(swarmDir)) {
+          _internals15.mkdirSync(swarmDir, { recursive: true });
         }
-        _internals14.writeFileSync(contextPath, updatedContent, "utf-8");
+        _internals15.writeFileSync(contextPath, updatedContent, "utf-8");
       }
     } catch (err) {
       warn(`[skill-propagation-gate] failed to write skill index to context.md: ${err instanceof Error ? err.message : String(err)}`);
@@ -11926,7 +12082,7 @@ ${newSection}`;
   });
   const warningMsg = `Skill propagation warning: Delegating to ${targetBase} without SKILLS field. ` + `Available skills: ${skillNames.join(", ")}`;
   try {
-    _internals14.writeWarnEvent(directory, {
+    _internals15.writeWarnEvent(directory, {
       type: "skill_propagation_warn",
       timestamp: new Date().toISOString(),
       tool: toolName,
@@ -11958,17 +12114,17 @@ async function skillPropagationTransformScan(directory, output, sessionID, confi
   const validatedProvenancePaths = (fieldValue) => {
     if (remainingProvenanceValidationBudget <= 0)
       return [];
-    const references = _internals14.parseSkillPaths(fieldValue).slice(0, remainingProvenanceValidationBudget);
+    const references = _internals15.parseSkillPaths(fieldValue).slice(0, remainingProvenanceValidationBudget);
     remainingProvenanceValidationBudget -= references.length;
     return references.flatMap((reference) => {
-      const validation = _internals14.validateSkillReference(directory, reference, audienceContext, { enforceAudience: true });
+      const validation = _internals15.validateSkillReference(directory, reference, audienceContext, { enforceAudience: true });
       return validation.valid && validation.skillPath ? [validation.skillPath] : [];
     });
   };
   let dedupKeys = new Set;
   let existingEntries = [];
   try {
-    existingEntries = _internals14.readSkillUsageEntriesTail(directory, {
+    existingEntries = _internals15.readSkillUsageEntriesTail(directory, {
       sessionID
     });
     dedupKeys = new Set(existingEntries.map((e, i) => {
@@ -12039,7 +12195,7 @@ async function skillPropagationTransformScan(directory, output, sessionID, confi
         if (isDuplicate(skillPath, "reviewer", resolvedTaskID))
           continue;
         try {
-          _internals14.appendSkillUsageEntry(directory, {
+          _internals15.appendSkillUsageEntry(directory, {
             skillPath,
             agentName: "reviewer",
             taskID: resolvedTaskID,
@@ -12084,14 +12240,14 @@ async function skillPropagationTransformScan(directory, output, sessionID, confi
       }
       if (currentTargetAgent && skillsField && skillsField.toLowerCase() !== "none") {
         const skillPaths = validatedProvenancePaths(skillsField);
-        const taskId = _internals14.extractTaskIdFromPrompt(text);
+        const taskId = _internals15.extractTaskIdFromPrompt(text);
         for (const skillPath of skillPaths) {
           if (hadRecordingError)
             break;
           if (isDuplicate(skillPath, currentTargetAgent, taskId))
             continue;
           try {
-            _internals14.appendSkillUsageEntry(directory, {
+            _internals15.appendSkillUsageEntry(directory, {
               skillPath,
               agentName: currentTargetAgent,
               taskID: taskId,
@@ -12111,18 +12267,18 @@ async function skillPropagationTransformScan(directory, output, sessionID, confi
     break;
   }
 }
-_internals14.skillPropagationGateBefore = skillPropagationGateBefore;
-_internals14.skillPropagationTransformScan = skillPropagationTransformScan;
-_internals14.writeWarnEvent = writeWarnEvent;
-_internals14.discoverAvailableSkills = discoverAvailableSkills;
-_internals14.parseDelegationArgs = parseDelegationArgs;
-_internals14.parseSkillPaths = parseSkillPaths;
-_internals14.extractFileSkillReferences = extractFileSkillReferences;
-_internals14.validateSkillReference = validateSkillReference;
-_internals14.extractTaskIdFromPrompt = extractTaskIdFromPrompt;
-_internals14.extractSkillsFieldFromPrompt = extractSkillsFieldFromPrompt;
-_internals14.formatSkillIndexWithContext = formatSkillIndexWithContext;
-_internals14.loadRoutingSkills = loadRoutingSkills;
+_internals15.skillPropagationGateBefore = skillPropagationGateBefore;
+_internals15.skillPropagationTransformScan = skillPropagationTransformScan;
+_internals15.writeWarnEvent = writeWarnEvent;
+_internals15.discoverAvailableSkills = discoverAvailableSkills;
+_internals15.parseDelegationArgs = parseDelegationArgs;
+_internals15.parseSkillPaths = parseSkillPaths;
+_internals15.extractFileSkillReferences = extractFileSkillReferences;
+_internals15.validateSkillReference = validateSkillReference;
+_internals15.extractTaskIdFromPrompt = extractTaskIdFromPrompt;
+_internals15.extractSkillsFieldFromPrompt = extractSkillsFieldFromPrompt;
+_internals15.formatSkillIndexWithContext = formatSkillIndexWithContext;
+_internals15.loadRoutingSkills = loadRoutingSkills;
 
 // src/hooks/micro-reflector.ts
 var REFLECT_OUTCOMES = new Set([
@@ -12160,6 +12316,8 @@ async function readTaskTrajectory(directory, taskId) {
 // src/hooks/knowledge-curator.ts
 var seenRetroSections = new Map;
 var MAX_TRACKED_RETRO_SECTIONS = 500;
+var MAX_IN_FLIGHT_EVIDENCE_ENTRIES = 500;
+var inFlightEvidenceEntries = new Set;
 function pruneSeenRetroSections() {
   const cutoff = Date.now() - 86400000;
   for (const [key, entry] of seenRetroSections) {
@@ -12184,6 +12342,81 @@ function recordSeenRetroSection(key, value, timestamp) {
 function hashContent(content) {
   return createHash4("sha1").update(content).digest("hex");
 }
+async function canonicalExistingPath(candidate) {
+  let resolved = path23.resolve(candidate);
+  try {
+    resolved = await _internals16.realpath(resolved);
+  } catch {}
+  return resolved;
+}
+function isPathContained(root, candidate) {
+  const relative3 = path23.relative(root, candidate);
+  return relative3 === "" || !relative3.startsWith(`..${path23.sep}`) && relative3 !== ".." && !path23.isAbsolute(relative3);
+}
+function physicalPathIdentity(candidate) {
+  const normalized = candidate.replaceAll("\\", "/").normalize("NFC");
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+async function resolveEvidencePathScope(directory, relativeEvidencePath) {
+  const projectRoot = await canonicalExistingPath(directory);
+  const swarmRoot = await canonicalExistingPath(path23.join(projectRoot, ".swarm"));
+  if (!isPathContained(projectRoot, swarmRoot))
+    return null;
+  const evidenceRoot = await canonicalExistingPath(path23.join(swarmRoot, "evidence"));
+  if (!isPathContained(swarmRoot, evidenceRoot))
+    return null;
+  const evidenceTarget = await canonicalExistingPath(path23.join(swarmRoot, ...relativeEvidencePath.split("/")));
+  if (!isPathContained(evidenceRoot, evidenceTarget))
+    return null;
+  return {
+    projectIdentity: hashContent(physicalPathIdentity(projectRoot)),
+    evidenceIdentity: hashContent(physicalPathIdentity(evidenceTarget))
+  };
+}
+function sanitizeEvidenceLessons(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.filter((lesson) => typeof lesson === "string").map((lesson) => lesson.trim()).filter((lesson) => lesson.length > 0 && lesson.length <= 280);
+}
+function evidenceProjectName(entry, root) {
+  const metadata = isRecord2(entry.metadata) ? entry.metadata : null;
+  return typeof entry.project_name === "string" ? entry.project_name : typeof metadata?.project_name === "string" ? metadata.project_name : typeof root.project_name === "string" ? root.project_name : "unknown";
+}
+function evidencePhaseNumber(entry, root) {
+  return typeof entry.phase_number === "number" ? entry.phase_number : typeof root.phase_number === "number" ? root.phase_number : 1;
+}
+function extractEvidenceLessonBatches(evidenceData) {
+  const rawEntries = Array.isArray(evidenceData.entries) ? evidenceData.entries : [evidenceData];
+  const batches = [];
+  for (const rawEntry of rawEntries) {
+    if (!isRecord2(rawEntry))
+      continue;
+    if (Object.hasOwn(rawEntry, "type") && rawEntry.type !== "retrospective") {
+      continue;
+    }
+    const lessons = sanitizeEvidenceLessons(rawEntry.lessons_learned);
+    if (lessons.length === 0)
+      continue;
+    const phaseNumber = evidencePhaseNumber(rawEntry, evidenceData);
+    const projectName = evidenceProjectName(rawEntry, evidenceData);
+    const identity = hashContent(JSON.stringify([
+      rawEntry.type ?? "legacy-retrospective",
+      rawEntry.task_id ?? evidenceData.task_id ?? "",
+      rawEntry.timestamp ?? "",
+      rawEntry.agent ?? "",
+      phaseNumber,
+      projectName,
+      lessons
+    ]));
+    batches.push({
+      identity,
+      lessons,
+      projectName,
+      phaseNumber
+    });
+  }
+  return batches;
+}
 function isWriteToEvidenceFile(input) {
   const trigger = normalizeWriteTrigger(input);
   return isEvidencePath(trigger?.filePath);
@@ -12893,9 +13126,9 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
     } catch {}
   }
   if (!options?.skipAutoPromotion) {
-    await _internals15.runAutoPromotion(directory, config);
+    await _internals16.runAutoPromotion(directory, config);
     if (phaseInfo.phase_number > 0) {
-      await _internals15.runAutoDemotion(directory, config, phaseInfo.phase_number);
+      await _internals16.runAutoDemotion(directory, config, phaseInfo.phase_number);
     }
   }
   return { stored, reinforced, skipped, rejected, quarantined };
@@ -12984,9 +13217,11 @@ function createKnowledgeCuratorHook(directory, config, options = {}) {
     if (!isPlanTrigger && !isEvidenceTrigger)
       return;
     if (isEvidenceTrigger) {
-      const relativeEvidencePath = trigger.filePath.replace(/^.*\.swarm\//, "");
-      const evidenceKey = `evidence:${trigger.sessionID}:${relativeEvidencePath}`;
-      const lastSeenEvidence = seenRetroSections.get(evidenceKey);
+      const relativeEvidencePath = trigger.filePath.replaceAll("\\", "/").replace(/^.*\.swarm\//i, "");
+      const canonicalRelativeEvidencePath = path23.posix.normalize(relativeEvidencePath);
+      const evidenceScope = await resolveEvidencePathScope(directory, canonicalRelativeEvidencePath);
+      if (!evidenceScope)
+        return;
       const evidenceContent = await readSwarmFileAsync(directory, relativeEvidencePath);
       if (!evidenceContent)
         return;
@@ -12996,28 +13231,29 @@ function createKnowledgeCuratorHook(directory, config, options = {}) {
       } catch {
         return;
       }
-      let lessons = [];
-      if (Array.isArray(evidenceData.entries) && evidenceData.entries.length > 0) {
-        const firstEntry = evidenceData.entries[0];
-        if (Array.isArray(firstEntry.lessons_learned)) {
-          lessons = firstEntry.lessons_learned;
+      const batches = extractEvidenceLessonBatches(evidenceData);
+      for (const batch of batches) {
+        const evidenceKey = `evidence:${evidenceScope.projectIdentity}:${evidenceScope.evidenceIdentity}:entry:${batch.identity}`;
+        if (seenRetroSections.has(evidenceKey) || inFlightEvidenceEntries.has(evidenceKey)) {
+          continue;
+        }
+        if (inFlightEvidenceEntries.size >= MAX_IN_FLIGHT_EVIDENCE_ENTRIES) {
+          warn(`Evidence curation overload: ${MAX_IN_FLIGHT_EVIDENCE_ENTRIES} entries already in flight; retrying ${relativeEvidencePath} on a later trigger`);
+          continue;
+        }
+        inFlightEvidenceEntries.add(evidenceKey);
+        try {
+          await _internals16.curateAndStoreSwarm(batch.lessons, batch.projectName, { phase_number: batch.phaseNumber }, directory, config, {
+            llmDelegate: options.llmDelegateFactory?.(trigger.sessionID),
+            enrichmentQuota: options.enrichmentQuota
+          });
+          recordSeenRetroSection(evidenceKey, batch.identity, Date.now());
+        } catch (err) {
+          warn(`Evidence curation failed for entry ${batch.identity}, will retry on next trigger: ${err instanceof Error ? err.message : String(err)}`);
+        } finally {
+          inFlightEvidenceEntries.delete(evidenceKey);
         }
-      } else if (Array.isArray(evidenceData.lessons_learned)) {
-        lessons = evidenceData.lessons_learned;
-      }
-      if (lessons.length === 0)
-        return;
-      const evidenceHash = hashContent(JSON.stringify(lessons));
-      if (lastSeenEvidence?.value === evidenceHash) {
-        return;
       }
-      recordSeenRetroSection(evidenceKey, evidenceHash, Date.now());
-      const projectName2 = evidenceData.project_name ?? "unknown";
-      const phaseNumber2 = typeof evidenceData.phase_number === "number" ? evidenceData.phase_number : 1;
-      await _internals15.curateAndStoreSwarm(lessons, projectName2, { phase_number: phaseNumber2 }, directory, config, {
-        llmDelegate: options.llmDelegateFactory?.(trigger.sessionID),
-        enrichmentQuota: options.enrichmentQuota
-      });
       return;
     }
     const planContent = await readSwarmFileAsync(directory, "plan.md");
@@ -13039,14 +13275,14 @@ function createKnowledgeCuratorHook(directory, config, options = {}) {
     const projectName = projectNameMatch ? projectNameMatch[1].trim() : "unknown";
     const phaseMatch = /^Phase:\s*(\d+)/m.exec(planContent);
     const phaseNumber = phaseMatch ? parseInt(phaseMatch[1], 10) : 1;
-    await _internals15.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config, {
+    await _internals16.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config, {
       llmDelegate: options.llmDelegateFactory?.(trigger.sessionID),
       enrichmentQuota: options.enrichmentQuota
     });
   };
   return safeHook(handler);
 }
-var _internals15 = {
+var _internals16 = {
   isWriteToEvidenceFile,
   curateAndStoreSwarm,
   runAutoPromotion,
@@ -13056,7 +13292,11 @@ var _internals15 = {
   recordSeenRetroSection,
   hashContent,
   capSeenRetroSections,
-  MAX_TRACKED_RETRO_SECTIONS
+  MAX_TRACKED_RETRO_SECTIONS,
+  inFlightEvidenceEntries,
+  MAX_IN_FLIGHT_EVIDENCE_ENTRIES,
+  extractEvidenceLessonBatches,
+  realpath
 };
 
 // src/memory/finalize-reward-sweep.ts
@@ -13081,7 +13321,7 @@ async function runFinalizeRewardSweep(args) {
       return result;
     }
     const timestamp = args.timestamp ?? new Date().toISOString();
-    const provider = _internals16.createConfiguredMemoryProvider(directory, memoryConfig);
+    const provider = _internals17.createConfiguredMemoryProvider(directory, memoryConfig);
     try {
       result.swept = true;
       for (const taskId of taskIds) {
@@ -13101,7 +13341,7 @@ async function runFinalizeRewardSweep(args) {
         }
         let taskRewarded = 0;
         for (const runId of runIds) {
-          const { memoriesRewarded } = await _internals16.applyCouncilReward(provider, {
+          const { memoriesRewarded } = await _internals17.applyCouncilReward(provider, {
             runId,
             unitId: taskId,
             reward: FINALIZE_NEGATIVE_TERMINAL_REWARD,
@@ -13127,7 +13367,7 @@ async function runFinalizeRewardSweep(args) {
   }
   return result;
 }
-var _internals16 = {
+var _internals17 = {
   createConfiguredMemoryProvider,
   applyCouncilReward
 };
@@ -14154,7 +14394,7 @@ async function reconcileStaleActiveSkills(directory, options = {}) {
       continue;
     }
     try {
-      const regen = await _internals17.regenerateSkill(directory, skill.slug, {
+      const regen = await _internals18.regenerateSkill(directory, skill.slug, {
         evaluate: false
       });
       if (regen.regenerated) {
@@ -14404,7 +14644,7 @@ async function runSkillImprover(req) {
     autoApply
   };
 }
-var _internals17 = {
+var _internals18 = {
   runSkillImprover,
   buildDeterministicProposal,
   buildLLMProposalFrame,
@@ -14807,13 +15047,13 @@ var write_retro = createSwarmTool({
         task_id: args.task_id !== undefined ? String(args.task_id) : undefined,
         metadata: args.metadata
       };
-      return await _internals18.executeWriteRetro(writeRetroArgs, directory);
+      return await _internals19.executeWriteRetro(writeRetroArgs, directory);
     } catch {
       return JSON.stringify({ success: false, phase: rawPhase, message: "Invalid arguments" }, null, 2);
     }
   }
 });
-var _internals18 = {
+var _internals19 = {
   executeWriteRetro,
   write_retro
 };
@@ -15112,8 +15352,8 @@ async function runFinalizeStage(ctx) {
   ];
   ctx.curationSucceeded = false;
   try {
-    ctx.curationResult = await _internals19.curateAndStoreSwarm(ctx.allLessons, ctx.projectName, { phase_number: 0 }, ctx.directory, ctx.config, {
-      llmDelegate: _internals19.createCuratorLLMDelegate(ctx.directory, "phase", ctx.options.sessionID),
+    ctx.curationResult = await _internals20.curateAndStoreSwarm(ctx.allLessons, ctx.projectName, { phase_number: 0 }, ctx.directory, ctx.config, {
+      llmDelegate: _internals20.createCuratorLLMDelegate(ctx.directory, "phase", ctx.options.sessionID),
       enrichmentQuota: {
         maxCalls: ctx.config.enrichment.max_calls_per_day,
         window: ctx.config.enrichment.quota_window
@@ -15132,7 +15372,7 @@ async function runFinalizeStage(ctx) {
     if (ctx.config.hive_enabled === false) {} else {
       try {
         const entries = await readKnowledge(resolveSwarmKnowledgePath(ctx.directory));
-        const result = await _internals19.checkHivePromotions(entries, ctx.config);
+        const result = await _internals20.checkHivePromotions(entries, ctx.config);
         ctx.hivePromoted = result.new_promotions;
       } catch (hiveErr) {
         const msg = hiveErr instanceof Error ? hiveErr.message : String(hiveErr);
@@ -15153,7 +15393,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 } = _internals19.loadPluginConfigWithMeta(ctx.directory);
+      const { config: loadedConfig } = _internals20.loadPluginConfigWithMeta(ctx.directory);
       const skillImproverConfig = SkillImproverConfigSchema.parse(loadedConfig.skill_improver ?? {});
       const skillReviewResult = await runAbortableSkillReview({
         directory: ctx.directory,
@@ -15216,7 +15456,7 @@ async function runFinalizeStage(ctx) {
     }
     if (!ctx.planAlreadyDone || ctx.guaranteeResult.closedPhaseIds.length > 0 || ctx.guaranteeResult.closedTaskIds.length > 0) {
       try {
-        await _internals19.closePlanTerminalState(ctx.directory, ctx.planData, {
+        await _internals20.closePlanTerminalState(ctx.directory, ctx.planData, {
           closedPhaseIds: ctx.guaranteeResult.closedPhaseIds,
           closedTaskIds: ctx.guaranteeResult.closedTaskIds,
           originalStatuses: ctx.originalStatuses
@@ -15233,11 +15473,11 @@ async function runFinalizeStage(ctx) {
   }
   try {
     const { CuratorConfigSchema: CCS } = await import("./schema-e5kd993s.js");
-    const { config: pmLoadedConfig } = _internals19.loadPluginConfigWithMeta(ctx.directory);
+    const { config: pmLoadedConfig } = _internals20.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
-      const pmResult = await _internals19.runCuratorPostMortem(ctx.directory, {
-        llmDelegate: _internals19.createCuratorLLMDelegate(ctx.directory, "postmortem", ctx.options.sessionID),
+      const pmResult = await _internals20.runCuratorPostMortem(ctx.directory, {
+        llmDelegate: _internals20.createCuratorLLMDelegate(ctx.directory, "postmortem", ctx.options.sessionID),
         scope: "project",
         sessionID: ctx.options.sessionID
       });
@@ -15263,7 +15503,7 @@ async function copySqliteSafe(srcPath, destPath, laneEnv) {
   }
   let checkpointVerified = false;
   try {
-    const result = _internals19.spawnSync("sqlite3", [srcPath, "PRAGMA wal_checkpoint(TRUNCATE);"], {
+    const result = _internals20.spawnSync("sqlite3", [srcPath, "PRAGMA wal_checkpoint(TRUNCATE);"], {
       cwd: path29.dirname(srcPath),
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
@@ -15434,7 +15674,7 @@ async function runArchiveEvidenceRetention(ctx) {
   let maxAgeDays = 30;
   let maxBundles = 10;
   try {
-    const { config: evidenceLoadedConfig } = _internals19.loadPluginConfigWithMeta(ctx.directory);
+    const { config: evidenceLoadedConfig } = _internals20.loadPluginConfigWithMeta(ctx.directory);
     const evidenceCfg = evidenceLoadedConfig.evidence ?? {};
     if (typeof evidenceCfg.max_age_days === "number") {
       maxAgeDays = evidenceCfg.max_age_days;
@@ -15444,7 +15684,7 @@ async function runArchiveEvidenceRetention(ctx) {
     }
   } catch {}
   try {
-    await _internals19.archiveEvidence(ctx.directory, maxAgeDays, maxBundles);
+    await _internals20.archiveEvidence(ctx.directory, maxAgeDays, maxBundles);
   } catch (error2) {
     const msg = error2 instanceof Error ? error2.message : String(error2);
     ctx.warnings.push(`Evidence retention archive failed: ${msg}`);
@@ -15645,9 +15885,9 @@ async function runAlignStage(ctx) {
   const pruneBranches = ctx.args.includes("--prune-branches");
   let gitAlignResult = "";
   const prunedBranches = [];
-  const gitStatus = _internals19.getGitRepositoryStatus(ctx.directory);
+  const gitStatus = _internals20.getGitRepositoryStatus(ctx.directory);
   if (gitStatus.isRepo) {
-    const aggressiveResult = await _internals19.resetToMainAfterMerge(ctx.directory, {
+    const aggressiveResult = await _internals20.resetToMainAfterMerge(ctx.directory, {
       pruneBranches
     });
     if (aggressiveResult.success) {
@@ -15659,7 +15899,7 @@ async function runAlignStage(ctx) {
         ctx.warnings.push("Uncommitted changes were discarded during git alignment");
       }
     } else {
-      const alignResult = await _internals19.resetToRemoteBranch(ctx.directory, {
+      const alignResult = await _internals20.resetToRemoteBranch(ctx.directory, {
         pruneBranches
       });
       gitAlignResult = alignResult.message;
@@ -15719,7 +15959,7 @@ async function handleCloseCommand(directory, args, options = {}) {
   let finalizeLock = {
     acquired: false
   };
-  finalizeLock = await _internals19.acquireFinalizeLock(directory);
+  finalizeLock = await _internals20.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.`;
   }
@@ -15750,7 +15990,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 } = _internals19.loadPluginConfigWithMeta(directory);
+    const { config: loadedConfig } = _internals20.loadPluginConfigWithMeta(directory);
     const config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     const ctx = {
       directory,
@@ -15794,7 +16034,7 @@ This project was already finalized in a previous /swarm close run. The plan has
       args
     };
     await runFinalizeStage(ctx);
-    await _internals19.runFinalizeRewardSweep({
+    await _internals20.runFinalizeRewardSweep({
       directory,
       closedTaskIds: ctx.guaranteeResult.closedTaskIds,
       memoryConfig: loadedConfig.memory
@@ -15875,9 +16115,9 @@ This project was already finalized in a previous /swarm close run. The plan has
     }
     const sessionIdsToEnd = [...swarmState.agentSessions.keys()];
     for (const sessionId of sessionIdsToEnd) {
-      _internals19.endAgentSession(sessionId);
+      _internals20.endAgentSession(sessionId);
     }
-    _internals19.resetSwarmStatePreservingSingletons();
+    _internals20.resetSwarmStatePreservingSingletons();
     const retroWarnings = ctx.warnings.filter((w) => w.includes("Retrospective write") || w.includes("retrospective write") || w.includes("Session retrospective"));
     const otherWarnings = ctx.warnings.filter((w) => !w.includes("Retrospective write") && !w.includes("retrospective write") && !w.includes("Session retrospective"));
     let warningMsg = "";
@@ -15946,7 +16186,7 @@ async function acquireFinalizeLock(directory) {
   }
   return { acquired: false };
 }
-var _internals19 = {
+var _internals20 = {
   ACTIVE_STATE_DIRS_TO_CLEAN,
   countSessionKnowledgeEntries,
   CLOSE_SKILL_REVIEW_TIMEOUT_MS,
@@ -16793,9 +17033,9 @@ async function detectDarkMatter(directory, options) {
   } catch {
     return [];
   }
-  const commitMap = await _internals20.parseGitLog(directory, maxCommitsToAnalyze);
-  const matrix = _internals20.buildCoChangeMatrix(commitMap, maxFilesPerCommit);
-  const staticEdges = await _internals20.getStaticEdges(directory);
+  const commitMap = await _internals21.parseGitLog(directory, maxCommitsToAnalyze);
+  const matrix = _internals21.buildCoChangeMatrix(commitMap, maxFilesPerCommit);
+  const staticEdges = await _internals21.getStaticEdges(directory);
   const results = [];
   for (const entry of matrix.values()) {
     const key = `${entry.fileA}::${entry.fileB}`;
@@ -16911,11 +17151,11 @@ var co_change_analyzer = createSwarmTool({
       npmiThreshold,
       maxCommitsToAnalyze
     };
-    const pairs = await _internals20.detectDarkMatter(directory, options);
-    return _internals20.formatDarkMatterOutput(pairs);
+    const pairs = await _internals21.detectDarkMatter(directory, options);
+    return _internals21.formatDarkMatterOutput(pairs);
   }
 });
-var _internals20 = {
+var _internals21 = {
   parseGitLog,
   buildCoChangeMatrix,
   getStaticEdges,
@@ -16932,7 +17172,7 @@ var DEFAULT_MAX_COMMITS = 500;
 var cache = new Map;
 async function readGitHead(directory) {
   try {
-    const { stdout } = await _internals21.execFile("git", ["rev-parse", "HEAD"], {
+    const { stdout } = await _internals22.execFile("git", ["rev-parse", "HEAD"], {
       cwd: directory,
       timeout: GIT_HEAD_TIMEOUT_MS
     });
@@ -16958,9 +17198,9 @@ async function getCoChangeData(directory, options) {
   let entries;
   let commitsObserved;
   try {
-    const commitMap = await _internals21.parseGitLog(directory, maxCommits);
+    const commitMap = await _internals22.parseGitLog(directory, maxCommits);
     commitsObserved = commitMap.size;
-    const matrix = _internals21.buildCoChangeMatrix(commitMap);
+    const matrix = _internals22.buildCoChangeMatrix(commitMap);
     entries = Array.from(matrix.values());
   } catch {
     return { pairs: [], commitsObserved: 0 };
@@ -16984,10 +17224,10 @@ async function getCoChangePairs(directory, options) {
   const data = await getCoChangeData(directory, options);
   return data.pairs;
 }
-var _internals21 = {
+var _internals22 = {
   execFile: execFileAsync,
-  parseGitLog: _internals20.parseGitLog,
-  buildCoChangeMatrix: _internals20.buildCoChangeMatrix
+  parseGitLog: _internals21.parseGitLog,
+  buildCoChangeMatrix: _internals21.buildCoChangeMatrix
 };
 
 // src/turbo/epic/cochange-conflict.ts
@@ -17269,7 +17509,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 _internals22.loadPlanJsonOnly(directory);
+  const plan = await _internals23.loadPlanJsonOnly(directory);
   if (plan === null) {
     return "No plan found at `.swarm/plan.json`. Run `/swarm plan` to create one before measuring coupling.";
   }
@@ -17293,7 +17533,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 _internals22.getCoChangePairs(directory);
+  const cochangePairs = await _internals23.getCoChangePairs(directory);
   const report = computeCouplingReport(tasks, cochangePairs, {
     npmi: parsed.threshold,
     minCoChanges: parsed.minCoChanges
@@ -17332,13 +17572,13 @@ _Warning: failed to persist report (${persistStatus.error})._`;
   }
   return `${formatCouplingReportMarkdown(report)}${persistTrailer}`;
 }
-var _internals22 = {
+var _internals23 = {
   loadPlanJsonOnly,
   getCoChangePairs
 };
 
 // src/commands/curate.ts
-var _internals23 = {
+var _internals24 = {
   checkHivePromotions,
   readKnowledge,
   resolveSwarmKnowledgePath,
@@ -17346,8 +17586,8 @@ var _internals23 = {
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
       import("./schema-e5kd993s.js"),
-      import("./curator-ckzb8ww4.js"),
-      import("./curator-llm-factory-mhjcpy1s.js")
+      import("./curator-nh9raf1a.js"),
+      import("./curator-llm-factory-b3g0g0cd.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -17355,15 +17595,15 @@ var _internals23 = {
 async function handleCurateCommand(directory, _args, options) {
   try {
     const config = KnowledgeConfigSchema.parse({});
-    const swarmPath = _internals23.resolveSwarmKnowledgePath(directory);
-    const swarmEntries = await _internals23.readKnowledge(swarmPath) ?? [];
-    const summary = await _internals23.checkHivePromotions(swarmEntries, config);
+    const swarmPath = _internals24.resolveSwarmKnowledgePath(directory);
+    const swarmEntries = await _internals24.readKnowledge(swarmPath) ?? [];
+    const summary = await _internals24.checkHivePromotions(swarmEntries, config);
     if (options?.sessionID) {
       let onDemandPhase = 1;
       try {
-        const { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 } = await _internals23.loadCuratorDeps();
+        const { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 } = await _internals24.loadCuratorDeps();
         const curatorConfig = CuratorConfigSchema.parse({});
-        const priorSummary = await _internals23.readSwarmFileAsync(directory, "curator-summary.json");
+        const priorSummary = await _internals24.readSwarmFileAsync(directory, "curator-summary.json");
         if (priorSummary) {
           try {
             const parsed = JSON.parse(priorSummary);
@@ -17374,7 +17614,7 @@ async function handleCurateCommand(directory, _args, options) {
         }
         let planPhaseCount = Infinity;
         try {
-          const planRaw = await _internals23.readSwarmFileAsync(directory, "plan.json");
+          const planRaw = await _internals24.readSwarmFileAsync(directory, "plan.json");
           if (planRaw) {
             const plan = JSON.parse(planRaw);
             if (Array.isArray(plan.phases))
@@ -17393,8 +17633,8 @@ async function handleCurateCommand(directory, _args, options) {
           summary.knowledge_skipped = applied.skipped;
           summary.curator_phase = onDemandPhase;
           try {
-            const updatedEntries = await _internals23.readKnowledge(swarmPath) ?? [];
-            const postUpdateHive = await _internals23.checkHivePromotions(updatedEntries, config);
+            const updatedEntries = await _internals24.readKnowledge(swarmPath) ?? [];
+            const postUpdateHive = await _internals24.checkHivePromotions(updatedEntries, config);
             summary.new_promotions += postUpdateHive.new_promotions;
             summary.encounters_incremented += postUpdateHive.encounters_incremented;
             summary.advancements += postUpdateHive.advancements;
@@ -17459,7 +17699,7 @@ async function handleDarkMatterCommand(directory, args) {
   }
   let pairs;
   try {
-    pairs = await _internals20.detectDarkMatter(directory, options);
+    pairs = await _internals21.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Dark Matter Analysis Failed
@@ -17843,7 +18083,7 @@ import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.113.3",
+  version: "7.113.4",
   description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -18296,7 +18536,7 @@ function resolveCachePackageRoot(cachePath) {
   const nestedPackageRoot = path36.join(cachePath, "node_modules", "opencode-swarm");
   return existsSync23(nestedPackageRoot) ? nestedPackageRoot : cachePath;
 }
-var _internals24 = {
+var _internals25 = {
   detectSandboxCapability: () => sandboxCapabilityProbe.detect(),
   getSandboxExecutor: getExecutor
 };
@@ -18880,9 +19120,9 @@ async function checkCurator(directory) {
 }
 async function getSandboxStatus() {
   try {
-    const capability = await _internals24.detectSandboxCapability();
+    const capability = await _internals25.detectSandboxCapability();
     const mechanism = capability.mechanism ?? "none";
-    const executor = await _internals24.getSandboxExecutor();
+    const executor = await _internals25.getSandboxExecutor();
     const hasExecutor = executor !== null;
     if (hasExecutor) {
       const executorStrength = executor?.strength;
@@ -19634,7 +19874,7 @@ function readPromotionEvidence(directory) {
 }
 
 // src/commands/epic.ts
-var _internals25 = {
+var _internals26 = {
   loadPluginConfigWithMeta,
   loadPlanJsonOnly,
   getCoChangeData,
@@ -19656,7 +19896,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 = _internals25.ensureAgentSession(sessionID, undefined, directory);
+  const session = _internals26.ensureAgentSession(sessionID, undefined, directory);
   const arg0 = args[0]?.toLowerCase();
   switch (arg0) {
     case "status":
@@ -19683,7 +19923,7 @@ Usage:
 }
 function enableAndAck(directory, sessionID, session) {
   try {
-    _internals25.enableEpicMode(directory, sessionID);
+    _internals26.enableEpicMode(directory, sessionID);
   } catch (err) {
     return `Error enabling Epic Mode: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -19699,7 +19939,7 @@ function enableAndAck(directory, sessionID, session) {
 }
 function disableAndAck(directory, sessionID, session) {
   try {
-    _internals25.disableEpicMode(directory, sessionID);
+    _internals26.disableEpicMode(directory, sessionID);
   } catch (err) {
     return `Error disabling Epic Mode: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -19708,12 +19948,12 @@ function disableAndAck(directory, sessionID, session) {
 }
 function renderStatus(directory, sessionID) {
   const lines = ["## Epic Mode \u2014 Status", ""];
-  if (_internals25.isStateUnreadable(directory)) {
+  if (_internals26.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 = _internals25.loadEpicSessionState(directory, sessionID);
+  const state = _internals26.loadEpicSessionState(directory, sessionID);
   if (!state) {
     lines.push("Epic Mode has not been toggled for this session.");
     return lines.join(`
@@ -19765,7 +20005,7 @@ function formatGreenfieldDetail(input) {
 function renderLast(directory) {
   let records;
   try {
-    records = _internals25.readPromotionEvidence(directory);
+    records = _internals26.readPromotionEvidence(directory);
   } catch (err) {
     return `Error reading epic-promotions.jsonl: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -19820,7 +20060,7 @@ function renderLast(directory) {
 `);
 }
 function renderCalibration(directory) {
-  if (_internals25.isCalibrationStateUnreadable(directory)) {
+  if (_internals26.isCalibrationStateUnreadable(directory)) {
     return [
       "## Epic Mode \u2014 Calibration",
       "",
@@ -19832,11 +20072,11 @@ function renderCalibration(directory) {
   }
   let state;
   try {
-    state = _internals25.loadCalibrationState(directory);
+    state = _internals26.loadCalibrationState(directory);
   } catch (err) {
     return `Error reading calibration state: ${err instanceof Error ? err.message : String(err)}`;
   }
-  const { config } = _internals25.loadPluginConfigWithMeta(directory);
+  const { config } = _internals26.loadPluginConfigWithMeta(directory);
   const staticThreshold = config.turbo?.epic?.mode?.activation_threshold ?? 0.3;
   const calibrationCfg = config.turbo?.epic?.calibration;
   const loosenWindow = calibrationCfg?.loosen_window ?? 10;
@@ -19884,7 +20124,7 @@ function renderCalibration(directory) {
   lines.push("");
   let recentDivergent = [];
   try {
-    const all = _internals25.readDivergenceHistory(directory, { limit: 50 });
+    const all = _internals26.readDivergenceHistory(directory, { limit: 50 });
     recentDivergent = all.filter((r) => !r.isClean).slice(-5);
   } catch {}
   lines.push("### Recent divergent tasks (tightened the threshold)");
@@ -19901,11 +20141,11 @@ function renderCalibration(directory) {
 `);
 }
 async function renderDecide(directory) {
-  const plan = await _internals25.loadPlanJsonOnly(directory);
+  const plan = await _internals26.loadPlanJsonOnly(directory);
   if (!plan) {
     return "No plan found at `.swarm/plan.json`. Run `/swarm plan` first.";
   }
-  const { config } = _internals25.loadPluginConfigWithMeta(directory);
+  const { config } = _internals26.loadPluginConfigWithMeta(directory);
   const modeCfg = config.turbo?.epic?.mode;
   const cochangeCfg = config.turbo?.epic?.cochange;
   const activationThreshold = modeCfg?.activation_threshold ?? 0.3;
@@ -19915,20 +20155,20 @@ async function renderDecide(directory) {
   const tasks = [];
   for (const phase of plan.phases) {
     for (const task of phase.tasks) {
-      const scopeFiles = _internals25.readTaskScopes(directory, task.id);
+      const scopeFiles = _internals26.readTaskScopes(directory, task.id);
       const scope = scopeFiles ?? task.files_touched ?? [];
       tasks.push({ id: task.id, scope });
     }
   }
-  const { pairs, commitsObserved } = await _internals25.getCoChangeData(directory);
+  const { pairs, commitsObserved } = await _internals26.getCoChangeData(directory);
   const isGitProject = (() => {
     try {
-      return _internals25.isGitRepo(directory);
+      return _internals26.isGitRepo(directory);
     } catch {
       return false;
     }
   })();
-  const verdict = _internals25.decideEpicActivation(tasks, pairs, commitsObserved, {
+  const verdict = _internals26.decideEpicActivation(tasks, pairs, commitsObserved, {
     activationThreshold,
     minCommitsForSignal,
     cochangeNpmiThreshold,
@@ -19972,7 +20212,7 @@ function formatVerdict(verdict) {
 }
 
 // src/services/evidence-service.ts
-var _internals26 = {
+var _internals27 = {
   loadEvidence,
   listEvidenceTaskIds
 };
@@ -20017,7 +20257,7 @@ function getVerdictEmoji(verdict) {
   return getVerdictIcon(verdict);
 }
 async function getTaskEvidenceData(directory, taskId) {
-  const result = await _internals26.loadEvidence(directory, taskId);
+  const result = await _internals27.loadEvidence(directory, taskId);
   if (result.status !== "found") {
     return {
       hasEvidence: false,
@@ -20040,13 +20280,13 @@ async function getTaskEvidenceData(directory, taskId) {
   };
 }
 async function getEvidenceListData(directory) {
-  const taskIds = await _internals26.listEvidenceTaskIds(directory);
+  const taskIds = await _internals27.listEvidenceTaskIds(directory);
   if (taskIds.length === 0) {
     return { hasEvidence: false, tasks: [] };
   }
   const tasks = [];
   for (const taskId of taskIds) {
-    const result = await _internals26.loadEvidence(directory, taskId);
+    const result = await _internals27.loadEvidence(directory, taskId);
     if (result.status === "found") {
       tasks.push({
         taskId,
@@ -20674,7 +20914,7 @@ function extractCurrentPhaseFromPlan(plan) {
   if (!plan) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
-  if (!_internals27.validatePlanPhases(plan)) {
+  if (!_internals28.validatePlanPhases(plan)) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
   let currentPhase = null;
@@ -20816,9 +21056,9 @@ function extractPhaseMetrics(content) {
 async function getHandoffData(directory) {
   const now = new Date().toISOString();
   const sessionContent = await readSwarmFileAsync(directory, "session/state.json");
-  const sessionState = _internals27.parseSessionState(sessionContent);
+  const sessionState = _internals28.parseSessionState(sessionContent);
   const plan = await loadPlanJsonOnly(directory);
-  const planInfo = _internals27.extractCurrentPhaseFromPlan(plan);
+  const planInfo = _internals28.extractCurrentPhaseFromPlan(plan);
   if (!plan) {
     const planMdContent = await readSwarmFileAsync(directory, "plan.md");
     if (planMdContent) {
@@ -20837,8 +21077,8 @@ async function getHandoffData(directory) {
     }
   }
   const contextContent = await readSwarmFileAsync(directory, "context.md");
-  const recentDecisions = _internals27.extractDecisions(contextContent);
-  const rawPhaseMetrics = _internals27.extractPhaseMetrics(contextContent);
+  const recentDecisions = _internals28.extractDecisions(contextContent);
+  const rawPhaseMetrics = _internals28.extractPhaseMetrics(contextContent);
   const phaseMetrics = sanitizeString(rawPhaseMetrics, 1000);
   let delegationState = null;
   if (sessionState?.delegationState) {
@@ -21002,7 +21242,7 @@ ${lines.join(`
 `)}
 \`\`\``;
 }
-var _internals27 = {
+var _internals28 = {
   getHandoffData,
   formatHandoffMarkdown,
   formatContinuationPrompt,
@@ -21151,15 +21391,15 @@ async function writeSnapshot(directory, state) {
 }
 function createSnapshotWriterHook(directory) {
   return (_input, _output) => {
-    _writeInFlight = _writeInFlight.then(() => _internals28.writeSnapshot(directory, swarmState), () => _internals28.writeSnapshot(directory, swarmState));
+    _writeInFlight = _writeInFlight.then(() => _internals29.writeSnapshot(directory, swarmState), () => _internals29.writeSnapshot(directory, swarmState));
     return _writeInFlight;
   };
 }
 async function flushPendingSnapshot(directory) {
-  _writeInFlight = _writeInFlight.then(() => _internals28.writeSnapshot(directory, swarmState), () => _internals28.writeSnapshot(directory, swarmState));
+  _writeInFlight = _writeInFlight.then(() => _internals29.writeSnapshot(directory, swarmState), () => _internals29.writeSnapshot(directory, swarmState));
   await _writeInFlight;
 }
-var _internals28 = {
+var _internals29 = {
   writeSnapshot,
   createSnapshotWriterHook,
   flushPendingSnapshot
@@ -21367,7 +21607,7 @@ var IPV4_PRIVATE_192 = /^192\.168\./;
 var IPV4_ZERO_NETWORK = /^0\./;
 var IPV6_LINK_LOCAL = /^fe80:/i;
 var IPV6_UNIQUE_LOCAL = /^f[cd][0-9a-f]{2}:/i;
-var _internals29 = {
+var _internals30 = {
   spawnSync: (cmd, args, options) => {
     const mergedEnv = mergeEnvForChild(options?.env, options?.envOverrides);
     return child_process6.spawnSync(cmd, args, {
@@ -21485,7 +21725,7 @@ function validateAndSanitizeGithubUrl(rawUrl, resource) {
 }
 function detectGitRemote(cwd, laneEnv) {
   try {
-    const result = _internals29.spawnSync("git", ["remote", "get-url", "origin"], {
+    const result = _internals30.spawnSync("git", ["remote", "get-url", "origin"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 5000,
@@ -21662,7 +21902,7 @@ import * as path42 from "path";
 async function migrateKnowledgeToExternal(_directory, _config) {
   const externalSentinelPath = path42.join(_directory, ".swarm", ".knowledge-external-migrated");
   const contextPath = path42.join(_directory, ".swarm", "context.md");
-  if (_internals30.existsSync(externalSentinelPath)) {
+  if (_internals31.existsSync(externalSentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -21671,7 +21911,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
       skippedReason: "external-sentinel-exists"
     };
   }
-  if (!_internals30.existsSync(contextPath)) {
+  if (!_internals31.existsSync(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -21680,7 +21920,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
       skippedReason: "no-context-file"
     };
   }
-  const contextContent = await _internals30.readFile(contextPath, "utf-8");
+  const contextContent = await _internals31.readFile(contextPath, "utf-8");
   if (contextContent.trim().length === 0) {
     return {
       migrated: false,
@@ -21698,7 +21938,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
       entriesCount++;
     }
   }
-  await _internals30.writeSentinel(externalSentinelPath, entriesCount, entriesCount);
+  await _internals31.writeSentinel(externalSentinelPath, entriesCount, entriesCount);
   return {
     migrated: true,
     entriesMigrated: entriesCount,
@@ -21706,7 +21946,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
     entriesTotal: entriesCount
   };
 }
-var _internals30 = {
+var _internals31 = {
   appendKnowledge,
   migrateContextToKnowledge,
   migrateKnowledgeToExternal,
@@ -21757,9 +21997,9 @@ async function migrateContextToKnowledge(directory, config) {
       skippedReason: "empty-context"
     };
   }
-  const rawEntries = _internals30.parseContextMd(contextContent);
+  const rawEntries = _internals31.parseContextMd(contextContent);
   if (rawEntries.length === 0) {
-    await _internals30.writeSentinel(sentinelPath, 0, 0);
+    await _internals31.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -21770,10 +22010,10 @@ async function migrateContextToKnowledge(directory, config) {
   const existing = await readKnowledge(knowledgePath);
   let migrated = 0;
   let dropped = 0;
-  const projectName = _internals30.inferProjectName(directory);
+  const projectName = _internals31.inferProjectName(directory);
   for (const raw of rawEntries) {
     if (config.validation_enabled !== false) {
-      const category = raw.categoryHint ?? _internals30.inferCategoryFromText(raw.text);
+      const category = raw.categoryHint ?? _internals31.inferCategoryFromText(raw.text);
       const result = validateLesson(raw.text, existing.map((e) => e.lesson), {
         category,
         scope: "global",
@@ -21793,8 +22033,8 @@ async function migrateContextToKnowledge(directory, config) {
     const entry = {
       id: randomUUID6(),
       tier: "swarm",
-      lesson: _internals30.truncateLesson(raw.text),
-      category: raw.categoryHint ?? _internals30.inferCategoryFromText(raw.text),
+      lesson: _internals31.truncateLesson(raw.text),
+      category: raw.categoryHint ?? _internals31.inferCategoryFromText(raw.text),
       tags: [...inferredTags, `migration:${raw.sourceSection}`],
       scope: "global",
       confidence: 0.3,
@@ -21817,7 +22057,7 @@ async function migrateContextToKnowledge(directory, config) {
   if (migrated > 0) {
     await rewriteKnowledge(knowledgePath, existing);
   }
-  await _internals30.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals31.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -21827,7 +22067,7 @@ async function migrateContextToKnowledge(directory, config) {
   };
 }
 async function migrateHiveKnowledgeLegacy(config) {
-  const legacyHivePath = _internals30.resolveLegacyHiveKnowledgePath();
+  const legacyHivePath = _internals31.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath();
   const sentinelPath = path42.join(path42.dirname(canonicalHivePath), ".hive-knowledge-migrated");
   if (existsSync28(sentinelPath)) {
@@ -21850,7 +22090,7 @@ async function migrateHiveKnowledgeLegacy(config) {
   }
   const legacyEntries = await readKnowledge(legacyHivePath);
   if (legacyEntries.length === 0) {
-    await _internals30.writeSentinel(sentinelPath, 0, 0);
+    await _internals31.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -21898,7 +22138,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       const newHiveEntry = {
         id: resolvedId,
         tier: "hive",
-        lesson: _internals30.truncateLesson(lesson),
+        lesson: _internals31.truncateLesson(lesson),
         category,
         tags: ["migration:legacy-hive"],
         scope: scopeTag,
@@ -21917,7 +22157,7 @@ async function migrateHiveKnowledgeLegacy(config) {
         encounter_score: 1
       };
       try {
-        await _internals30.appendKnowledge(canonicalHivePath, newHiveEntry);
+        await _internals31.appendKnowledge(canonicalHivePath, newHiveEntry);
         existingHiveEntries.push(newHiveEntry);
         migrated++;
       } catch (appendError) {
@@ -21933,7 +22173,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       dropped++;
     }
   }
-  await _internals30.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals31.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} legacy hive entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -21944,7 +22184,7 @@ async function migrateHiveKnowledgeLegacy(config) {
   };
 }
 function parseContextMd(content) {
-  const sections = _internals30.splitIntoSections(content);
+  const sections = _internals31.splitIntoSections(content);
   const entries = [];
   const seen = new Set;
   const sectionPatterns = [
@@ -21960,7 +22200,7 @@ function parseContextMd(content) {
     const match = sectionPatterns.find((sp) => sp.pattern.test(section.heading));
     if (!match)
       continue;
-    const bullets = _internals30.extractBullets(section.body);
+    const bullets = _internals31.extractBullets(section.body);
     for (const bullet of bullets) {
       if (bullet.length < 15)
         continue;
@@ -21969,9 +22209,9 @@ function parseContextMd(content) {
         continue;
       seen.add(normalized);
       entries.push({
-        text: _internals30.truncateLesson(bullet),
+        text: _internals31.truncateLesson(bullet),
         sourceSection: match.sourceSection,
-        categoryHint: _internals30.inferCategoryFromText(bullet)
+        categoryHint: _internals31.inferCategoryFromText(bullet)
       });
     }
   }
@@ -22061,8 +22301,8 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await _internals30.mkdir(path42.dirname(sentinelPath), { recursive: true });
-  await _internals30.writeFile(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
+  await _internals31.mkdir(path42.dirname(sentinelPath), { recursive: true });
+  await _internals31.writeFile(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 function resolveLegacyHiveKnowledgePath() {
   const platform = process.platform;
@@ -22443,7 +22683,7 @@ function timeoutMessage(timeoutMs) {
 async function computeWithTimeout(directory, currentPhase, timeoutMs) {
   const controller = new AbortController;
   let timeout;
-  const metricsPromise = _internals31.computeLearningMetrics(directory, {
+  const metricsPromise = _internals32.computeLearningMetrics(directory, {
     currentPhase,
     signal: controller.signal
   });
@@ -22500,7 +22740,7 @@ ${JSON.stringify({
     return `Error computing learning metrics: ${message}. Run /swarm diagnose to check .swarm/ health.`;
   }
 }
-var _internals31 = {
+var _internals32 = {
   computeLearningMetrics
 };
 
@@ -22702,7 +22942,7 @@ async function readLatestLoopState(directory) {
     return null;
   }
 }
-var _internals32 = {
+var _internals33 = {
   readLatestLoopState
 };
 var USAGE7 = `Usage: /swarm loop <objective> [--max-cycles 1..5] [--autonomy checkpoint|auto] [--depth standard|exhaustive] [--resume]
@@ -22815,7 +23055,7 @@ ${USAGE7}`;
   }
   let autonomy = parsed.autonomy;
   if (parsed.resume && !parsed.autonomyExplicit) {
-    const state = await _internals32.readLatestLoopState(_directory);
+    const state = await _internals33.readLatestLoopState(_directory);
     if (state?.autonomy && AUTONOMY_LEVELS.has(state.autonomy)) {
       autonomy = state.autonomy;
     }
@@ -22903,7 +23143,7 @@ async function rmTempRoot(tempRoot) {
     } catch (err) {
       if (attempt === 9)
         throw err;
-      await new Promise((resolve12) => setTimeout(resolve12, 50));
+      await new Promise((resolve13) => setTimeout(resolve13, 50));
     }
   }
 }
@@ -23751,15 +23991,15 @@ function truncate(value, maxLength) {
 }
 
 // src/services/plan-service.ts
-var _internals33 = {
+var _internals34 = {
   loadPlanJsonOnly,
   derivePlanMarkdown,
   readSwarmFileAsync
 };
 async function getPlanData(directory, phaseArg) {
-  const plan = await _internals33.loadPlanJsonOnly(directory);
+  const plan = await _internals34.loadPlanJsonOnly(directory);
   if (plan) {
-    const fullMarkdown = _internals33.derivePlanMarkdown(plan);
+    const fullMarkdown = _internals34.derivePlanMarkdown(plan);
     if (phaseArg === undefined || phaseArg === null || phaseArg === "") {
       return {
         hasPlan: true,
@@ -23802,7 +24042,7 @@ async function getPlanData(directory, phaseArg) {
       isLegacy: false
     };
   }
-  const planContent = await _internals33.readSwarmFileAsync(directory, "plan.md");
+  const planContent = await _internals34.readSwarmFileAsync(directory, "plan.md");
   if (!planContent) {
     return {
       hasPlan: false,
@@ -23899,7 +24139,7 @@ async function handlePlanCommand(directory, args) {
   return formatPlanMarkdown(planData);
 }
 // src/commands/post-mortem.ts
-var _internals34 = {
+var _internals35 = {
   createCuratorLLMDelegate,
   runCuratorPostMortem
 };
@@ -23947,10 +24187,10 @@ async function handlePostMortemCommand(directory, args, options) {
     };
     if (options?.sessionID) {
       try {
-        pmOptions.llmDelegate = _internals34.createCuratorLLMDelegate(directory, "postmortem", options.sessionID);
+        pmOptions.llmDelegate = _internals35.createCuratorLLMDelegate(directory, "postmortem", options.sessionID);
       } catch {}
     }
-    const result = await _internals34.runCuratorPostMortem(directory, pmOptions);
+    const result = await _internals35.runCuratorPostMortem(directory, pmOptions);
     const lines = [];
     if (result.success) {
       lines.push("## Post-Mortem Report Generated");
@@ -24186,7 +24426,7 @@ function formatMergeGroupStatus(status, conclusion, htmlUrl) {
   }
   return parts.join(" ");
 }
-var _internals35 = {
+var _internals36 = {
   formatRelativeTime,
   formatMergeGroupStatus,
   listActive,
@@ -24194,7 +24434,7 @@ var _internals35 = {
   parseMergeGroupRuns
 };
 async function handlePrMonitorStatusCommand(directory, _args, sessionID, source) {
-  const allActive = await _internals35.listActive(directory);
+  const allActive = await _internals36.listActive(directory);
   const allSessions = source === "cli";
   const subs = allSessions ? allActive : allActive.filter((record) => record.sessionID === sessionID);
   if (subs.length === 0) {
@@ -24210,7 +24450,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 _internals35.listMergeGroupRuns(directory, sub.repoFullName, sub.prNumber);
+    const mergeGroupRuns = await _internals36.listMergeGroupRuns(directory, sub.repoFullName, sub.prNumber);
     if (mergeGroupRuns.runs.length > 0) {
       lines.push("     Merge-group runs:");
       for (const run of mergeGroupRuns.runs) {
@@ -24350,7 +24590,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 = _internals36.loadPluginConfig(directory);
+    const config = _internals37.loadPluginConfig(directory);
     const prMonitorConfig = config.pr_monitor;
     if (!prMonitorConfig?.enabled) {
       return [
@@ -24360,7 +24600,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
       ].join(`
 `);
     }
-    await _internals36.subscribe(directory, {
+    await _internals37.subscribe(directory, {
       sessionID,
       prNumber: prInfo.number,
       repoFullName,
@@ -24388,7 +24628,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals36 = {
+var _internals37 = {
   loadPluginConfig,
   subscribe
 };
@@ -24411,9 +24651,9 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
   const refToken = rest[0];
-  const prInfo = _internals37.parsePrRef(refToken, directory);
+  const prInfo = _internals38.parsePrRef(refToken, directory);
   if (!prInfo) {
-    if (_internals37.looksLikePrRef(refToken)) {
+    if (_internals38.looksLikePrRef(refToken)) {
       return [
         `Error: Could not resolve PR reference from "${refToken}".`,
         "",
@@ -24434,8 +24674,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 = _internals37.buildCorrelationId(sessionID, repoFullName, prInfo.number);
-    const result = await _internals37.unsubscribe(directory, correlationId);
+    const correlationId = _internals38.buildCorrelationId(sessionID, repoFullName, prInfo.number);
+    const result = await _internals38.unsubscribe(directory, correlationId);
     if (!result) {
       return [
         `Not subscribed to ${prUrl}`,
@@ -24462,7 +24702,7 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals37 = {
+var _internals38 = {
   unsubscribe,
   buildCorrelationId,
   parsePrRef,
@@ -24780,7 +25020,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
       stderr: "pipe"
     });
     const biomeExit = biomeProc.exited;
-    const timeout = new Promise((resolve13) => setTimeout(() => resolve13("timeout"), DETECT_TIMEOUT));
+    const timeout = new Promise((resolve14) => setTimeout(() => resolve14("timeout"), DETECT_TIMEOUT));
     const result = await Promise.race([biomeExit, timeout]);
     if (result === "timeout") {
       biomeProc.kill();
@@ -24794,7 +25034,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
       stderr: "pipe"
     });
     const eslintExit = eslintProc.exited;
-    const timeout = new Promise((resolve13) => setTimeout(() => resolve13("timeout"), DETECT_TIMEOUT));
+    const timeout = new Promise((resolve14) => setTimeout(() => resolve14("timeout"), DETECT_TIMEOUT));
     const result = await Promise.race([eslintExit, timeout]);
     if (result === "timeout") {
       eslintProc.kill();
@@ -24944,15 +25184,15 @@ var lint = createSwarmTool({
     }
     const { mode } = args;
     const cwd = directory;
-    const linter = await _internals38.detectAvailableLinter(directory);
+    const linter = await _internals39.detectAvailableLinter(directory);
     if (linter) {
-      const result = await _internals38.runLint(linter, mode, directory);
+      const result = await _internals39.runLint(linter, mode, directory);
       return JSON.stringify(result, null, 2);
     }
-    const additionalLinter = _internals38.detectAdditionalLinter(cwd);
+    const additionalLinter = _internals39.detectAdditionalLinter(cwd);
     if (additionalLinter) {
       warn(`[lint] Using ${additionalLinter} linter for this project`);
-      const result = await _internals38.runAdditionalLint(additionalLinter, mode, cwd);
+      const result = await _internals39.runAdditionalLint(additionalLinter, mode, cwd);
       return JSON.stringify(result, null, 2);
     }
     const errorResult = {
@@ -24966,7 +25206,7 @@ For Rust: rustup component add clippy`
     return JSON.stringify(errorResult, null, 2);
   }
 });
-var _internals38 = {
+var _internals39 = {
   detectAvailableLinter,
   runLint,
   detectAdditionalLinter,
@@ -25654,7 +25894,7 @@ var secretscan = createSwarmTool({
 });
 async function runSecretscan(directory) {
   try {
-    const result = await _internals39.secretscan.execute({ directory }, {});
+    const result = await _internals40.secretscan.execute({ directory }, {});
     const jsonStr = typeof result === "string" ? result : result.output;
     return JSON.parse(jsonStr);
   } catch (e) {
@@ -25726,7 +25966,7 @@ async function runSecretscanOnFiles(files, directory) {
     };
   }
 }
-var _internals39 = {
+var _internals40 = {
   secretscan,
   runSecretscan,
   runSecretscanOnFiles,
@@ -26002,7 +26242,7 @@ async function buildImpactMapInternal(cwd) {
   }
   return impactMap;
 }
-var _internals40 = {
+var _internals41 = {
   validateProjectRoot,
   normalizePath: normalizePath2,
   isCacheStale,
@@ -26017,8 +26257,8 @@ var _internals40 = {
   _clearGoModuleCache
 };
 async function buildImpactMap(cwd) {
-  const impactMap = await _internals40.buildImpactMapInternal(cwd);
-  await _internals40.saveImpactMap(cwd, impactMap);
+  const impactMap = await _internals41.buildImpactMapInternal(cwd);
+  await _internals41.saveImpactMap(cwd, impactMap);
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
@@ -26032,7 +26272,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 (!_internals40.isCacheStale(map, generatedAt)) {
+          if (!_internals41.isCacheStale(map, generatedAt)) {
             return map;
           }
           if (options?.skipRebuild) {
@@ -26052,13 +26292,13 @@ async function loadImpactMap(cwd, options) {
   if (options?.skipRebuild) {
     return {};
   }
-  return _internals40.buildImpactMap(cwd);
+  return _internals41.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
   if (!path50.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
-  _internals40.validateProjectRoot(cwd);
+  _internals41.validateProjectRoot(cwd);
   const cacheDir2 = path50.join(cwd, ".swarm", "cache");
   const cachePath = path50.join(cacheDir2, "impact-map.json");
   if (!fs19.existsSync(cacheDir2)) {
@@ -26082,7 +26322,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
     };
   }
   const validFiles = changedFiles.filter((f) => typeof f === "string" && f.length > 0 && !f.includes("\x00"));
-  const impactMap = await _internals40.loadImpactMap(cwd);
+  const impactMap = await _internals41.loadImpactMap(cwd);
   const impactedTestsSet = new Set;
   const untestedFiles = [];
   let visitedCount = 0;
@@ -26552,7 +26792,7 @@ function batchAppendTestRuns(records, workingDir) {
   }
   const historyPath = getHistoryPath(workingDir);
   const historyDir = path51.dirname(historyPath);
-  _internals41.validateProjectRoot(workingDir);
+  _internals42.validateProjectRoot(workingDir);
   if (!fs20.existsSync(historyDir)) {
     fs20.mkdirSync(historyDir, { recursive: true });
   }
@@ -26675,7 +26915,7 @@ function getAllHistory(workingDir) {
   records.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
   return records;
 }
-var _internals41 = {
+var _internals42 = {
   validateProjectRoot
 };
 
@@ -27944,9 +28184,9 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
       stderr: "pipe",
       cwd
     });
-    const timeoutPromise = new Promise((resolve16) => setTimeout(() => {
+    const timeoutPromise = new Promise((resolve17) => setTimeout(() => {
       proc.kill();
-      resolve16(-1);
+      resolve17(-1);
     }, timeout_ms));
     const [exitCode, stdoutResult, stderrResult] = await Promise.all([
       Promise.race([proc.exited, timeoutPromise]),
@@ -28104,11 +28344,11 @@ function normalizeHistoryTestFile(testFile, workingDir) {
   const normalized = testFile.replace(/\\/g, "/");
   if (!path53.isAbsolute(testFile))
     return normalized;
-  const relative6 = path53.relative(workingDir, testFile);
-  if (relative6.startsWith("..") || path53.isAbsolute(relative6)) {
+  const relative7 = path53.relative(workingDir, testFile);
+  if (relative7.startsWith("..") || path53.isAbsolute(relative7)) {
     return normalized;
   }
-  return relative6.replace(/\\/g, "/");
+  return relative7.replace(/\\/g, "/");
 }
 function combineAggregateResult(current, next) {
   if (current === "fail" || next === "fail")
@@ -28653,9 +28893,9 @@ function getVersionFileVersion(dir) {
 async function runVersionCheck(dir, _timeoutMs) {
   const startTime = Date.now();
   try {
-    const packageVersion = _internals42.getPackageVersion(dir);
-    const changelogVersion = _internals42.getChangelogVersion(dir);
-    const versionFileVersion = _internals42.getVersionFileVersion(dir);
+    const packageVersion = _internals43.getPackageVersion(dir);
+    const changelogVersion = _internals43.getChangelogVersion(dir);
+    const versionFileVersion = _internals43.getVersionFileVersion(dir);
     const versions = [];
     if (packageVersion)
       versions.push(`package.json: ${packageVersion}`);
@@ -29019,7 +29259,7 @@ async function runPreflight(dir, phase, config) {
   const reportId = `preflight-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   let validatedDir;
   try {
-    validatedDir = _internals42.validateDirectoryPath(dir);
+    validatedDir = _internals43.validateDirectoryPath(dir);
   } catch (error2) {
     return {
       id: reportId,
@@ -29039,7 +29279,7 @@ async function runPreflight(dir, phase, config) {
   }
   let validatedTimeout;
   try {
-    validatedTimeout = _internals42.validateTimeout(config?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
+    validatedTimeout = _internals43.validateTimeout(config?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
   } catch (error2) {
     return {
       id: reportId,
@@ -29080,12 +29320,12 @@ async function runPreflight(dir, phase, config) {
   });
   const checks = [];
   log("[Preflight] Running lint check...");
-  const lintResult = await _internals42.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
+  const lintResult = await _internals43.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 _internals42.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
+    const testsResult = await _internals43.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
     checks.push(testsResult);
     log(`[Preflight] Tests check: ${testsResult.status} ${testsResult.message}`);
   } else {
@@ -29097,7 +29337,7 @@ async function runPreflight(dir, phase, config) {
   }
   if (!cfg.skipSecrets) {
     log("[Preflight] Running secrets check...");
-    const secretsResult = await _internals42.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
+    const secretsResult = await _internals43.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
     checks.push(secretsResult);
     log(`[Preflight] Secrets check: ${secretsResult.status} ${secretsResult.message}`);
   } else {
@@ -29109,7 +29349,7 @@ async function runPreflight(dir, phase, config) {
   }
   if (!cfg.skipEvidence) {
     log("[Preflight] Running evidence check...");
-    const evidenceResult = await _internals42.runEvidenceCheck(validatedDir);
+    const evidenceResult = await _internals43.runEvidenceCheck(validatedDir);
     checks.push(evidenceResult);
     log(`[Preflight] Evidence check: ${evidenceResult.status} ${evidenceResult.message}`);
   } else {
@@ -29120,12 +29360,12 @@ async function runPreflight(dir, phase, config) {
     });
   }
   log("[Preflight] Running requirement coverage check...");
-  const reqCoverageResult = await _internals42.runRequirementCoverageCheck(validatedDir, phase);
+  const reqCoverageResult = await _internals43.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 _internals42.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
+    const versionResult = await _internals43.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
     checks.push(versionResult);
     log(`[Preflight] Version check: ${versionResult.status} ${versionResult.message}`);
   } else {
@@ -29188,10 +29428,10 @@ function formatPreflightMarkdown(report) {
 async function handlePreflightCommand(directory, _args) {
   const plan = await loadPlan(directory);
   const phase = plan?.current_phase ?? 1;
-  const report = await _internals42.runPreflight(directory, phase);
-  return _internals42.formatPreflightMarkdown(report);
+  const report = await _internals43.runPreflight(directory, phase);
+  return _internals43.formatPreflightMarkdown(report);
 }
-var _internals42 = {
+var _internals43 = {
   runPreflight,
   formatPreflightMarkdown,
   handlePreflightCommand,
@@ -29427,13 +29667,13 @@ class CircuitBreaker {
     if (this.config.callTimeoutMs <= 0) {
       return fn();
     }
-    return new Promise((resolve17, reject) => {
+    return new Promise((resolve18, reject) => {
       const timeout = setTimeout(() => {
         reject(new Error(`Call timeout after ${this.config.callTimeoutMs}ms`));
       }, this.config.callTimeoutMs);
       fn().then((result) => {
         clearTimeout(timeout);
-        resolve17(result);
+        resolve18(result);
       }).catch((error2) => {
         clearTimeout(timeout);
         reject(error2);
@@ -29732,7 +29972,7 @@ class AutomationQueue {
 
 // src/background/worker.ts
 function sleep(ms) {
-  return new Promise((resolve17) => setTimeout(resolve17, ms));
+  return new Promise((resolve18) => setTimeout(resolve18, ms));
 }
 
 class WorkerManager {
@@ -30697,7 +30937,7 @@ async function recordReplayEntry(artifactPath, sessionID, entry) {
 }
 
 // src/prm/index.ts
-var _internals43 = {
+var _internals44 = {
   getAgentSession,
   readTrajectory,
   getInMemoryTrajectory,
@@ -30720,12 +30960,12 @@ function resetPrmSessionState(session, sessionId) {
   session.prmTrajectoryStep = 0;
   session.replayArtifactPath = null;
   if (sessionId) {
-    _internals43.clearTrajectoryCache(sessionId);
+    _internals44.clearTrajectoryCache(sessionId);
   }
 }
 
 // src/commands/reset-session.ts
-var _internals44 = {
+var _internals45 = {
   cleanupOrphanedBranches
 };
 function errorMessage(err) {
@@ -30791,7 +31031,7 @@ async function handleResetSessionCommand(directory, _args) {
     results.push(`\u26A0\uFE0F Failed to remove .swarm-worktrees/: ${errorMessage(err)}`);
   }
   try {
-    const branchResult = await _internals44.cleanupOrphanedBranches(directory, []);
+    const branchResult = await _internals45.cleanupOrphanedBranches(directory, []);
     if (branchResult.removed.length > 0) {
       results.push(`\u2705 Removed ${branchResult.removed.length} orphan swarm-lane branch(es)`);
     }
@@ -31128,7 +31368,7 @@ async function handleRollbackCommand(directory, args) {
 // src/commands/sdd.ts
 import * as fs29 from "fs";
 import * as path61 from "path";
-var _internals45 = {
+var _internals46 = {
   writeProjectedSpecSync
 };
 var SWARM_SPEC_REL = path61.join(".swarm", "spec.md");
@@ -31524,7 +31764,7 @@ ${USAGE9}`;
 
 ${USAGE9}`;
     }
-    const result2 = _internals45.writeProjectedSpecSync(directory, {
+    const result2 = _internals46.writeProjectedSpecSync(directory, {
       source: "speckit",
       feature: resolution.feature,
       dryRun: parsed.dryRun,
@@ -31582,7 +31822,7 @@ ${formatList(result2.projection.warnings)}` : ""
     ].join(`
 `);
   }
-  const result = _internals45.writeProjectedSpecSync(directory, {
+  const result = _internals46.writeProjectedSpecSync(directory, {
     changeId: parsed.changeId,
     dryRun: parsed.dryRun,
     overwrite: parsed.overwrite
@@ -31663,7 +31903,7 @@ async function handleSimulateCommand(directory, args) {
   }
   let darkMatterPairs;
   try {
-    darkMatterPairs = await _internals20.detectDarkMatter(directory, options);
+    darkMatterPairs = await _internals21.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Simulate Report
@@ -31968,7 +32208,7 @@ var DEFAULT_CONTEXT_BUDGET_CONFIG = {
 };
 
 // src/services/status-service.ts
-var _internals46 = {
+var _internals47 = {
   loadLeanTurboRunState,
   hasActiveLeanTurbo,
   hasActiveFullAuto
@@ -32073,7 +32313,7 @@ async function getStatusData(directory, agents) {
 }
 function enrichWithLeanTurbo(status, directory) {
   const turboMode = hasActiveTurboMode();
-  const leanActive = _internals46.hasActiveLeanTurbo();
+  const leanActive = _internals47.hasActiveLeanTurbo();
   let turboStrategy = "off";
   if (leanActive) {
     turboStrategy = "lean";
@@ -32092,7 +32332,7 @@ function enrichWithLeanTurbo(status, directory) {
     }
   }
   if (leanSessionID) {
-    const runState = _internals46.loadLeanTurboRunState(directory, leanSessionID);
+    const runState = _internals47.loadLeanTurboRunState(directory, leanSessionID);
     if (runState) {
       status.leanTurboPhase = runState.phase;
       status.leanMaxParallelCoders = runState.maxParallelCoders;
@@ -32124,7 +32364,7 @@ function enrichWithLeanTurbo(status, directory) {
       }
     }
   }
-  status.fullAutoActive = _internals46.hasActiveFullAuto();
+  status.fullAutoActive = _internals47.hasActiveFullAuto();
   return status;
 }
 function formatStatusMarkdown(status) {
@@ -32278,7 +32518,7 @@ No active swarm plan found. Nothing to sync.`;
 
 // src/commands/turbo.ts
 init_logger();
-var _internals47 = {
+var _internals48 = {
   loadPluginConfigWithMeta
 };
 async function handleTurboCommand(directory, args, sessionID) {
@@ -32338,7 +32578,7 @@ async function handleTurboCommand(directory, args, sessionID) {
   if (arg0 === "on") {
     let strategy = "standard";
     try {
-      const { config } = _internals47.loadPluginConfigWithMeta(directory);
+      const { config } = _internals48.loadPluginConfigWithMeta(directory);
       if (config.turbo?.strategy === "lean") {
         strategy = "lean";
       }
@@ -32435,7 +32675,7 @@ function enableLeanTurbo(session, directory, sessionID) {
   let maxParallelCoders = 4;
   let conflictPolicy = "serialize";
   try {
-    const { config } = _internals47.loadPluginConfigWithMeta(directory);
+    const { config } = _internals48.loadPluginConfigWithMeta(directory);
     const leanConfig = config.turbo?.lean;
     if (leanConfig) {
       maxParallelCoders = leanConfig.max_parallel_coders ?? 4;
@@ -32651,7 +32891,7 @@ function findSimilarCommands(query) {
   }
   const scored = VALID_COMMANDS.map((cmd) => {
     const cmdLower = cmd.toLowerCase();
-    const fullScore = _internals48.levenshteinDistance(q, cmdLower);
+    const fullScore = _internals49.levenshteinDistance(q, cmdLower);
     let tokenScore = Infinity;
     if (cmd.includes(" ") || cmd.includes("-")) {
       const qTokens = q.split(/[\s-]+/);
@@ -32664,7 +32904,7 @@ function findSimilarCommands(query) {
         for (const ct of cmdTokens) {
           if (ct.length === 0)
             continue;
-          const dist = _internals48.levenshteinDistance(qt, ct);
+          const dist = _internals49.levenshteinDistance(qt, ct);
           if (dist < minDist)
             minDist = dist;
         }
@@ -32674,7 +32914,7 @@ function findSimilarCommands(query) {
     }
     const dashStrippedQ = q.replace(/-/g, "");
     const dashStrippedCmd = cmdLower.replace(/-/g, "");
-    const dashScore = _internals48.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
+    const dashScore = _internals49.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
     const score = Math.min(fullScore, tokenScore, dashScore);
     return { cmd, score };
   });
@@ -32709,16 +32949,16 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-hw4tcxs9.js");
+    const { buildHelpText } = await import("./index-5yzr9fk6.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
-  const resolved = _internals48.resolveCommand(tokens);
+  const resolved = _internals49.resolveCommand(tokens);
   if (resolved) {
-    return _internals48.buildDetailedHelp(resolved.key, resolved.entry);
+    return _internals49.buildDetailedHelp(resolved.key, resolved.entry);
   }
-  const similar = _internals48.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-hw4tcxs9.js");
+  const similar = _internals49.findSimilarCommands(targetCommand);
+  const { buildHelpText: fullHelp } = await import("./index-5yzr9fk6.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -32782,7 +33022,7 @@ var COMMAND_REGISTRY = {
     toolNoArgs: true
   },
   help: {
-    handler: (ctx) => _internals48.handleHelpCommand(ctx),
+    handler: (ctx) => _internals49.handleHelpCommand(ctx),
     description: "Show help for swarm commands",
     category: "core",
     args: "[command]",
@@ -32851,7 +33091,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-kabd97j8.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-wpv5eskq.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -32861,7 +33101,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-kabd97j8.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-wpv5eskq.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -33695,7 +33935,7 @@ function validateToolPolicy() {
   }
   return { valid: warnings.length === 0, warnings };
 }
-var _internals48 = {
+var _internals49 = {
   handleHelpCommand,
   validateAliases,
   validateToolPolicy,
@@ -33705,16 +33945,16 @@ var _internals48 = {
   findSimilarCommands,
   buildDetailedHelp
 };
-var validation = _internals48.validateAliases();
+var validation = _internals49.validateAliases();
 if (!validation.valid) {
   throw new Error(`COMMAND_REGISTRY alias validation failed:
 ${validation.errors.join(`
 `)}`);
 }
-_internals48.emitValidationWarnings("COMMAND_REGISTRY alias warnings", validation.warnings);
+_internals49.emitValidationWarnings("COMMAND_REGISTRY alias warnings", validation.warnings);
 try {
-  const toolPolicyValidation = _internals48.validateToolPolicy();
-  _internals48.emitValidationWarnings("COMMAND_REGISTRY toolPolicy warnings", toolPolicyValidation.warnings);
+  const toolPolicyValidation = _internals49.validateToolPolicy();
+  _internals49.emitValidationWarnings("COMMAND_REGISTRY toolPolicy warnings", toolPolicyValidation.warnings);
 } catch (e) {
   warn(`COMMAND_REGISTRY toolPolicy validation failed (non-fatal): ${e.message}`);
 }
@@ -36397,7 +36637,7 @@ function formatCommandNotFound(tokens) {
   const attemptedCommand = tokens[0] || "";
   const MAX_DISPLAY = 100;
   const displayCommand = attemptedCommand.length > MAX_DISPLAY ? `${attemptedCommand.slice(0, MAX_DISPLAY)}...` : attemptedCommand;
-  const similar = _internals48.findSimilarCommands(attemptedCommand);
+  const similar = _internals49.findSimilarCommands(attemptedCommand);
   const header = `Command \`/swarm ${displayCommand}\` not found.`;
   const suggestions = similar.length > 0 ? `Did you mean:
 ${similar.map((cmd) => `  - /swarm ${cmd}`).join(`
@@ -38070,11 +38310,11 @@ function markSuggested(sessionId) {
   _suggestedSessions.add(sessionId);
 }
 function countWorktrees(directory) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     try {
       const child = execFile3("git", ["-C", directory, "worktree", "list", "--porcelain"], { timeout: GIT_TIMEOUT_MS3, windowsHide: true, encoding: "utf-8" }, (err, stdout) => {
         if (err || typeof stdout !== "string") {
-          resolve20(0);
+          resolve21(0);
           return;
         }
         let count = 0;
@@ -38083,14 +38323,14 @@ function countWorktrees(directory) {
           if (line.startsWith("worktree "))
             count++;
         }
-        resolve20(count);
+        resolve21(count);
       });
       try {
         child.stdin?.end();
       } catch {}
-      child.on("error", () => resolve20(0));
+      child.on("error", () => resolve21(0));
     } catch {
-      resolve20(0);
+      resolve21(0);
     }
   });
 }
@@ -38314,10 +38554,10 @@ function startAgentSession(sessionId, agentName, staleDurationMs = STALE_SESSION
   }
   telemetry.sessionStarted(sessionId, agentName);
   swarmState.activeAgent.set(sessionId, agentName);
-  _internals51.applyRehydrationCache(sessionState);
+  _internals52.applyRehydrationCache(sessionState);
   if (directory) {
     let rehydrationPromise;
-    rehydrationPromise = _internals51.rehydrateSessionFromDisk(directory, sessionState).then(async () => {
+    rehydrationPromise = _internals52.rehydrateSessionFromDisk(directory, sessionState).then(async () => {
       try {
         sessionState.prSubscriptions = await rehydratePrSubscriptions(sessionId, directory);
       } catch (err) {
@@ -38498,7 +38738,7 @@ function ensureAgentSession(sessionId, agentName, directory) {
     maybeSweepStaleSessions();
     return session;
   }
-  _internals51.startAgentSession(sessionId, agentName ?? "unknown", 7200000, directory);
+  _internals52.startAgentSession(sessionId, agentName ?? "unknown", 7200000, directory);
   session = swarmState.agentSessions.get(sessionId);
   if (!session) {
     throw new Error(`Failed to create guardrail session for ${sessionId}`);
@@ -38786,8 +39026,8 @@ function applyRehydrationCache(session) {
   }
 }
 async function rehydrateSessionFromDisk(directory, session) {
-  await _internals51.buildRehydrationCache(directory);
-  _internals51.applyRehydrationCache(session);
+  await _internals52.buildRehydrationCache(directory);
+  _internals52.applyRehydrationCache(session);
 }
 function hasActiveTurboMode(sessionID) {
   if (sessionID) {
@@ -38861,7 +39101,7 @@ async function rehydratePrSubscriptions(sessionID, directory) {
   }
   return map;
 }
-var _internals51 = {
+var _internals52 = {
   swarmState,
   resetSwarmState,
   ensureAgentSession,
@@ -39000,4 +39240,4 @@ function createCuratorLLMDelegate(directory, mode = "init", sessionId) {
   };
 }
 
-export { package_default, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleArchiveCommand, DC_SAFE_TARGETS, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcValidateTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleCiSimulateCommand, handleClarifyCommand, createCuratorLLMDelegate, _internals11 as _internals, normalizeRecommendationEntryIdToken, parseKnowledgeRecommendations, parseKnowledgeRecommendationsWithDiagnostics, parseStructuredCuratorBlocks, readCuratorSummary, writeCuratorSummary, filterPhaseEvents, checkPhaseCompliance, runCuratorInit, runCuratorPhase, applyCuratorKnowledgeUpdates, isHiveEligible, checkHivePromotions, createHivePromoterHook, promoteToHive, promoteFromSwarm, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCostsCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleHandoffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryValueLogCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals48 as _internals1, resolveCommand };
+export { package_default, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleArchiveCommand, DC_SAFE_TARGETS, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcValidateTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleCiSimulateCommand, handleClarifyCommand, createCuratorLLMDelegate, _internals11 as _internals, normalizeRecommendationEntryIdToken, parseKnowledgeRecommendations, parseKnowledgeRecommendationsWithDiagnostics, parseStructuredCuratorBlocks, readCuratorSummary, writeCuratorSummary, appendCuratorRecommendation, mergeCuratorPhaseSummary, filterPhaseEvents, checkPhaseCompliance, runCuratorInit, runCuratorPhase, applyCuratorKnowledgeUpdates, isHiveEligible, checkHivePromotions, _internals13 as _internals1, createHivePromoterHook, promoteToHive, promoteFromSwarm, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCostsCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleHandoffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryValueLogCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals49 as _internals2, resolveCommand };