opencode-swarm 7.74.0 → 7.74.2

package/dist/cli/index.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.74.0",
+    version: "7.74.2",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -17572,7 +17572,7 @@ var init_tool_metadata = __esm(() => {
       agents: ["architect", "coder"]
     },
     knowledge_archive: {
-      description: "archive (default), quarantine, or purge a swarm knowledge entry by ID with an immutable audit tombstone; purge requires an admin flag",
+      description: "archive (default), quarantine, or purge a swarm or hive knowledge entry by ID with an immutable audit tombstone; purge requires an admin flag",
       agents: ["architect"]
     },
     swarm_memory_recall: {
@@ -18588,7 +18588,11 @@ var init_schema = __esm(() => {
       cold_start_max_age_phases: exports_external.number().int().min(0).max(100).default(3),
       synonym_min_cooccurrence: exports_external.number().int().min(1).max(100).default(3),
       synonym_map_max_pairs: exports_external.number().int().min(1).max(1e4).default(500)
-    }).optional()
+    }).optional(),
+    enrichment: exports_external.object({
+      max_calls_per_day: exports_external.number().int().min(0).max(1000).default(30),
+      quota_window: exports_external.enum(["utc", "local"]).default("utc")
+    }).default({ max_calls_per_day: 30, quota_window: "utc" })
   });
   MemoryConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(false),
@@ -18655,7 +18659,7 @@ var init_schema = __esm(() => {
     llm_timeout_ms: exports_external.number().int().min(5000).max(600000).default(300000),
     skill_generation_enabled: exports_external.boolean().default(true),
     skill_generation_mode: exports_external.enum(["draft", "active"]).default("draft"),
-    min_skill_confidence: exports_external.number().min(0).max(1).default(0.85),
+    min_skill_confidence: exports_external.number().min(0).max(1).default(0.7),
     min_skill_confirmations: exports_external.number().int().min(1).max(50).default(2)
   });
   ArchitecturalSupervisionConfigSchema = exports_external.object({
@@ -37561,34 +37565,56 @@ var init_event_bus = __esm(() => {
   init_utils();
 });
 
+// src/evidence/task-file.ts
+import { renameSync as renameSync6, unlinkSync as unlinkSync4 } from "fs";
+import * as path12 from "path";
+function taskEvidenceRelPath(taskId) {
+  return path12.join("evidence", `${taskId}.json`);
+}
+function taskEvidencePath(directory, taskId) {
+  return path12.join(directory, ".swarm", taskEvidenceRelPath(taskId));
+}
+async function atomicWriteFile(targetPath, content) {
+  const tempPath = `${targetPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
+  try {
+    await bunWrite(tempPath, content);
+    _internals14.renameSync(tempPath, targetPath);
+  } finally {
+    try {
+      _internals14.unlinkSync(tempPath);
+    } catch {}
+  }
+}
+var _internals14;
+var init_task_file = __esm(() => {
+  init_bun_compat();
+  init_lock();
+  _internals14 = {
+    renameSync: renameSync6,
+    unlinkSync: unlinkSync4
+  };
+});
+
 // src/hooks/knowledge-events.ts
 import { existsSync as existsSync9 } from "fs";
-import { appendFile as appendFile2, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
-import * as path12 from "path";
+import { appendFile as appendFile2, mkdir as mkdir2, readFile as readFile2, stat as stat2 } from "fs/promises";
+import * as path13 from "path";
 function resolveKnowledgeEventsPath(directory) {
-  return path12.join(directory, ".swarm", "knowledge-events.jsonl");
+  return path13.join(directory, ".swarm", "knowledge-events.jsonl");
+}
+function resolveKnowledgeCounterBaselinePath(directory) {
+  return path13.join(directory, ".swarm", "knowledge-counter-baseline.json");
 }
 function resolveLegacyApplicationLogPath(directory) {
-  return path12.join(directory, ".swarm", "knowledge-application.jsonl");
+  return path13.join(directory, ".swarm", "knowledge-application.jsonl");
 }
 async function readKnowledgeEvents(directory) {
   const filePath = resolveKnowledgeEventsPath(directory);
   if (!existsSync9(filePath))
     return [];
   const content = await readFile2(filePath, "utf-8");
-  const out = [];
-  for (const line of content.split(`
-`)) {
-    const trimmed = line.trim();
-    if (!trimmed)
-      continue;
-    try {
-      out.push(JSON.parse(trimmed));
-    } catch {
-      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
-    }
-  }
-  return out;
+  return parseEventLines(content.split(`
+`), filePath);
 }
 async function readLegacyApplicationRecords(directory) {
   const filePath = resolveLegacyApplicationLogPath(directory);
@@ -37624,6 +37650,29 @@ function emptyRollup() {
     violation_timestamps: []
   };
 }
+function cloneRollup(input) {
+  return {
+    ...emptyRollup(),
+    ...input,
+    violation_timestamps: [...input.violation_timestamps ?? []]
+  };
+}
+function cloneRollupMap(input) {
+  const out = new Map;
+  for (const [id, rollup] of input) {
+    out.set(id, cloneRollup(rollup));
+  }
+  return out;
+}
+function normalizeRollupTimestamps(rollup) {
+  if (rollup.violation_timestamps.length > 1) {
+    rollup.violation_timestamps.sort((a, b) => a < b ? 1 : a > b ? -1 : 0);
+  }
+  if (rollup.violation_timestamps.length > MAX_VIOLATION_TIMESTAMPS) {
+    rollup.violation_timestamps = rollup.violation_timestamps.slice(0, MAX_VIOLATION_TIMESTAMPS);
+  }
+  return rollup;
+}
 function get(map3, id) {
   let r = map3.get(id);
   if (!r) {
@@ -37637,9 +37686,72 @@ function maxIso(current, candidate) {
     return candidate;
   return candidate > current ? candidate : current;
 }
-function recomputeCounters(events, legacyRecords = []) {
+async function readCounterBaseline(directory) {
+  const filePath = resolveKnowledgeCounterBaselinePath(directory);
+  if (!existsSync9(filePath))
+    return new Map;
+  const raw = JSON.parse(await readFile2(filePath, "utf-8"));
+  const map3 = new Map;
+  for (const [id, rollup] of Object.entries(raw)) {
+    map3.set(id, normalizeRollupTimestamps(cloneRollup(rollup)));
+  }
+  return map3;
+}
+async function statCacheKey(filePath) {
+  try {
+    const fileStat = await stat2(filePath);
+    return `${fileStat.mtimeMs}:${fileStat.ctimeMs}:${fileStat.size}`;
+  } catch (err) {
+    if (err?.code === "ENOENT")
+      return "missing";
+    throw err;
+  }
+}
+async function buildCounterRollupCacheKey(directory) {
+  const [eventsKey, legacyKey, baselineKey] = await Promise.all([
+    statCacheKey(resolveKnowledgeEventsPath(directory)),
+    statCacheKey(resolveLegacyApplicationLogPath(directory)),
+    statCacheKey(resolveKnowledgeCounterBaselinePath(directory))
+  ]);
+  return `${eventsKey}|${legacyKey}|${baselineKey}`;
+}
+function setCounterRollupCache(directory, key, rollups) {
+  if (counterRollupCache.has(directory)) {
+    counterRollupCache.delete(directory);
+  }
+  counterRollupCache.set(directory, {
+    key,
+    rollups: cloneRollupMap(rollups)
+  });
+  while (counterRollupCache.size > MAX_COUNTER_ROLLUP_CACHE_DIRS) {
+    const oldestKey = counterRollupCache.keys().next().value;
+    if (oldestKey === undefined)
+      break;
+    counterRollupCache.delete(oldestKey);
+  }
+}
+function parseEventLines(lines, filePath) {
+  const out = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
+    }
+  }
+  return out;
+}
+function recomputeCounters(events, legacyRecords = [], baseline = new Map) {
   const map3 = new Map;
   const retrievedIds = new Set;
+  for (const [id, rollup] of baseline) {
+    map3.set(id, cloneRollup(rollup));
+    if ((rollup.shown_count ?? 0) > 0)
+      retrievedIds.add(id);
+  }
   for (const e of events) {
     switch (e.type) {
       case "retrieved": {
@@ -37715,22 +37827,27 @@ function recomputeCounters(events, legacyRecords = []) {
     }
   }
   for (const r of map3.values()) {
-    if (r.violation_timestamps.length > 1) {
-      r.violation_timestamps.sort((a, b) => a < b ? 1 : a > b ? -1 : 0);
-    }
-    if (r.violation_timestamps.length > MAX_VIOLATION_TIMESTAMPS) {
-      r.violation_timestamps = r.violation_timestamps.slice(0, MAX_VIOLATION_TIMESTAMPS);
-    }
+    normalizeRollupTimestamps(r);
   }
   return map3;
 }
 async function readKnowledgeCounterRollups(directory) {
   try {
-    const [events, legacyRecords] = await Promise.all([
+    const cacheKey = await buildCounterRollupCacheKey(directory);
+    const cached3 = counterRollupCache.get(directory);
+    if (cached3?.key === cacheKey) {
+      counterRollupCache.delete(directory);
+      counterRollupCache.set(directory, cached3);
+      return cloneRollupMap(cached3.rollups);
+    }
+    const [events, legacyRecords, baseline] = await Promise.all([
       readKnowledgeEvents(directory),
-      readLegacyApplicationRecords(directory)
+      readLegacyApplicationRecords(directory),
+      readCounterBaseline(directory)
     ]);
-    return recomputeCounters(events, legacyRecords);
+    const rollups = recomputeCounters(events, legacyRecords, baseline);
+    setCounterRollupCache(directory, cacheKey, rollups);
+    return cloneRollupMap(rollups);
   } catch (err) {
     warn(`[knowledge-events] readKnowledgeCounterRollups failed: ${err instanceof Error ? err.message : String(err)}`);
     return new Map;
@@ -37749,10 +37866,12 @@ function effectiveRetrievalOutcomes(stored, rollup) {
     ...rollup
   };
 }
-var import_proper_lockfile3, RECEIPT_EVENT_TYPES, MAX_VIOLATION_TIMESTAMPS = 10;
+var import_proper_lockfile3, counterRollupCache, MAX_COUNTER_ROLLUP_CACHE_DIRS = 32, RECEIPT_EVENT_TYPES, MAX_VIOLATION_TIMESTAMPS = 10;
 var init_knowledge_events = __esm(() => {
+  init_task_file();
   init_logger();
   import_proper_lockfile3 = __toESM(require_proper_lockfile(), 1);
+  counterRollupCache = new Map;
   RECEIPT_EVENT_TYPES = new Set([
     "acknowledged",
     "applied",
@@ -37764,36 +37883,6 @@ var init_knowledge_events = __esm(() => {
   ]);
 });
 
-// src/evidence/task-file.ts
-import { renameSync as renameSync6, unlinkSync as unlinkSync4 } from "fs";
-import * as path13 from "path";
-function taskEvidenceRelPath(taskId) {
-  return path13.join("evidence", `${taskId}.json`);
-}
-function taskEvidencePath(directory, taskId) {
-  return path13.join(directory, ".swarm", taskEvidenceRelPath(taskId));
-}
-async function atomicWriteFile(targetPath, content) {
-  const tempPath = `${targetPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
-  try {
-    await bunWrite(tempPath, content);
-    _internals14.renameSync(tempPath, targetPath);
-  } finally {
-    try {
-      _internals14.unlinkSync(tempPath);
-    } catch {}
-  }
-}
-var _internals14;
-var init_task_file = __esm(() => {
-  init_bun_compat();
-  init_lock();
-  _internals14 = {
-    renameSync: renameSync6,
-    unlinkSync: unlinkSync4
-  };
-});
-
 // src/hooks/knowledge-store.ts
 import { existsSync as existsSync10 } from "fs";
 import { appendFile as appendFile3, mkdir as mkdir3, readFile as readFile3 } from "fs/promises";
@@ -37998,9 +38087,46 @@ async function enforceKnowledgeCap(filePath, maxEntries) {
   await transactKnowledge(filePath, (entries) => {
     if (entries.length <= maxEntries)
       return null;
-    return entries.slice(entries.length - maxEntries);
+    return selectKnowledgeCapSurvivors(entries, maxEntries);
   });
 }
+function selectKnowledgeCapSurvivors(entries, maxEntries) {
+  if (entries.length <= maxEntries)
+    return entries;
+  if (maxEntries <= 0)
+    return [];
+  const candidates = entries.map((entry, index) => {
+    const maybeKnowledge = entry;
+    return {
+      entry,
+      index,
+      status: maybeKnowledge.status,
+      outcomeSignal: computeOutcomeSignal(maybeKnowledge.retrieval_outcomes)
+    };
+  });
+  const allPromoted = candidates.every((c) => c.status === "promoted");
+  const evictable = allPromoted ? candidates : candidates.filter((c) => c.status !== "promoted");
+  const targetDropCount = entries.length - maxEntries;
+  const dropCount = Math.min(targetDropCount, evictable.length);
+  if (dropCount <= 0)
+    return entries;
+  const drop = new Set([...evictable].sort((a, b) => {
+    const inactiveDelta = getKnowledgeCapStatusPriority(a.status) - getKnowledgeCapStatusPriority(b.status);
+    if (inactiveDelta !== 0)
+      return inactiveDelta;
+    const signalDelta = a.outcomeSignal - b.outcomeSignal;
+    if (signalDelta !== 0)
+      return signalDelta;
+    return a.index - b.index;
+  }).slice(0, dropCount).map((c) => c.index));
+  return candidates.filter((c) => !drop.has(c.index)).map((c) => c.entry);
+}
+function getKnowledgeCapStatusPriority(status) {
+  if (status === "archived" || status === "quarantined" || status === "quarantined_unactionable") {
+    return 0;
+  }
+  return 1;
+}
 async function appendRejectedLesson(directory, lesson, maxEntries = 20) {
   const filePath = resolveSwarmRejectedPath(directory);
   await transactKnowledge(filePath, (existing) => {
@@ -38661,7 +38787,7 @@ function validateLesson(candidate, existingLessons, meta3) {
     };
   }
   const normalizedCandidate = candidate.normalize("NFKC").replace(INVISIBLE_FORMAT_CHARS, " ").replace(/\s+/g, " ").toLowerCase();
-  for (const pattern of DANGEROUS_COMMAND_PATTERNS) {
+  for (const pattern of DANGEROUS_COMMAND_ERROR_PATTERNS) {
     if (pattern.test(normalizedCandidate)) {
       return {
         valid: false,
@@ -38671,6 +38797,16 @@ function validateLesson(candidate, existingLessons, meta3) {
       };
     }
   }
+  for (const pattern of DANGEROUS_COMMAND_WARNING_PATTERNS) {
+    if (pattern.test(normalizedCandidate)) {
+      return {
+        valid: true,
+        layer: 2,
+        reason: "potentially dangerous command pattern queued for review",
+        severity: "warning"
+      };
+    }
+  }
   for (const pattern of SECURITY_DEGRADING_PATTERNS) {
     if (pattern.test(normalizedCandidate)) {
       return {
@@ -38693,10 +38829,10 @@ function validateLesson(candidate, existingLessons, meta3) {
   }
   if (detectContradiction(candidate, existingLessons)) {
     return {
-      valid: false,
+      valid: true,
       layer: 3,
-      reason: "lesson contradicts an existing lesson with shared tags",
-      severity: "error"
+      reason: "possible contradiction with an existing lesson with shared tags",
+      severity: "warning"
     };
   }
   if (isVagueLesson(candidate)) {
@@ -38836,31 +38972,22 @@ async function appendUnactionable(directory, entry, reason) {
   const filePath = resolveUnactionablePath(directory);
   const dirPath = path15.dirname(filePath);
   await mkdir4(dirPath, { recursive: true });
-  let release = null;
-  try {
-    release = await import_proper_lockfile5.default.lock(dirPath, {
-      retries: { retries: 50, minTimeout: 10, maxTimeout: 100 },
-      stale: 5000
-    });
+  await transactKnowledge(filePath, (existing) => {
     const record3 = {
       ...entry,
       status: "quarantined_unactionable",
       unactionable_reason: reason,
       quarantined_at: new Date().toISOString()
     };
-    await appendFile4(filePath, `${JSON.stringify(record3)}
-`, "utf-8");
-    const existing = await readKnowledge(filePath);
-    if (existing.length > 200) {
-      const trimmed = existing.slice(-200);
-      await atomicWriteFile(filePath, `${trimmed.map((e) => JSON.stringify(e)).join(`
-`)}
-`);
+    const duplicate = findNearDuplicate(record3.lesson, existing, 0.6);
+    if (duplicate?.unactionable_reason === reason) {
+      duplicate.quarantined_at = record3.quarantined_at;
+      duplicate.updated_at = record3.updated_at;
+      return existing;
     }
-  } finally {
-    if (release)
-      await release().catch(() => {});
-  }
+    const next = [...existing, record3];
+    return next.length > 200 ? next.slice(-200) : next;
+  });
 }
 async function quarantineEntry(directory, entryId, reason, reportedBy) {
   if (!directory || directory.includes("..")) {
@@ -38994,28 +39121,34 @@ async function restoreEntry(directory, entryId) {
     }
   }
 }
-var import_proper_lockfile5, DANGEROUS_COMMAND_PATTERNS, SECURITY_DEGRADING_PATTERNS, INVISIBLE_FORMAT_CHARS, INJECTION_PATTERNS, VALID_CATEGORIES, TECH_REFERENCE_WORDS, ACTION_VERB_WORDS, NEGATION_PAIRS, ACTIONABLE_STRING_MAX = 200, ACTIONABLE_LIST_MAX = 20, NAME_PATTERN, SOURCE_REF_FORBIDDEN, ALLOWED_SKILL_PATH_PREFIXES, VALID_DIRECTIVE_PRIORITIES;
+var import_proper_lockfile5, DANGEROUS_COMMAND_ERROR_PATTERNS, DANGEROUS_COMMAND_WARNING_PATTERNS, DANGEROUS_COMMAND_PATTERNS, SECURITY_DEGRADING_PATTERNS, INVISIBLE_FORMAT_CHARS, INJECTION_PATTERNS, VALID_CATEGORIES, TECH_REFERENCE_WORDS, ACTION_VERB_WORDS, NEGATION_PAIRS, ACTIONABLE_STRING_MAX = 200, ACTIONABLE_LIST_MAX = 20, NAME_PATTERN, SOURCE_REF_FORBIDDEN, ALLOWED_SKILL_PATH_PREFIXES, VALID_DIRECTIVE_PRIORITIES;
 var init_knowledge_validator = __esm(() => {
   init_task_file();
   init_logger();
   init_knowledge_store();
   import_proper_lockfile5 = __toESM(require_proper_lockfile(), 1);
-  DANGEROUS_COMMAND_PATTERNS = [
+  DANGEROUS_COMMAND_ERROR_PATTERNS = [
     /\brm\s+-rf\b/,
     /\bsudo\s+rm\b/,
-    /\bformat\b/,
     /\bmkfs\b/,
     /\bdd\s+if=/,
     /:\(\)\s*\{/,
     /\bchmod\s+-R\s+777\b/i,
     /\bdeltree\b/,
-    /\brmdir\s+\/s\b/,
+    /\brmdir\s+\/s\b/
+  ];
+  DANGEROUS_COMMAND_WARNING_PATTERNS = [
+    /\bformat\b/,
     /\bkill\s+-9\b/,
     /\bpkill\b/,
     /\bkillall\b/,
     /`[^`]*`/,
     /\$\([^)]*\)/
   ];
+  DANGEROUS_COMMAND_PATTERNS = [
+    ...DANGEROUS_COMMAND_ERROR_PATTERNS,
+    ...DANGEROUS_COMMAND_WARNING_PATTERNS
+  ];
   SECURITY_DEGRADING_PATTERNS = [
     /disable\s+.{0,50}firewall/i,
     /turn\s+off\s+.{0,50}security/i,
@@ -39117,7 +39250,7 @@ var init_knowledge_validator = __esm(() => {
 });
 
 // src/services/skill-changelog.ts
-import { appendFile as appendFile5, mkdir as mkdir5, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { appendFile as appendFile5, mkdir as mkdir5, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
 import * as path16 from "path";
 function resolveSkillChangelogPath(directory, slug) {
   if (slug.includes("..") || slug.includes("/") || slug.includes("\\")) {
@@ -39137,7 +39270,7 @@ async function appendSkillChangelog(directory, slug, entry) {
 `).filter((line) => line.trim().length > 0);
     if (lines.length > MAX_CHANGELOG_ENTRIES_PER_SKILL) {
       const trimmed = lines.slice(lines.length - MAX_CHANGELOG_ENTRIES_PER_SKILL);
-      await writeFile4(filePath, `${trimmed.join(`
+      await writeFile3(filePath, `${trimmed.join(`
 `)}
 `, "utf-8");
     }
@@ -39152,7 +39285,7 @@ var init_skill_changelog = __esm(() => {
 
 // src/services/skill-generator.ts
 import { existsSync as existsSync11, unlinkSync as unlinkSync5 } from "fs";
-import { mkdir as mkdir6, readFile as readFile5, rename as rename3, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile5, rename as rename3, writeFile as writeFile4 } from "fs/promises";
 import * as path17 from "path";
 function sanitizeSlug(input) {
   const lc = input.toLowerCase().trim();
@@ -39177,18 +39310,35 @@ async function selectCandidateEntries(directory, opts) {
   const hivePath = resolveHiveKnowledgePath();
   const hive = existsSync11(hivePath) ? await readKnowledge(hivePath) : [];
   const all = [...swarm, ...hive];
-  return all.filter((e) => {
+  const counterRollups = await readKnowledgeCounterRollups(directory);
+  const selected = [];
+  for (const e of all) {
     if (e.status === "archived")
-      return false;
-    if (e.confidence < opts.minConfidence)
-      return false;
-    const confirmations = (e.confirmed_by ?? []).length;
-    if (confirmations < opts.minConfirmations)
-      return false;
+      continue;
     if (e.generated_skill_slug)
-      return false;
-    return true;
-  });
+      continue;
+    const outcomes = effectiveRetrievalOutcomes(e.retrieval_outcomes, counterRollups.get(e.id));
+    if (!isSkillMaturityEligible(e, opts, outcomes))
+      continue;
+    selected.push({ ...e, retrieval_outcomes: outcomes });
+  }
+  return selected;
+}
+function hasStrongSkillOutcomeRecord(outcomes) {
+  return (outcomes?.applied_explicit_count ?? 0) >= STRONG_SKILL_OUTCOME_COUNT || (outcomes?.succeeded_after_shown_count ?? 0) >= STRONG_SKILL_OUTCOME_COUNT;
+}
+function isHighPriorityDirective(entry) {
+  return entry.directive_priority === "critical" || entry.directive_priority === "high";
+}
+function isSkillMaturityEligible(entry, opts, outcomes = entry.retrieval_outcomes) {
+  const outcomeSignal = computeOutcomeSignal(outcomes);
+  if (outcomeSignal < 0)
+    return false;
+  const strongOutcomes = hasStrongSkillOutcomeRecord(outcomes);
+  if (entry.confidence < opts.minConfidence && !strongOutcomes)
+    return false;
+  const confirmations = (entry.confirmed_by ?? []).length;
+  return confirmations >= opts.minConfirmations || strongOutcomes;
 }
 function jaccardSimilarity(setA, setB) {
   const normA = setA.map((s) => s.toLowerCase());
@@ -39228,8 +39378,9 @@ function clusterEntries(entries) {
   }
   const result = [];
   for (const c of clusters) {
-    if (c.members.length < MIN_CLUSTER_SIZE)
+    if (c.members.length < MIN_CLUSTER_SIZE && !isSkillSingletonEligible(c.members[0])) {
       continue;
+    }
     const arr = c.members;
     const triggers = uniqueStrings(arr.flatMap((e) => e.triggers ?? []));
     const required3 = uniqueStrings(arr.flatMap((e) => e.required_actions ?? []));
@@ -39255,6 +39406,11 @@ function clusterEntries(entries) {
   result.sort((a, b) => b.entries.length - a.entries.length || b.avgConfidence - a.avgConfidence || a.slug.localeCompare(b.slug));
   return result;
 }
+function isSkillSingletonEligible(entry) {
+  if (!entry)
+    return false;
+  return isHighPriorityDirective(entry) || hasStrongSkillOutcomeRecord(entry.retrieval_outcomes);
+}
 function uniqueStrings(arr) {
   return [...new Set(arr.filter((s) => typeof s === "string" && s.length > 0))];
 }
@@ -39355,12 +39511,12 @@ function escapeMarkdown(s) {
 async function atomicWrite(p, content) {
   await mkdir6(path17.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile5(tmp, content, "utf-8");
+  await writeFile4(tmp, content, "utf-8");
   await rename3(tmp, p);
 }
 async function generateSkills(req) {
-  const minConfidence = req.minConfidence ?? 0.85;
-  const minConfirmations = req.minConfirmations ?? 2;
+  const minConfidence = req.minConfidence ?? DEFAULT_SKILL_MIN_CONFIDENCE;
+  const minConfirmations = req.minConfirmations ?? DEFAULT_SKILL_MIN_CONFIRMATIONS;
   const candidates = await selectCandidateEntries(req.directory, {
     minConfidence,
     minConfirmations
@@ -39755,7 +39911,7 @@ async function retireSkill(directory, slug, reason) {
     reason: reason ?? "manual_retire"
   });
   await mkdir6(markerDir, { recursive: true });
-  await writeFile5(markerPath, markerContent, "utf-8");
+  await writeFile4(markerPath, markerContent, "utf-8");
   return {
     retired: true,
     path: skillPath,
@@ -39918,8 +40074,9 @@ async function regenerateSkill(directory, slug) {
     entryCount: matchedEntries.length
   };
 }
-var SLUG_PATTERN, MIN_CLUSTER_SIZE = 2, JACCARD_THRESHOLD = 0.5, AUTO_APPLY_BATCH_LIMIT = 5, _internals15;
+var SLUG_PATTERN, DEFAULT_SKILL_MIN_CONFIDENCE = 0.7, DEFAULT_SKILL_MIN_CONFIRMATIONS = 2, STRONG_SKILL_OUTCOME_COUNT = 3, MIN_CLUSTER_SIZE = 2, JACCARD_THRESHOLD = 0.5, AUTO_APPLY_BATCH_LIMIT = 5, _internals15;
 var init_skill_generator = __esm(() => {
+  init_knowledge_events();
   init_knowledge_store();
   init_knowledge_validator();
   init_logger();
@@ -39929,6 +40086,7 @@ var init_skill_generator = __esm(() => {
     sanitizeSlug,
     isValidSlug,
     selectCandidateEntries,
+    isSkillMaturityEligible,
     clusterEntries,
     jaccardSimilarity,
     renderSkillMarkdown,
@@ -39947,7 +40105,7 @@ var init_skill_generator = __esm(() => {
 
 // src/services/skill-improver-quota.ts
 import { existsSync as existsSync12 } from "fs";
-import { mkdir as mkdir7, readFile as readFile6, rename as rename4, writeFile as writeFile6 } from "fs/promises";
+import { mkdir as mkdir7, readFile as readFile6, rename as rename4, writeFile as writeFile5 } from "fs/promises";
 import * as path18 from "path";
 async function acquireLock(dir) {
   const acquire = import_proper_lockfile6.default.lock(dir, LOCK_RETRY_OPTS);
@@ -39965,8 +40123,9 @@ async function acquireLock(dir) {
       clearTimeout(timer);
   }
 }
-function resolveQuotaPath(directory) {
-  return path18.join(directory, ".swarm", "skill-improver-quota.json");
+function resolveQuotaPath(directory, scope = "skill-improver") {
+  const fileName = scope === "knowledge-enrichment" ? "knowledge-enrichment-quota.json" : "skill-improver-quota.json";
+  return path18.join(directory, ".swarm", fileName);
 }
 function todayKey(window, now = new Date) {
   if (window === "utc") {
@@ -39994,11 +40153,11 @@ async function readState(filePath) {
 async function writeState(filePath, state) {
   await mkdir7(path18.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}`;
-  await writeFile6(tmp, JSON.stringify(state, null, 2), "utf-8");
+  await writeFile5(tmp, JSON.stringify(state, null, 2), "utf-8");
   await rename4(tmp, filePath);
 }
 async function getQuotaState(directory, opts) {
-  const filePath = resolveQuotaPath(directory);
+  const filePath = resolveQuotaPath(directory, opts.scope);
   const today = todayKey(opts.window, opts.now);
   const existing = await readState(filePath);
   if (!existing || existing.date !== today || existing.window !== opts.window) {
@@ -40014,7 +40173,7 @@ async function getQuotaState(directory, opts) {
   return { ...existing, max_calls: opts.maxCalls };
 }
 async function reserveQuota(directory, opts) {
-  const filePath = resolveQuotaPath(directory);
+  const filePath = resolveQuotaPath(directory, opts.scope);
   await mkdir7(path18.dirname(filePath), { recursive: true });
   let release = null;
   try {
@@ -40044,7 +40203,7 @@ async function reserveQuota(directory, opts) {
   }
 }
 async function releaseQuota(directory, opts) {
-  const filePath = resolveQuotaPath(directory);
+  const filePath = resolveQuotaPath(directory, opts.scope);
   await mkdir7(path18.dirname(filePath), { recursive: true });
   let release = null;
   try {
@@ -40096,6 +40255,89 @@ function resolveLogPath(directory) {
 function normalizeComplianceVerdict(verdict) {
   return verdict === "violation" ? "violated" : verdict;
 }
+function normalizeSkillUsageEntry(raw) {
+  const entry = raw;
+  return {
+    ...entry,
+    complianceVerdict: normalizeComplianceVerdict(entry.complianceVerdict)
+  };
+}
+function legacySkillUsageId(entry) {
+  const stable = JSON.stringify({
+    skillPath: entry.skillPath,
+    agentName: entry.agentName,
+    taskID: entry.taskID,
+    timestamp: entry.timestamp,
+    complianceVerdict: entry.complianceVerdict,
+    sessionID: entry.sessionID,
+    skillVersion: entry.skillVersion
+  });
+  return `legacy:${crypto3.createHash("sha256").update(stable).digest("hex")}`;
+}
+function parseSkillUsageEntry(raw) {
+  const entry = raw;
+  if (entry.type === "feedback_applied")
+    return null;
+  if (typeof entry.skillPath !== "string" || typeof entry.agentName !== "string" || typeof entry.taskID !== "string" || typeof entry.timestamp !== "string" || typeof entry.complianceVerdict !== "string" || typeof entry.sessionID !== "string") {
+    return null;
+  }
+  return normalizeSkillUsageEntry({
+    ...entry,
+    id: typeof entry.id === "string" ? entry.id : legacySkillUsageId(entry)
+  });
+}
+function parseFeedbackMarker(raw) {
+  const marker = raw;
+  if (marker.type !== "feedback_applied")
+    return null;
+  if (typeof marker.timestamp !== "string")
+    return null;
+  if (!Array.isArray(marker.processedEntryIds))
+    return null;
+  const processedEntryIds = marker.processedEntryIds.filter((id) => typeof id === "string" && id.length > 0);
+  return {
+    type: "feedback_applied",
+    timestamp: marker.timestamp,
+    processedEntryIds
+  };
+}
+function readFeedbackAppliedEntryIds(directory) {
+  const resolved = resolveLogPath(directory);
+  const processed = new Set;
+  if (!_internals16.existsSync(resolved))
+    return processed;
+  const raw = _internals16.readFileSync(resolved, "utf-8");
+  for (const line of raw.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      const marker = parseFeedbackMarker(JSON.parse(trimmed));
+      if (!marker)
+        continue;
+      for (const id of marker.processedEntryIds)
+        processed.add(id);
+    } catch {}
+  }
+  return processed;
+}
+function appendFeedbackAppliedMarker(directory, processedEntryIds) {
+  if (processedEntryIds.length === 0)
+    return;
+  const resolved = resolveLogPath(directory);
+  const dir = path19.dirname(resolved);
+  if (!_internals16.existsSync(dir)) {
+    _internals16.mkdirSync(dir, { recursive: true });
+  }
+  const marker = {
+    type: "feedback_applied",
+    timestamp: new Date().toISOString(),
+    processedEntryIds: [...new Set(processedEntryIds)]
+  };
+  _internals16.appendFileSync(resolved, `${JSON.stringify(marker)}
+`, "utf-8");
+}
 function appendSkillUsageEntry(directory, entry) {
   const {
     skillPath,
@@ -40139,7 +40381,7 @@ function appendSkillUsageEntry(directory, entry) {
     agentName,
     taskID,
     timestamp,
-    complianceVerdict,
+    complianceVerdict: normalizeComplianceVerdict(complianceVerdict),
     sessionID,
     ...reviewerNotes !== undefined && { reviewerNotes },
     ...skillVersion !== undefined && { skillVersion }
@@ -40147,8 +40389,8 @@ function appendSkillUsageEntry(directory, entry) {
   _internals16.appendFileSync(resolved, `${JSON.stringify(fullEntry)}
 `, "utf-8");
   try {
-    const stat2 = _internals16.statSync(resolved);
-    if (stat2.size > SKILL_USAGE_LOG_ROTATE_BYTES) {
+    const stat3 = _internals16.statSync(resolved);
+    if (stat3.size > SKILL_USAGE_LOG_ROTATE_BYTES) {
       _internals16.pruneSkillUsageLog(directory, SKILL_USAGE_LOG_MAX_ENTRIES_PER_SKILL);
     }
   } catch {}
@@ -40166,9 +40408,9 @@ function readSkillUsageEntries(directory, options) {
     if (!trimmed)
       continue;
     try {
-      const entry = JSON.parse(trimmed);
-      entry.complianceVerdict = normalizeComplianceVerdict(entry.complianceVerdict);
-      entries.push(entry);
+      const entry = parseSkillUsageEntry(JSON.parse(trimmed));
+      if (entry)
+        entries.push(entry);
     } catch {}
   }
   if (!options)
@@ -40202,11 +40444,11 @@ function readSkillUsageEntriesTail(directory, filters, maxBytes = TAIL_BYTES_DEF
   try {
     const normalizedMaxBytes = Number.isFinite(maxBytes) ? maxBytes : TAIL_BYTES_DEFAULT;
     const boundedMaxBytes = Math.min(Math.max(1, normalizedMaxBytes), MAX_TAIL_BYTES);
-    const stat2 = _internals16.statSync(logPath);
-    const start = Math.max(0, stat2.size - boundedMaxBytes);
+    const stat3 = _internals16.statSync(logPath);
+    const start = Math.max(0, stat3.size - boundedMaxBytes);
     const fd = _internals16.openSync(logPath, "r");
     try {
-      const readLen = stat2.size - start;
+      const readLen = stat3.size - start;
       if (readLen === 0)
         return [];
       const buf = Buffer.alloc(readLen);
@@ -40226,8 +40468,9 @@ function readSkillUsageEntriesTail(directory, filters, maxBytes = TAIL_BYTES_DEF
         if (!line.trim())
           continue;
         try {
-          const entry = JSON.parse(line);
-          entry.complianceVerdict = normalizeComplianceVerdict(entry.complianceVerdict);
+          const entry = parseSkillUsageEntry(JSON.parse(line));
+          if (!entry)
+            continue;
           if (filters.sessionID !== undefined && entry.sessionID !== filters.sessionID) {
             continue;
           }
@@ -40262,8 +40505,9 @@ function computeComplianceByVersion(entries, skillPath) {
     stats.total += 1;
     if (e.complianceVerdict === "compliant")
       stats.compliant += 1;
-    if (e.complianceVerdict === "violated")
+    if (normalizeComplianceVerdict(e.complianceVerdict) === "violated") {
       stats.violation += 1;
+    }
   }
   for (const stats of map3.values()) {
     stats.rate = stats.total === 0 ? 0 : stats.compliant / stats.total;
@@ -40374,6 +40618,7 @@ async function applySkillUsageFeedback(directory, options) {
   let bumps = 0;
   try {
     const allEntries = readSkillUsageEntries(directory);
+    const alreadyProcessed = readFeedbackAppliedEntryIds(directory);
     const actionable = allEntries.filter((e) => {
       if (e.complianceVerdict !== "compliant" && e.complianceVerdict !== "violated") {
         return false;
@@ -40381,6 +40626,9 @@ async function applySkillUsageFeedback(directory, options) {
       if (options?.sinceTimestamp && e.timestamp <= options.sinceTimestamp) {
         return false;
       }
+      if (alreadyProcessed.has(e.id)) {
+        return false;
+      }
       return true;
     });
     if (actionable.length === 0) {
@@ -40395,6 +40643,7 @@ async function applySkillUsageFeedback(directory, options) {
         groups.set(entry.skillPath, [entry]);
     }
     const allDeltas = [];
+    const processedEntryIds = [];
     for (const [skillPath, entries] of Array.from(groups)) {
       let compliantCount = 0;
       let violationCount = 0;
@@ -40413,6 +40662,7 @@ async function applySkillUsageFeedback(directory, options) {
       for (const id of sourceIds) {
         allDeltas.push({ id, delta });
       }
+      processedEntryIds.push(...entries.map((entry) => entry.id));
       processed++;
       bumps += sourceIds.length;
     }
@@ -40426,6 +40676,7 @@ async function applySkillUsageFeedback(directory, options) {
     }));
     if (clampedDeltas.length > 0) {
       await bumpKnowledgeConfidenceBatch(directory, clampedDeltas);
+      appendFeedbackAppliedMarker(directory, processedEntryIds);
     }
   } catch (err) {
     console.warn("[skill-usage-log] applySkillUsageFeedback failed (fail-open):", err instanceof Error ? err.message : String(err));
@@ -40452,7 +40703,10 @@ var init_skill_usage_log = __esm(() => {
     resolveSourceKnowledgeIds,
     applySkillUsageFeedback,
     parseGeneratedFromKnowledge,
-    computeComplianceByVersion
+    computeComplianceByVersion,
+    normalizeComplianceVerdict,
+    readFeedbackAppliedEntryIds,
+    appendFeedbackAppliedMarker
   };
   TAIL_BYTES_DEFAULT = 64 * 1024;
   MAX_TAIL_BYTES = TAIL_BYTES_DEFAULT;
@@ -40502,6 +40756,9 @@ function isAlreadyInHive(entry, hiveEntries, threshold) {
   return findNearDuplicate(entry.lesson, hiveEntries, threshold) !== undefined;
 }
 function isHiveEligible(entry, autoPromoteDays) {
+  if (!isActiveForHivePromotion(entry)) {
+    return false;
+  }
   const phaseNumbers = new Set;
   for (const record3 of entry.confirmed_by ?? []) {
     if (record3 && typeof record3.phase_number === "number") {
@@ -40522,6 +40779,9 @@ function isHiveEligible(entry, autoPromoteDays) {
   }
   return false;
 }
+function isActiveForHivePromotion(entry) {
+  return !["archived", "quarantined", "quarantined_unactionable"].includes(entry.status);
+}
 function countDistinctProjects(confirmedBy) {
   const projectNames = new Set;
   for (const record3 of confirmedBy) {
@@ -40604,7 +40864,7 @@ async function checkHivePromotions(swarmEntries, config3) {
   }
   let hiveModified = false;
   for (const hiveEntry of hiveEntries) {
-    const nearDuplicate = findNearDuplicate(hiveEntry.lesson, swarmEntries, config3.dedup_threshold);
+    const nearDuplicate = findNearDuplicate(hiveEntry.lesson, swarmEntries.filter(isActiveForHivePromotion), config3.dedup_threshold);
     if (!nearDuplicate) {
       continue;
     }
@@ -40734,9 +40994,9 @@ import {
   mkdir as mkdir8,
   readFile as readFile7,
   rename as rename5,
-  stat as stat2,
+  stat as stat3,
   unlink as unlink2,
-  writeFile as writeFile7
+  writeFile as writeFile6
 } from "fs/promises";
 import * as path21 from "path";
 function emptySynonymMap() {
@@ -40877,7 +41137,7 @@ async function readSynonymMap(directory, maxPairs = DEFAULT_MAX_PAIRS) {
   }
   try {
     const ceiling = Math.max(MIN_READ_CEILING_BYTES, Math.floor(maxPairs) * APPROX_BYTES_PER_PAIR);
-    const st = await stat2(filePath);
+    const st = await stat3(filePath);
     if (st.size > ceiling)
       return emptySynonymMap();
     const raw = await readFile7(filePath, "utf-8");
@@ -40890,7 +41150,7 @@ async function writeSynonymMapAtomic(filePath, map3) {
   await mkdir8(path21.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   try {
-    await writeFile7(tmp, JSON.stringify(map3, null, 2), "utf-8");
+    await writeFile6(tmp, JSON.stringify(map3, null, 2), "utf-8");
     await rename5(tmp, filePath);
   } finally {
     try {
@@ -41099,12 +41359,12 @@ function extractKeywords(text) {
   const words = text.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length >= MIN_KEYWORD_LENGTH);
   return new Set(words);
 }
-function computeContextMatchScore(taskDescription, skillPath) {
+function computeContextMatchScore(taskDescription, skillPath, metadata) {
   const taskKeywords = extractKeywords(taskDescription);
   if (taskKeywords.size === 0)
     return 0;
   const skillName = extractSkillName(skillPath);
-  const skillText = `${skillPath} ${skillName}`;
+  const skillText = `${skillPath} ${skillName} ${metadata?.name ?? ""} ${metadata?.description ?? ""}`;
   const skillKeywords = extractKeywords(skillText);
   let matchCount = 0;
   for (const kw of taskKeywords) {
@@ -41115,7 +41375,7 @@ function computeContextMatchScore(taskDescription, skillPath) {
   return matchCount / taskKeywords.size;
 }
 function computeSkillRelevanceScore(skillPath, taskDescription, usageHistory, metadata) {
-  const contextScore = computeContextMatchScore(taskDescription, skillPath) * CONTEXT_WEIGHT;
+  const contextScore = computeContextMatchScore(taskDescription, skillPath, metadata) * CONTEXT_WEIGHT;
   if (usageHistory.length === 0)
     return Math.min(1, contextScore);
   const usageCount = usageHistory.length;
@@ -41190,8 +41450,8 @@ function formatSkillIndexWithContext(skills, directory) {
   const usageLogPath = path22.join(directory, ".swarm", "skill-usage.jsonl");
   let hasHistory = false;
   try {
-    const stat3 = fs10.statSync(usageLogPath);
-    hasHistory = stat3.size > 0;
+    const stat4 = fs10.statSync(usageLogPath);
+    hasHistory = stat4.size > 0;
   } catch {}
   if (!hasHistory) {
     return skills.map((sp) => {
@@ -41712,24 +41972,32 @@ async function skillPropagationTransformScan(directory, output, sessionID) {
     if (!text)
       continue;
     const skillPaths = [];
+    let explicitReviewerTaskID;
     for (const line of text.split(`
 `)) {
-      const coderMatch = line.trim().match(CODER_SKILLS_PATTERN);
+      const trimmed = line.trim();
+      const taskMatch = trimmed.match(REVIEWER_TASK_PATTERN);
+      if (taskMatch) {
+        explicitReviewerTaskID = taskMatch[1];
+      }
+      const coderMatch = trimmed.match(CODER_SKILLS_PATTERN);
       if (coderMatch) {
         const parsed = _internals18.parseSkillPaths(coderMatch[1]);
         skillPaths.push(...parsed);
       }
     }
-    let resolvedTaskID = "unknown";
+    let resolvedTaskID = explicitReviewerTaskID ?? "unknown";
     if (existingEntries.length > 0) {
-      const latestDelegation = [...existingEntries].reverse().find((e) => e.agentName !== "reviewer" && e.skillPath !== "__overall__");
-      if (latestDelegation) {
-        resolvedTaskID = latestDelegation.taskID;
-        if (skillPaths.length === 0) {
-          const delegatedPaths = existingEntries.filter((e) => e.agentName !== "reviewer" && e.skillPath !== "__overall__" && e.taskID === resolvedTaskID).map((e) => e.skillPath);
-          if (delegatedPaths.length > 0) {
-            skillPaths.push(...new Set(delegatedPaths));
-          }
+      if (!explicitReviewerTaskID) {
+        const latestDelegation = [...existingEntries].reverse().find((e) => e.agentName !== "reviewer" && e.skillPath !== "__overall__");
+        if (latestDelegation) {
+          resolvedTaskID = latestDelegation.taskID;
+        }
+      }
+      if (skillPaths.length === 0 && resolvedTaskID !== "unknown") {
+        const delegatedPaths = existingEntries.filter((e) => e.agentName !== "reviewer" && e.skillPath !== "__overall__" && e.taskID === resolvedTaskID).map((e) => e.skillPath);
+        if (delegatedPaths.length > 0) {
+          skillPaths.push(...new Set(delegatedPaths));
         }
       }
     }
@@ -41819,7 +42087,7 @@ async function skillPropagationTransformScan(directory, output, sessionID) {
     break;
   }
 }
-var SKILL_CAPABLE_AGENTS, SKILL_SEARCH_ROOTS, MAX_SCORING_SESSION_ENTRIES = 500, _internals18, COMPLIANCE_PATTERN, CODER_SKILLS_PATTERN;
+var SKILL_CAPABLE_AGENTS, SKILL_SEARCH_ROOTS, MAX_SCORING_SESSION_ENTRIES = 500, _internals18, COMPLIANCE_PATTERN, CODER_SKILLS_PATTERN, REVIEWER_TASK_PATTERN;
 var init_skill_propagation_gate = __esm(() => {
   init_schema();
   init_logger();
@@ -41865,6 +42133,7 @@ var init_skill_propagation_gate = __esm(() => {
   };
   COMPLIANCE_PATTERN = /SKILL_COMPLIANCE\s*:\s*(COMPLIANT|PARTIAL|VIOLATED)(?:\s*(?:\u2014|-)\s*(.*))?\s*$/i;
   CODER_SKILLS_PATTERN = /SKILLS_USED_BY_CODER\s*:\s*(.+)/i;
+  REVIEWER_TASK_PATTERN = /TASK\s*:\s*(\S+)/i;
   _internals18.skillPropagationGateBefore = skillPropagationGateBefore;
   _internals18.skillPropagationTransformScan = skillPropagationTransformScan;
   _internals18.writeWarnEvent = writeWarnEvent;
@@ -41879,7 +42148,7 @@ var init_skill_propagation_gate = __esm(() => {
 
 // src/hooks/micro-reflector.ts
 import { existsSync as existsSync15 } from "fs";
-import { readFile as readFile8, writeFile as writeFile8 } from "fs/promises";
+import { readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
 import * as path24 from "path";
 function resolveInsightCandidatesPath(directory) {
   return validateSwarmPath(directory, "insight-candidates.jsonl");
@@ -41926,7 +42195,7 @@ var init_micro_reflector = __esm(() => {
 
 // src/hooks/knowledge-curator.ts
 import { existsSync as existsSync16 } from "fs";
-import { appendFile as appendFile6, mkdir as mkdir9, readFile as readFile9, writeFile as writeFile9 } from "fs/promises";
+import { appendFile as appendFile6, mkdir as mkdir9, readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
 import * as path25 from "path";
 function pruneSeenRetroSections() {
   const cutoff = Date.now() - 86400000;
@@ -42167,7 +42436,8 @@ async function enrichLessonToV3(params) {
       const reservation = await reserveQuota(params.directory, {
         nCalls: 1,
         maxCalls: quota.maxCalls,
-        window: quota.window
+        window: quota.window,
+        scope: "knowledge-enrichment"
       });
       if (!reservation.allowed)
         return null;
@@ -42221,7 +42491,7 @@ async function consumeInsightCandidates(directory, batchLimit = MESO_INSIGHT_BAT
       const body = data.length === 0 ? "" : `${data.map((c) => JSON.stringify(c)).join(`
 `)}
 `;
-      await writeFile9(p, body, "utf-8");
+      await writeFile8(p, body, "utf-8");
     }, (all) => {
       if (all.length === 0)
         return null;
@@ -42512,7 +42782,7 @@ async function runAutoPromotion(directory, config3) {
     await rewriteKnowledge(knowledgePath, entries);
   }
 }
-function createKnowledgeCuratorHook(directory, config3) {
+function createKnowledgeCuratorHook(directory, config3, options = {}) {
   const handler = async (input, _output) => {
     pruneSeenRetroSections();
     if (!config3.enabled)
@@ -42557,7 +42827,10 @@ function createKnowledgeCuratorHook(directory, config3) {
       recordSeenRetroSection(evidenceKey, evidenceHash, Date.now());
       const projectName2 = evidenceData.project_name ?? "unknown";
       const phaseNumber2 = typeof evidenceData.phase_number === "number" ? evidenceData.phase_number : 1;
-      await _internals19.curateAndStoreSwarm(lessons, projectName2, { phase_number: phaseNumber2 }, directory, config3);
+      await _internals19.curateAndStoreSwarm(lessons, projectName2, { phase_number: phaseNumber2 }, directory, config3, {
+        llmDelegate: options.llmDelegateFactory?.(sessionID),
+        enrichmentQuota: options.enrichmentQuota
+      });
       return;
     }
     const planContent = await readSwarmFileAsync(directory, "plan.md");
@@ -42579,7 +42852,10 @@ function createKnowledgeCuratorHook(directory, config3) {
     const projectName = projectNameMatch ? projectNameMatch[1].trim() : "unknown";
     const phaseMatch = /^Phase:\s*(\d+)/m.exec(planContent);
     const phaseNumber = phaseMatch ? parseInt(phaseMatch[1], 10) : 1;
-    await _internals19.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config3);
+    await _internals19.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config3, {
+      llmDelegate: options.llmDelegateFactory?.(sessionID),
+      enrichmentQuota: options.enrichmentQuota
+    });
   };
   return safeHook(handler);
 }
@@ -42738,7 +43014,7 @@ var init_skill_improver_llm_factory = __esm(() => {
 });
 
 // src/services/trajectory-cluster.ts
-import { mkdir as mkdir10, writeFile as writeFile10 } from "fs/promises";
+import { mkdir as mkdir10, writeFile as writeFile9 } from "fs/promises";
 import * as path26 from "path";
 function failureKind(e) {
   const tool3 = (e.tool ?? "").toLowerCase();
@@ -42873,7 +43149,7 @@ async function writeMotifProposals(directory, opts = {}) {
     for (const motif of motifs.slice(0, max)) {
       const slug = `motif-${slugify2(motif.signature)}`;
       const filePath = path26.join(proposalsDir, `${slug}.md`);
-      await writeFile10(filePath, buildMotifProposal(motif), "utf-8");
+      await writeFile9(filePath, buildMotifProposal(motif), "utf-8");
       result.proposalsWritten.push(filePath);
     }
     return result;
@@ -43017,7 +43293,7 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
     for (const motif of motifs.slice(0, max)) {
       const slug = workflowSlug(motif.signature);
       const filePath = path26.join(proposalsDir, `${slug}.md`);
-      await writeFile10(filePath, buildWorkflowProposal(motif), "utf-8");
+      await writeFile9(filePath, buildWorkflowProposal(motif), "utf-8");
       result.proposalsWritten.push(filePath);
     }
     return result;
@@ -43148,7 +43424,7 @@ var init_unactionable_hardening = __esm(() => {
 
 // src/services/skill-improver.ts
 import { existsSync as existsSync18 } from "fs";
-import { mkdir as mkdir11, readFile as readFile10, rename as rename6, writeFile as writeFile11 } from "fs/promises";
+import { mkdir as mkdir11, readFile as readFile10, rename as rename6, writeFile as writeFile10 } from "fs/promises";
 import * as path27 from "path";
 function timestampSlug(d) {
   return d.toISOString().replace(/[:.]/g, "-");
@@ -43156,7 +43432,7 @@ function timestampSlug(d) {
 async function atomicWrite2(p, content) {
   await mkdir11(path27.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile11(tmp, content, "utf-8");
+  await writeFile10(tmp, content, "utf-8");
   await rename6(tmp, p);
 }
 async function gatherInventory(directory) {
@@ -43210,7 +43486,10 @@ async function gatherInventory(directory) {
       });
     }
   }
-  const matureCandidates = swarm.concat(hive).filter((e) => e.status !== "archived" && e.confidence >= 0.85 && !e.generated_skill_slug && (e.confirmed_by ?? []).length >= 2);
+  const matureCandidates = await selectCandidateEntries(directory, {
+    minConfidence: DEFAULT_SKILL_MIN_CONFIDENCE,
+    minConfirmations: DEFAULT_SKILL_MIN_CONFIRMATIONS
+  });
   return {
     knowledge: { swarm: swarm.length, hive: hive.length, archived },
     skills: {
@@ -43476,8 +43755,8 @@ async function runSkillImprover(req) {
     const gen = await generateSkills({
       directory: req.directory,
       mode: "draft",
-      minConfidence: 0.85,
-      minConfirmations: 2
+      minConfidence: DEFAULT_SKILL_MIN_CONFIDENCE,
+      minConfirmations: DEFAULT_SKILL_MIN_CONFIRMATIONS
     });
     draftSkillsWritten = gen.written.map((w) => ({
       slug: w.slug,
@@ -43513,7 +43792,7 @@ async function runSkillImprover(req) {
     unactionableHardening = await hardenUnactionableEntries({
       directory: req.directory,
       llmDelegate: delegate,
-      quota: { maxCalls: cfg.max_calls_per_day, window: cfg.quota_window }
+      quota: req.enrichmentQuota
     });
   }
   const motifResult = await writeMotifProposals(req.directory);
@@ -44339,8 +44618,8 @@ async function copyDirRecursive(src, dest) {
     const srcEntry = path29.join(src, entry);
     const destEntry = path29.join(dest, entry);
     try {
-      const stat3 = await fs12.stat(srcEntry);
-      if (stat3.isDirectory()) {
+      const stat4 = await fs12.stat(srcEntry);
+      if (stat4.isDirectory()) {
         const subCount = await copyDirRecursive(srcEntry, destEntry).catch(() => 0);
         count += subCount;
       } else {
@@ -44376,8 +44655,8 @@ function guaranteeAllPlansComplete(planData) {
 async function handleCloseCommand(directory, args, options = {}) {
   const swarmDir = path29.join(directory, ".swarm");
   try {
-    const stat3 = fsSync2.lstatSync(swarmDir);
-    if (stat3.isSymbolicLink()) {
+    const stat4 = fsSync2.lstatSync(swarmDir);
+    if (stat4.isSymbolicLink()) {
       return `\u274C Refused: .swarm/ is a symlink or junction. Refusing to operate on a redirected directory for safety.`;
     }
   } catch (err) {
@@ -44531,12 +44810,11 @@ async function handleCloseCommand(directory, args, options = {}) {
   let curationSucceeded = false;
   let curationResult;
   try {
-    const skillImproverCfg = SkillImproverConfigSchema.parse(loadedConfig.skill_improver ?? {});
     curationResult = await curateAndStoreSwarm(allLessons, projectName, { phase_number: 0 }, directory, config3, {
       llmDelegate: createCuratorLLMDelegate(directory, "phase", options.sessionID),
       enrichmentQuota: {
-        maxCalls: skillImproverCfg.max_calls_per_day,
-        window: skillImproverCfg.quota_window
+        maxCalls: config3.enrichment.max_calls_per_day,
+        window: config3.enrichment.quota_window
       }
     });
     curationSucceeded = true;
@@ -44601,7 +44879,11 @@ async function handleCloseCommand(directory, args, options = {}) {
         config: skillImproverConfig,
         targets: ["skills", "knowledge"],
         mode: "proposal",
-        sessionId: options.sessionID
+        sessionId: options.sessionID,
+        enrichmentQuota: {
+          maxCalls: config3.enrichment.max_calls_per_day,
+          window: config3.enrichment.quota_window
+        }
       }, options.skillReviewTimeoutMs ?? CLOSE_SKILL_REVIEW_TIMEOUT_MS);
       if (skillReviewResult.ran) {
         const proposal = skillReviewResult.proposalPath ? ` Proposal: ${skillReviewResult.proposalPath}.` : "";
@@ -45359,7 +45641,7 @@ var init_curate = __esm(() => {
 // src/tools/co-change-analyzer.ts
 import * as child_process3 from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
-import { readdir, readFile as readFile11, stat as stat3 } from "fs/promises";
+import { readdir, readFile as readFile11, stat as stat4 } from "fs/promises";
 import * as path31 from "path";
 import { promisify } from "util";
 function getExecFileAsync() {
@@ -45510,7 +45792,7 @@ async function getStaticEdges(directory) {
           for (const ext of extensions) {
             const testPath = resolvedPath + ext;
             try {
-              const testStat = await stat3(testPath);
+              const testStat = await stat4(testPath);
               if (testStat.isFile()) {
                 targetFile = testPath;
                 break;
@@ -51774,7 +52056,7 @@ var KNOWLEDGE_SCHEMA_VERSION = 2;
 // src/hooks/knowledge-migrator.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { existsSync as existsSync26, readFileSync as readFileSync16 } from "fs";
-import { mkdir as mkdir12, readFile as readFile13, writeFile as writeFile12 } from "fs/promises";
+import { mkdir as mkdir12, readFile as readFile13, writeFile as writeFile11 } from "fs/promises";
 import * as os8 from "os";
 import * as path39 from "path";
 async function migrateKnowledgeToExternal(_directory, _config) {
@@ -52123,7 +52405,7 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     migration_tool: "knowledge-migrator.ts"
   };
   await mkdir12(path39.dirname(sentinelPath), { recursive: true });
-  await writeFile12(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
+  await writeFile11(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 function resolveLegacyHiveKnowledgePath() {
   const platform = process.platform;
@@ -52540,7 +52822,7 @@ var init_redaction = __esm(() => {
 });
 
 // src/memory/schema.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 function normalizeMemoryText(text) {
   return text.replace(/\s+/g, " ").trim();
 }
@@ -52564,7 +52846,7 @@ function stableScopeKey(scope) {
 }
 function computeMemoryContentHash(recordLike) {
   const normalized = normalizeMemoryText(recordLike.text).toLowerCase();
-  return createHash6("sha256").update(`${stableScopeKey(recordLike.scope)}
+  return createHash7("sha256").update(`${stableScopeKey(recordLike.scope)}
 ${recordLike.kind}
 ${normalized}`).digest("hex");
 }
@@ -53316,7 +53598,7 @@ import {
   mkdir as mkdir13,
   readFile as readFile14,
   rename as rename7,
-  writeFile as writeFile13
+  writeFile as writeFile12
 } from "fs/promises";
 import * as path40 from "path";
 
@@ -53727,7 +54009,7 @@ async function writeJsonlAtomic(filePath, values) {
   const content = values.map((value) => JSON.stringify(value)).join(`
 `) + (values.length > 0 ? `
 ` : "");
-  await writeFile13(tmp, content, "utf-8");
+  await writeFile12(tmp, content, "utf-8");
   await rename7(tmp, filePath);
 }
 var init_local_jsonl_provider = __esm(() => {
@@ -53748,7 +54030,7 @@ var init_prompt_block = __esm(() => {
 
 // src/memory/jsonl-migration.ts
 import { existsSync as existsSync28 } from "fs";
-import { copyFile, mkdir as mkdir14, readFile as readFile15, stat as stat4, writeFile as writeFile14 } from "fs/promises";
+import { copyFile, mkdir as mkdir14, readFile as readFile15, stat as stat5, writeFile as writeFile13 } from "fs/promises";
 import * as path41 from "path";
 function resolveMemoryStorageDir(rootDirectory, config3 = {}) {
   const resolved = resolveConfig(config3);
@@ -53796,14 +54078,14 @@ async function writeJsonlExport(rootDirectory, config3, memories, proposals) {
   await mkdir14(exportDir, { recursive: true });
   const memoriesPath = path41.join(exportDir, "memories.jsonl");
   const proposalsPath = path41.join(exportDir, "proposals.jsonl");
-  await writeFile14(memoriesPath, toJsonl(memories), "utf-8");
-  await writeFile14(proposalsPath, toJsonl(proposals), "utf-8");
+  await writeFile13(memoriesPath, toJsonl(memories), "utf-8");
+  await writeFile13(proposalsPath, toJsonl(proposals), "utf-8");
   return { directory: exportDir, memoriesPath, proposalsPath };
 }
 async function writeMigrationReport(rootDirectory, report, config3 = {}) {
   const reportPath = path41.join(resolveMemoryStorageDir(rootDirectory, config3), "migration-report.json");
   await mkdir14(path41.dirname(reportPath), { recursive: true });
-  await writeFile14(reportPath, `${JSON.stringify(report, null, 2)}
+  await writeFile13(reportPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
   return reportPath;
 }
@@ -53824,7 +54106,7 @@ async function getLegacyJsonlFileStatus(rootDirectory, config3 = {}) {
     const filePath = path41.join(storageDir, file3);
     let sizeBytes = 0;
     if (existsSync28(filePath)) {
-      sizeBytes = (await stat4(filePath)).size;
+      sizeBytes = (await stat5(filePath)).size;
     }
     statuses.push({
       file: file3,
@@ -57559,8 +57841,8 @@ var init_secretscan = __esm(() => {
             break;
           const fileFindings = scanFileForSecrets(filePath);
           try {
-            const stat5 = fs19.statSync(filePath);
-            if (stat5.size > MAX_FILE_SIZE_BYTES) {
+            const stat6 = fs19.statSync(filePath);
+            if (stat6.size > MAX_FILE_SIZE_BYTES) {
               skippedFiles++;
               continue;
             }
@@ -58370,8 +58652,8 @@ function sharedTrailingSegments(a, b) {
 function isCacheStale(impactMap, generatedAtMs) {
   for (const sourcePath of Object.keys(impactMap)) {
     try {
-      const stat5 = fs23.statSync(sourcePath);
-      if (stat5.mtimeMs > generatedAtMs) {
+      const stat6 = fs23.statSync(sourcePath);
+      if (stat6.mtimeMs > generatedAtMs) {
         return true;
       }
     } catch {
@@ -59672,8 +59954,8 @@ function manifestHash(dir) {
     if (!entries.has(name))
       continue;
     try {
-      const stat5 = fs28.statSync(path56.join(dir, name));
-      parts.push(`${name}:${stat5.size}:${stat5.mtimeMs}:${stat5.ino}`);
+      const stat6 = fs28.statSync(path56.join(dir, name));
+      parts.push(`${name}:${stat6.size}:${stat6.mtimeMs}:${stat6.ino}`);
     } catch {}
   }
   return parts.join("|");