opencode-swarm 7.74.0 → 7.74.2

package/dist/index.js

@@ -69,7 +69,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",
@@ -648,7 +648,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: {
@@ -15921,7 +15921,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),
@@ -15988,7 +15992,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({
@@ -59523,7 +59527,7 @@ async function appendKnowledgeWithCapEnforcement(filePath, entry, maxEntries) {
   return transactKnowledge(filePath, (entries) => {
     const updated = [...entries, entry];
     if (updated.length > maxEntries) {
-      return updated.slice(updated.length - maxEntries);
+      return selectKnowledgeCapSurvivors(updated, maxEntries);
     }
     return updated;
   });
@@ -59532,9 +59536,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 sweepAgedEntries(filePath, defaultMaxPhases) {
   const result = {
     scanned: 0,
@@ -59770,6 +59811,7 @@ var init_knowledge_store = __esm(() => {
     findNearDuplicate,
     computeConfidence,
     computeOutcomeSignal,
+    selectKnowledgeCapSurvivors,
     inferTags,
     bumpKnowledgeConfidenceBatch
   };
@@ -59780,6 +59822,7 @@ var exports_knowledge_events = {};
 __export(exports_knowledge_events, {
   resolveLegacyApplicationLogPath: () => resolveLegacyApplicationLogPath,
   resolveKnowledgeEventsPath: () => resolveKnowledgeEventsPath,
+  resolveKnowledgeCounterBaselinePath: () => resolveKnowledgeCounterBaselinePath,
   recordKnowledgeEvent: () => recordKnowledgeEvent,
   recomputeCounters: () => recomputeCounters,
   readLegacyApplicationRecords: () => readLegacyApplicationRecords,
@@ -59800,11 +59843,14 @@ __export(exports_knowledge_events, {
 });
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { existsSync as existsSync15 } from "node:fs";
-import { appendFile as appendFile4, mkdir as mkdir4, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
+import { appendFile as appendFile4, mkdir as mkdir4, readFile as readFile5, stat as stat3 } from "node:fs/promises";
 import * as path32 from "node:path";
 function resolveKnowledgeEventsPath(directory) {
   return path32.join(directory, ".swarm", "knowledge-events.jsonl");
 }
+function resolveKnowledgeCounterBaselinePath(directory) {
+  return path32.join(directory, ".swarm", "knowledge-counter-baseline.json");
+}
 function resolveLegacyApplicationLogPath(directory) {
   return path32.join(directory, ".swarm", "knowledge-application.jsonl");
 }
@@ -59839,10 +59885,12 @@ async function appendKnowledgeEvent(directory, event) {
       const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
       if (lines.length > MAX_EVENT_LOG_ENTRIES) {
+        const evicted = lines.slice(0, lines.length - MAX_EVENT_LOG_ENTRIES);
         const trimmed = lines.slice(lines.length - MAX_EVENT_LOG_ENTRIES);
-        await writeFile3(filePath, `${trimmed.join(`
+        await foldEvictedEventsIntoBaseline(directory, evicted, filePath);
+        await atomicWriteFile(filePath, `${trimmed.join(`
 `)}
-`, "utf-8");
+`);
       }
     } catch (err2) {
       warn(`[knowledge-events] local cap trim failed (non-fatal): ${err2 instanceof Error ? err2.message : String(err2)}`);
@@ -59866,19 +59914,8 @@ async function readKnowledgeEvents(directory) {
   if (!existsSync15(filePath))
     return [];
   const content = await readFile5(filePath, "utf-8");
-  const out2 = [];
-  for (const line of content.split(`
-`)) {
-    const trimmed = line.trim();
-    if (!trimmed)
-      continue;
-    try {
-      out2.push(JSON.parse(trimmed));
-    } catch {
-      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
-    }
-  }
-  return out2;
+  return parseEventLines(content.split(`
+`), filePath);
 }
 async function readLegacyApplicationRecords(directory) {
   const filePath = resolveLegacyApplicationLogPath(directory);
@@ -59914,6 +59951,49 @@ function emptyRollup() {
     violation_timestamps: []
   };
 }
+function cloneRollup(input) {
+  return {
+    ...emptyRollup(),
+    ...input,
+    violation_timestamps: [...input.violation_timestamps ?? []]
+  };
+}
+function cloneRollupMap(input) {
+  const out2 = new Map;
+  for (const [id, rollup] of input) {
+    out2.set(id, cloneRollup(rollup));
+  }
+  return out2;
+}
+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 mergeRollupInto(target, source) {
+  target.shown_count += source.shown_count ?? 0;
+  target.acknowledged_count += source.acknowledged_count ?? 0;
+  target.applied_explicit_count += source.applied_explicit_count ?? 0;
+  target.ignored_count += source.ignored_count ?? 0;
+  target.violated_count += source.violated_count ?? 0;
+  target.contradicted_count += source.contradicted_count ?? 0;
+  target.n_a_count += source.n_a_count ?? 0;
+  target.succeeded_after_shown_count += source.succeeded_after_shown_count ?? 0;
+  target.failed_after_shown_count += source.failed_after_shown_count ?? 0;
+  target.partial_after_shown_count += source.partial_after_shown_count ?? 0;
+  if (source.last_applied_at) {
+    target.last_applied_at = maxIso(target.last_applied_at, source.last_applied_at);
+  }
+  if (source.last_acknowledged_at) {
+    target.last_acknowledged_at = maxIso(target.last_acknowledged_at, source.last_acknowledged_at);
+  }
+  target.violation_timestamps.push(...source.violation_timestamps ?? []);
+  normalizeRollupTimestamps(target);
+}
 function get(map3, id) {
   let r = map3.get(id);
   if (!r) {
@@ -59927,9 +60007,91 @@ function maxIso(current, candidate) {
     return candidate;
   return candidate > current ? candidate : current;
 }
-function recomputeCounters(events, legacyRecords = []) {
+async function readCounterBaseline(directory) {
+  const filePath = resolveKnowledgeCounterBaselinePath(directory);
+  if (!existsSync15(filePath))
+    return new Map;
+  const raw = JSON.parse(await readFile5(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 writeCounterBaseline(directory, baseline) {
+  const filePath = resolveKnowledgeCounterBaselinePath(directory);
+  const out2 = {};
+  for (const [id, rollup] of [...baseline.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    out2[id] = normalizeRollupTimestamps(cloneRollup(rollup));
+  }
+  await atomicWriteFile(filePath, `${JSON.stringify(out2, null, 2)}
+`);
+}
+async function statCacheKey(filePath) {
+  try {
+    const fileStat = await stat3(filePath);
+    return `${fileStat.mtimeMs}:${fileStat.ctimeMs}:${fileStat.size}`;
+  } catch (err2) {
+    if (err2?.code === "ENOENT")
+      return "missing";
+    throw err2;
+  }
+}
+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 out2 = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      out2.push(JSON.parse(trimmed));
+    } catch {
+      warn(`[knowledge-events] Skipping corrupted JSONL line in ${filePath}: ${trimmed.slice(0, 80)}`);
+    }
+  }
+  return out2;
+}
+async function foldEvictedEventsIntoBaseline(directory, evictedLines, filePath) {
+  const evictedEvents = parseEventLines(evictedLines, filePath);
+  if (evictedEvents.length === 0)
+    return;
+  const baseline = await readCounterBaseline(directory);
+  for (const [id, rollup] of recomputeCounters(evictedEvents)) {
+    mergeRollupInto(get(baseline, id), rollup);
+  }
+  await writeCounterBaseline(directory, baseline);
+}
+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": {
@@ -60005,12 +60167,7 @@ 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;
 }
@@ -60053,11 +60210,21 @@ async function countEntryViolationsInWindow(directory, entryId, windowDays, now
 }
 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 (err2) {
     warn(`[knowledge-events] readKnowledgeCounterRollups failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
     return new Map;
@@ -60124,10 +60291,12 @@ async function applyKnowledgeVerdictFeedback(directory, options) {
     return { processed: 0, bumps: 0 };
   }
 }
-var import_proper_lockfile4, KNOWLEDGE_EVENT_SCHEMA_VERSION = 1, MAX_EVENT_LOG_ENTRIES = 5000, RECEIPT_EVENT_TYPES, MAX_VIOLATION_TIMESTAMPS = 10, VERDICT_CONFIDENCE_BOOST = 0.03, VERDICT_CONFIDENCE_DECAY = 0.05, _internals23;
+var import_proper_lockfile4, KNOWLEDGE_EVENT_SCHEMA_VERSION = 1, MAX_EVENT_LOG_ENTRIES = 5000, counterRollupCache, MAX_COUNTER_ROLLUP_CACHE_DIRS = 32, RECEIPT_EVENT_TYPES, MAX_VIOLATION_TIMESTAMPS = 10, VERDICT_CONFIDENCE_BOOST = 0.03, VERDICT_CONFIDENCE_DECAY = 0.05, _internals23;
 var init_knowledge_events = __esm(() => {
+  init_task_file();
   init_logger();
   import_proper_lockfile4 = __toESM(require_proper_lockfile(), 1);
+  counterRollupCache = new Map;
   RECEIPT_EVENT_TYPES = new Set([
     "acknowledged",
     "applied",
@@ -60139,9 +60308,11 @@ var init_knowledge_events = __esm(() => {
   ]);
   _internals23 = {
     resolveKnowledgeEventsPath,
+    resolveKnowledgeCounterBaselinePath,
     appendKnowledgeEvent,
     recordKnowledgeEvent,
     readKnowledgeEvents,
+    readCounterBaseline,
     readLegacyApplicationRecords,
     readKnowledgeCounterRollups,
     effectiveRetrievalOutcomes,
@@ -60779,7 +60950,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,
@@ -60789,6 +60960,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 {
@@ -60811,10 +60992,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)) {
@@ -60954,31 +61135,22 @@ async function appendUnactionable(directory, entry, reason) {
   const filePath = resolveUnactionablePath(directory);
   const dirPath = path33.dirname(filePath);
   await mkdir5(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 appendFile5(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("..")) {
@@ -61112,28 +61284,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,
@@ -61235,7 +61413,7 @@ var init_knowledge_validator = __esm(() => {
 });
 
 // src/services/skill-changelog.ts
-import { appendFile as appendFile6, mkdir as mkdir6, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
+import { appendFile as appendFile6, mkdir as mkdir6, readFile as readFile6, writeFile as writeFile3 } from "node:fs/promises";
 import * as path34 from "node:path";
 function resolveSkillChangelogPath(directory, slug) {
   if (slug.includes("..") || slug.includes("/") || slug.includes("\\")) {
@@ -61255,7 +61433,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");
     }
@@ -61280,6 +61458,7 @@ __export(exports_skill_generator, {
   parseDraftFrontmatter: () => parseDraftFrontmatter,
   listSkills: () => listSkills,
   isValidSlug: () => isValidSlug,
+  isSkillMaturityEligible: () => isSkillMaturityEligible,
   inspectSkill: () => inspectSkill,
   generateSkills: () => generateSkills,
   clusterEntries: () => clusterEntries,
@@ -61287,10 +61466,13 @@ __export(exports_skill_generator, {
   activeRepoRelativePath: () => activeRepoRelativePath,
   activePath: () => activePath,
   activateProposal: () => activateProposal,
-  _internals: () => _internals24
+  _internals: () => _internals24,
+  STRONG_SKILL_OUTCOME_COUNT: () => STRONG_SKILL_OUTCOME_COUNT,
+  DEFAULT_SKILL_MIN_CONFIRMATIONS: () => DEFAULT_SKILL_MIN_CONFIRMATIONS,
+  DEFAULT_SKILL_MIN_CONFIDENCE: () => DEFAULT_SKILL_MIN_CONFIDENCE
 });
 import { existsSync as existsSync17, unlinkSync as unlinkSync5 } from "node:fs";
-import { mkdir as mkdir7, readFile as readFile7, rename as rename3, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdir as mkdir7, readFile as readFile7, rename as rename3, writeFile as writeFile4 } from "node:fs/promises";
 import * as path35 from "node:path";
 function sanitizeSlug(input) {
   const lc = input.toLowerCase().trim();
@@ -61315,18 +61497,35 @@ async function selectCandidateEntries(directory, opts) {
   const hivePath = resolveHiveKnowledgePath();
   const hive = existsSync17(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());
@@ -61366,8 +61565,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 ?? []));
@@ -61393,6 +61593,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))];
 }
@@ -61493,12 +61698,12 @@ function escapeMarkdown(s) {
 async function atomicWrite2(p, content) {
   await mkdir7(path35.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
@@ -61893,7 +62098,7 @@ async function retireSkill(directory, slug, reason) {
     reason: reason ?? "manual_retire"
   });
   await mkdir7(markerDir, { recursive: true });
-  await writeFile5(markerPath, markerContent, "utf-8");
+  await writeFile4(markerPath, markerContent, "utf-8");
   return {
     retired: true,
     path: skillPath,
@@ -62056,8 +62261,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, _internals24;
+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, _internals24;
 var init_skill_generator = __esm(() => {
+  init_knowledge_events();
   init_knowledge_store();
   init_knowledge_validator();
   init_logger();
@@ -62067,6 +62273,7 @@ var init_skill_generator = __esm(() => {
     sanitizeSlug,
     isValidSlug,
     selectCandidateEntries,
+    isSkillMaturityEligible,
     clusterEntries,
     jaccardSimilarity,
     renderSkillMarkdown,
@@ -62085,7 +62292,7 @@ var init_skill_generator = __esm(() => {
 
 // src/services/skill-improver-quota.ts
 import { existsSync as existsSync18 } from "node:fs";
-import { mkdir as mkdir8, readFile as readFile8, rename as rename4, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir8, readFile as readFile8, rename as rename4, writeFile as writeFile5 } from "node:fs/promises";
 import * as path36 from "node:path";
 async function acquireLock(dir) {
   const acquire = import_proper_lockfile6.default.lock(dir, LOCK_RETRY_OPTS);
@@ -62103,8 +62310,9 @@ async function acquireLock(dir) {
       clearTimeout(timer);
   }
 }
-function resolveQuotaPath(directory) {
-  return path36.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 path36.join(directory, ".swarm", fileName);
 }
 function todayKey(window2, now = new Date) {
   if (window2 === "utc") {
@@ -62132,11 +62340,11 @@ async function readState(filePath) {
 async function writeState(filePath, state) {
   await mkdir8(path36.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) {
@@ -62152,7 +62360,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 mkdir8(path36.dirname(filePath), { recursive: true });
   let release = null;
   try {
@@ -62182,7 +62390,7 @@ async function reserveQuota(directory, opts) {
   }
 }
 async function releaseQuota(directory, opts) {
-  const filePath = resolveQuotaPath(directory);
+  const filePath = resolveQuotaPath(directory, opts.scope);
   await mkdir8(path36.dirname(filePath), { recursive: true });
   let release = null;
   try {
@@ -62218,7 +62426,7 @@ var init_skill_improver_quota = __esm(() => {
 });
 
 // src/services/skill-reviser.ts
-import { readFile as readFile9, rename as rename5, writeFile as writeFile7 } from "node:fs/promises";
+import { readFile as readFile9, rename as rename5, writeFile as writeFile6 } from "node:fs/promises";
 async function getSkillVersion(skillPath) {
   try {
     const content = await readFile9(skillPath, "utf-8");
@@ -62324,7 +62532,7 @@ async function reviseSkill(params) {
     try {
       const revised = _internals25.buildDeterministicRevision(params.currentContent, params.currentVersion, params.violationContexts);
       const tmpPath = `${params.skillPath}.tmp-${process.pid}-${Date.now()}`;
-      await writeFile7(tmpPath, revised, "utf-8");
+      await writeFile6(tmpPath, revised, "utf-8");
       await rename5(tmpPath, params.skillPath);
       const newVersion = params.currentVersion + 1;
       const entry = {
@@ -62392,7 +62600,7 @@ async function reviseSkill(params) {
       finalOutput = finalOutput.replace(/^version:\s*\d+\s*$/m, `version: ${expectedVersion}`);
     }
     const tmpPath = `${params.skillPath}.tmp-${process.pid}-${Date.now()}`;
-    await writeFile7(tmpPath, `${finalOutput}
+    await writeFile6(tmpPath, `${finalOutput}
 `, "utf-8");
     await rename5(tmpPath, params.skillPath);
     const newVersion = expectedVersion;
@@ -62458,6 +62666,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:${crypto4.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 (!_internals26.existsSync(resolved))
+    return processed;
+  const raw = _internals26.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 = path37.dirname(resolved);
+  if (!_internals26.existsSync(dir)) {
+    _internals26.mkdirSync(dir, { recursive: true });
+  }
+  const marker = {
+    type: "feedback_applied",
+    timestamp: new Date().toISOString(),
+    processedEntryIds: [...new Set(processedEntryIds)]
+  };
+  _internals26.appendFileSync(resolved, `${JSON.stringify(marker)}
+`, "utf-8");
+}
 function appendSkillUsageEntry(directory, entry) {
   const {
     skillPath,
@@ -62501,7 +62792,7 @@ function appendSkillUsageEntry(directory, entry) {
     agentName,
     taskID,
     timestamp,
-    complianceVerdict,
+    complianceVerdict: normalizeComplianceVerdict(complianceVerdict),
     sessionID,
     ...reviewerNotes !== undefined && { reviewerNotes },
     ...skillVersion !== undefined && { skillVersion }
@@ -62509,8 +62800,8 @@ function appendSkillUsageEntry(directory, entry) {
   _internals26.appendFileSync(resolved, `${JSON.stringify(fullEntry)}
 `, "utf-8");
   try {
-    const stat3 = _internals26.statSync(resolved);
-    if (stat3.size > SKILL_USAGE_LOG_ROTATE_BYTES) {
+    const stat4 = _internals26.statSync(resolved);
+    if (stat4.size > SKILL_USAGE_LOG_ROTATE_BYTES) {
       _internals26.pruneSkillUsageLog(directory, SKILL_USAGE_LOG_MAX_ENTRIES_PER_SKILL);
     }
   } catch {}
@@ -62528,9 +62819,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)
@@ -62564,11 +62855,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 stat3 = _internals26.statSync(logPath);
-    const start2 = Math.max(0, stat3.size - boundedMaxBytes);
+    const stat4 = _internals26.statSync(logPath);
+    const start2 = Math.max(0, stat4.size - boundedMaxBytes);
     const fd = _internals26.openSync(logPath, "r");
     try {
-      const readLen = stat3.size - start2;
+      const readLen = stat4.size - start2;
       if (readLen === 0)
         return [];
       const buf = Buffer.alloc(readLen);
@@ -62588,8 +62879,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;
           }
@@ -62624,8 +62916,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;
@@ -62736,6 +63029,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;
@@ -62743,6 +63037,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) {
@@ -62757,6 +63054,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;
@@ -62775,6 +63073,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;
     }
@@ -62788,6 +63087,7 @@ async function applySkillUsageFeedback(directory, options) {
     }));
     if (clampedDeltas.length > 0) {
       await bumpKnowledgeConfidenceBatch(directory, clampedDeltas);
+      appendFeedbackAppliedMarker(directory, processedEntryIds);
     }
   } catch (err2) {
     console.warn("[skill-usage-log] applySkillUsageFeedback failed (fail-open):", err2 instanceof Error ? err2.message : String(err2));
@@ -62814,7 +63114,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;
@@ -62847,7 +63150,7 @@ async function autoRetireSkills(directory, curatorKnowledgePath, excludeSlugs) {
           return true;
         return false;
       });
-      const violations = skillUsage.filter((e) => e.complianceVerdict === "violated").length;
+      const violations = skillUsage.filter((e) => normalizeComplianceVerdict(e.complianceVerdict) === "violated").length;
       const violationRate = skillUsage.length > 0 ? violations / skillUsage.length : 0;
       let allArchived = false;
       try {
@@ -63512,7 +63815,7 @@ ${phaseDigest.summary}`,
         });
         if (skillUsage.length === 0)
           continue;
-        const violations = skillUsage.filter((e) => e.complianceVerdict === "violated").length;
+        const violations = skillUsage.filter((e) => normalizeComplianceVerdict(e.complianceVerdict) === "violated").length;
         const violationRate = violations / skillUsage.length;
         if (violationRate > REVISION_VIOLATION_THRESHOLD && violationRate <= 0.3) {
           const content = await _internals27.readFileAsync(active.path, "utf-8");
@@ -63520,7 +63823,7 @@ ${phaseDigest.summary}`,
           if (fm && fm.skillOrigin === "promoted_external")
             continue;
           const currentVersion = fm?.version ?? 1;
-          const violationContexts = skillUsage.filter((e) => e.complianceVerdict === "violated").slice(-10).map((e) => ({
+          const violationContexts = skillUsage.filter((e) => normalizeComplianceVerdict(e.complianceVerdict) === "violated").slice(-10).map((e) => ({
             taskId: e.taskID,
             agent: e.agentName,
             verdict: e.complianceVerdict,
@@ -63814,6 +64117,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") {
@@ -63834,6 +64140,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) {
@@ -63916,7 +64225,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;
     }
@@ -64074,9 +64383,9 @@ import {
   mkdir as mkdir9,
   readFile as readFile10,
   rename as rename6,
-  stat as stat3,
+  stat as stat4,
   unlink as unlink2,
-  writeFile as writeFile8
+  writeFile as writeFile7
 } from "node:fs/promises";
 import * as path40 from "node:path";
 function emptySynonymMap() {
@@ -64263,7 +64572,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 stat3(filePath);
+    const st = await stat4(filePath);
     if (st.size > ceiling)
       return emptySynonymMap();
     const raw = await readFile10(filePath, "utf-8");
@@ -64276,7 +64585,7 @@ async function writeSynonymMapAtomic(filePath, map3) {
   await mkdir9(path40.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   try {
-    await writeFile8(tmp, JSON.stringify(map3, null, 2), "utf-8");
+    await writeFile7(tmp, JSON.stringify(map3, null, 2), "utf-8");
     await rename6(tmp, filePath);
   } finally {
     try {
@@ -64485,12 +64794,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, metadata2) {
   const taskKeywords = extractKeywords(taskDescription);
   if (taskKeywords.size === 0)
     return 0;
   const skillName = extractSkillName(skillPath);
-  const skillText = `${skillPath} ${skillName}`;
+  const skillText = `${skillPath} ${skillName} ${metadata2?.name ?? ""} ${metadata2?.description ?? ""}`;
   const skillKeywords = extractKeywords(skillText);
   let matchCount = 0;
   for (const kw of taskKeywords) {
@@ -64501,7 +64810,7 @@ function computeContextMatchScore(taskDescription, skillPath) {
   return matchCount / taskKeywords.size;
 }
 function computeSkillRelevanceScore(skillPath, taskDescription, usageHistory, metadata2) {
-  const contextScore = computeContextMatchScore(taskDescription, skillPath) * CONTEXT_WEIGHT;
+  const contextScore = computeContextMatchScore(taskDescription, skillPath, metadata2) * CONTEXT_WEIGHT;
   if (usageHistory.length === 0)
     return Math.min(1, contextScore);
   const usageCount = usageHistory.length;
@@ -64576,8 +64885,8 @@ function formatSkillIndexWithContext(skills, directory) {
   const usageLogPath = path41.join(directory, ".swarm", "skill-usage.jsonl");
   let hasHistory = false;
   try {
-    const stat4 = fs21.statSync(usageLogPath);
-    hasHistory = stat4.size > 0;
+    const stat5 = fs21.statSync(usageLogPath);
+    hasHistory = stat5.size > 0;
   } catch {}
   if (!hasHistory) {
     return skills.map((sp) => {
@@ -65098,24 +65407,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 = _internals29.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));
         }
       }
     }
@@ -65205,7 +65522,7 @@ async function skillPropagationTransformScan(directory, output, sessionID) {
     break;
   }
 }
-var SKILL_CAPABLE_AGENTS, SKILL_SEARCH_ROOTS, MAX_SCORING_SESSION_ENTRIES = 500, _internals29, COMPLIANCE_PATTERN, CODER_SKILLS_PATTERN;
+var SKILL_CAPABLE_AGENTS, SKILL_SEARCH_ROOTS, MAX_SCORING_SESSION_ENTRIES = 500, _internals29, COMPLIANCE_PATTERN, CODER_SKILLS_PATTERN, REVIEWER_TASK_PATTERN;
 var init_skill_propagation_gate = __esm(() => {
   init_schema();
   init_logger();
@@ -65251,6 +65568,7 @@ var init_skill_propagation_gate = __esm(() => {
   };
   COMPLIANCE_PATTERN = /SKILL_COMPLIANCE\s*:\s*(COMPLIANT|PARTIAL|VIOLATED)(?:\s*(?:—|-)\s*(.*))?\s*$/i;
   CODER_SKILLS_PATTERN = /SKILLS_USED_BY_CODER\s*:\s*(.+)/i;
+  REVIEWER_TASK_PATTERN = /TASK\s*:\s*(\S+)/i;
   _internals29.skillPropagationGateBefore = skillPropagationGateBefore;
   _internals29.skillPropagationTransformScan = skillPropagationTransformScan;
   _internals29.writeWarnEvent = writeWarnEvent;
@@ -65265,7 +65583,7 @@ var init_skill_propagation_gate = __esm(() => {
 
 // src/hooks/micro-reflector.ts
 import { existsSync as existsSync22 } from "node:fs";
-import { readFile as readFile11, writeFile as writeFile9 } from "node:fs/promises";
+import { readFile as readFile11, writeFile as writeFile8 } from "node:fs/promises";
 import * as path43 from "node:path";
 function resolveInsightCandidatesPath(directory) {
   return validateSwarmPath(directory, "insight-candidates.jsonl");
@@ -65334,7 +65652,7 @@ async function appendInsightCandidates(directory, candidates) {
     const body2 = data.length === 0 ? "" : `${data.map((c) => JSON.stringify(c)).join(`
 `)}
 `;
-    await writeFile9(p, body2, "utf-8");
+    await writeFile8(p, body2, "utf-8");
   }, (all) => {
     const merged = [...all, ...candidates];
     const capped = merged.length > INSIGHT_CANDIDATES_MAX_ENTRIES ? merged.slice(-INSIGHT_CANDIDATES_MAX_ENTRIES) : merged;
@@ -65455,7 +65773,8 @@ async function runMicroReflection(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 result;
@@ -65542,7 +65861,7 @@ var init_micro_reflector = __esm(() => {
 
 // src/hooks/knowledge-curator.ts
 import { existsSync as existsSync23 } from "node:fs";
-import { appendFile as appendFile7, mkdir as mkdir10, readFile as readFile12, writeFile as writeFile10 } from "node:fs/promises";
+import { appendFile as appendFile7, mkdir as mkdir10, readFile as readFile12, writeFile as writeFile9 } from "node:fs/promises";
 import * as path44 from "node:path";
 function pruneSeenRetroSections() {
   const cutoff = Date.now() - 86400000;
@@ -65783,7 +66102,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;
@@ -65837,7 +66157,7 @@ async function consumeInsightCandidates(directory, batchLimit = MESO_INSIGHT_BAT
       const body2 = data.length === 0 ? "" : `${data.map((c) => JSON.stringify(c)).join(`
 `)}
 `;
-      await writeFile10(p, body2, "utf-8");
+      await writeFile9(p, body2, "utf-8");
     }, (all) => {
       if (all.length === 0)
         return null;
@@ -66128,7 +66448,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)
@@ -66173,7 +66493,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 _internals30.curateAndStoreSwarm(lessons, projectName2, { phase_number: phaseNumber2 }, directory, config3);
+      await _internals30.curateAndStoreSwarm(lessons, projectName2, { phase_number: phaseNumber2 }, directory, config3, {
+        llmDelegate: options.llmDelegateFactory?.(sessionID),
+        enrichmentQuota: options.enrichmentQuota
+      });
       return;
     }
     const planContent = await readSwarmFileAsync(directory, "plan.md");
@@ -66195,7 +66518,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 _internals30.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config3);
+    await _internals30.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config3, {
+      llmDelegate: options.llmDelegateFactory?.(sessionID),
+      enrichmentQuota: options.enrichmentQuota
+    });
   };
   return safeHook(handler);
 }
@@ -66354,7 +66680,7 @@ var init_skill_improver_llm_factory = __esm(() => {
 });
 
 // src/services/trajectory-cluster.ts
-import { mkdir as mkdir11, writeFile as writeFile11 } from "node:fs/promises";
+import { mkdir as mkdir11, writeFile as writeFile10 } from "node:fs/promises";
 import * as path45 from "node:path";
 function failureKind(e) {
   const tool3 = (e.tool ?? "").toLowerCase();
@@ -66489,7 +66815,7 @@ async function writeMotifProposals(directory, opts = {}) {
     for (const motif of motifs.slice(0, max)) {
       const slug = `motif-${slugify2(motif.signature)}`;
       const filePath = path45.join(proposalsDir, `${slug}.md`);
-      await writeFile11(filePath, buildMotifProposal(motif), "utf-8");
+      await writeFile10(filePath, buildMotifProposal(motif), "utf-8");
       result.proposalsWritten.push(filePath);
     }
     return result;
@@ -66633,7 +66959,7 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
     for (const motif of motifs.slice(0, max)) {
       const slug = workflowSlug(motif.signature);
       const filePath = path45.join(proposalsDir, `${slug}.md`);
-      await writeFile11(filePath, buildWorkflowProposal(motif), "utf-8");
+      await writeFile10(filePath, buildWorkflowProposal(motif), "utf-8");
       result.proposalsWritten.push(filePath);
     }
     return result;
@@ -66764,7 +67090,7 @@ var init_unactionable_hardening = __esm(() => {
 
 // src/services/skill-improver.ts
 import { existsSync as existsSync25 } from "node:fs";
-import { mkdir as mkdir12, readFile as readFile13, rename as rename7, writeFile as writeFile12 } from "node:fs/promises";
+import { mkdir as mkdir12, readFile as readFile13, rename as rename7, writeFile as writeFile11 } from "node:fs/promises";
 import * as path46 from "node:path";
 function timestampSlug(d) {
   return d.toISOString().replace(/[:.]/g, "-");
@@ -66772,7 +67098,7 @@ function timestampSlug(d) {
 async function atomicWrite3(p, content) {
   await mkdir12(path46.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile12(tmp, content, "utf-8");
+  await writeFile11(tmp, content, "utf-8");
   await rename7(tmp, p);
 }
 async function gatherInventory(directory) {
@@ -66826,7 +67152,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: {
@@ -67092,8 +67421,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,
@@ -67129,7 +67458,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);
@@ -67955,8 +68284,8 @@ async function copyDirRecursive(src, dest) {
     const srcEntry = path48.join(src, entry);
     const destEntry = path48.join(dest, entry);
     try {
-      const stat4 = await fs23.stat(srcEntry);
-      if (stat4.isDirectory()) {
+      const stat5 = await fs23.stat(srcEntry);
+      if (stat5.isDirectory()) {
         const subCount = await copyDirRecursive(srcEntry, destEntry).catch(() => 0);
         count += subCount;
       } else {
@@ -67992,8 +68321,8 @@ function guaranteeAllPlansComplete(planData) {
 async function handleCloseCommand(directory, args2, options = {}) {
   const swarmDir = path48.join(directory, ".swarm");
   try {
-    const stat4 = fsSync5.lstatSync(swarmDir);
-    if (stat4.isSymbolicLink()) {
+    const stat5 = fsSync5.lstatSync(swarmDir);
+    if (stat5.isSymbolicLink()) {
       return `❌ Refused: .swarm/ is a symlink or junction. Refusing to operate on a redirected directory for safety.`;
     }
   } catch (err2) {
@@ -68147,12 +68476,11 @@ async function handleCloseCommand(directory, args2, 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;
@@ -68217,7 +68545,11 @@ async function handleCloseCommand(directory, args2, 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}.` : "";
@@ -68986,7 +69318,7 @@ __export(exports_co_change_analyzer, {
 });
 import * as child_process3 from "node:child_process";
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { readdir as readdir2, readFile as readFile14, stat as stat4 } from "node:fs/promises";
+import { readdir as readdir2, readFile as readFile14, stat as stat5 } from "node:fs/promises";
 import * as path50 from "node:path";
 import { promisify } from "node:util";
 function getExecFileAsync() {
@@ -69137,7 +69469,7 @@ async function getStaticEdges(directory) {
           for (const ext of extensions) {
             const testPath = resolvedPath + ext;
             try {
-              const testStat = await stat4(testPath);
+              const testStat = await stat5(testPath);
               if (testStat.isFile()) {
                 targetFile = testPath;
                 break;
@@ -75517,7 +75849,7 @@ var KNOWLEDGE_SCHEMA_VERSION = 2;
 // src/hooks/knowledge-migrator.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { existsSync as existsSync33, readFileSync as readFileSync18 } from "node:fs";
-import { mkdir as mkdir13, readFile as readFile16, writeFile as writeFile13 } from "node:fs/promises";
+import { mkdir as mkdir13, readFile as readFile16, writeFile as writeFile12 } from "node:fs/promises";
 import * as os13 from "node:os";
 import * as path58 from "node:path";
 async function migrateKnowledgeToExternal(_directory, _config) {
@@ -75866,7 +76198,7 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     migration_tool: "knowledge-migrator.ts"
   };
   await mkdir13(path58.dirname(sentinelPath), { recursive: true });
-  await writeFile13(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
+  await writeFile12(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 function resolveLegacyHiveKnowledgePath() {
   const platform = process.platform;
@@ -76297,7 +76629,7 @@ var init_redaction = __esm(() => {
 });
 
 // src/memory/schema.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 function normalizeMemoryText(text) {
   return text.replace(/\s+/g, " ").trim();
 }
@@ -76321,7 +76653,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");
 }
@@ -76329,14 +76661,14 @@ function createMemoryId(recordLike) {
   return `mem_${computeMemoryContentHash(recordLike).slice(0, 16)}`;
 }
 function createProposalId(input) {
-  const hash4 = createHash6("sha256").update(`${input.createdAt}
+  const hash4 = createHash7("sha256").update(`${input.createdAt}
 ${input.proposer}
 ${normalizeMemoryText(input.text)}`).digest("hex");
   return `prop_${hash4.slice(0, 16)}`;
 }
 function createBundleId(query, generatedAt) {
   const compactTimestamp = generatedAt.replace(/[-:.TZ]/g, "").slice(0, 14);
-  const hash4 = createHash6("sha256").update(`${generatedAt}
+  const hash4 = createHash7("sha256").update(`${generatedAt}
 ${query}`).digest("hex").slice(0, 8);
   return `bundle_${compactTimestamp}_${hash4}`;
 }
@@ -77088,7 +77420,7 @@ import {
   mkdir as mkdir14,
   readFile as readFile17,
   rename as rename8,
-  writeFile as writeFile14
+  writeFile as writeFile13
 } from "node:fs/promises";
 import * as path59 from "node:path";
 
@@ -77499,7 +77831,7 @@ async function writeJsonlAtomic(filePath, values) {
   const content = values.map((value) => JSON.stringify(value)).join(`
 `) + (values.length > 0 ? `
 ` : "");
-  await writeFile14(tmp, content, "utf-8");
+  await writeFile13(tmp, content, "utf-8");
   await rename8(tmp, filePath);
 }
 var init_local_jsonl_provider = __esm(() => {
@@ -77594,7 +77926,7 @@ var init_prompt_block = __esm(() => {
 
 // src/memory/jsonl-migration.ts
 import { existsSync as existsSync35 } from "node:fs";
-import { copyFile, mkdir as mkdir15, readFile as readFile18, stat as stat5, writeFile as writeFile15 } from "node:fs/promises";
+import { copyFile, mkdir as mkdir15, readFile as readFile18, stat as stat6, writeFile as writeFile14 } from "node:fs/promises";
 import * as path60 from "node:path";
 function resolveMemoryStorageDir(rootDirectory, config3 = {}) {
   const resolved = resolveConfig(config3);
@@ -77642,14 +77974,14 @@ async function writeJsonlExport(rootDirectory, config3, memories, proposals) {
   await mkdir15(exportDir, { recursive: true });
   const memoriesPath = path60.join(exportDir, "memories.jsonl");
   const proposalsPath = path60.join(exportDir, "proposals.jsonl");
-  await writeFile15(memoriesPath, toJsonl(memories), "utf-8");
-  await writeFile15(proposalsPath, toJsonl(proposals), "utf-8");
+  await writeFile14(memoriesPath, toJsonl(memories), "utf-8");
+  await writeFile14(proposalsPath, toJsonl(proposals), "utf-8");
   return { directory: exportDir, memoriesPath, proposalsPath };
 }
 async function writeMigrationReport(rootDirectory, report, config3 = {}) {
   const reportPath = path60.join(resolveMemoryStorageDir(rootDirectory, config3), "migration-report.json");
   await mkdir15(path60.dirname(reportPath), { recursive: true });
-  await writeFile15(reportPath, `${JSON.stringify(report, null, 2)}
+  await writeFile14(reportPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
   return reportPath;
 }
@@ -77670,7 +78002,7 @@ async function getLegacyJsonlFileStatus(rootDirectory, config3 = {}) {
     const filePath = path60.join(storageDir, file3);
     let sizeBytes = 0;
     if (existsSync35(filePath)) {
-      sizeBytes = (await stat5(filePath)).size;
+      sizeBytes = (await stat6(filePath)).size;
     }
     statuses.push({
       file: file3,
@@ -78719,7 +79051,7 @@ var init_sqlite_provider = __esm(() => {
 });
 
 // src/memory/gateway.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import { existsSync as existsSync36, readFileSync as readFileSync19 } from "node:fs";
 import * as path62 from "node:path";
 
@@ -79039,7 +79371,7 @@ function sourceFromEvidence(evidenceRefs, context) {
   return { type: "manual", ref: first };
 }
 function createStableId(value) {
-  return createHash7("sha256").update(value.toLowerCase()).digest("hex").slice(0, 16);
+  return createHash8("sha256").update(value.toLowerCase()).digest("hex").slice(0, 16);
 }
 function readGitRemoteUrl(directory) {
   if (gitRemoteUrlCache.has(directory))
@@ -82192,8 +82524,8 @@ var init_secretscan = __esm(() => {
             break;
           const fileFindings = scanFileForSecrets(filePath);
           try {
-            const stat6 = fs30.statSync(filePath);
-            if (stat6.size > MAX_FILE_SIZE_BYTES) {
+            const stat7 = fs30.statSync(filePath);
+            if (stat7.size > MAX_FILE_SIZE_BYTES) {
               skippedFiles++;
               continue;
             }
@@ -83003,8 +83335,8 @@ function sharedTrailingSegments(a, b) {
 function isCacheStale(impactMap, generatedAtMs) {
   for (const sourcePath of Object.keys(impactMap)) {
     try {
-      const stat6 = fs34.statSync(sourcePath);
-      if (stat6.mtimeMs > generatedAtMs) {
+      const stat7 = fs34.statSync(sourcePath);
+      if (stat7.mtimeMs > generatedAtMs) {
         return true;
       }
     } catch {
@@ -84350,8 +84682,8 @@ function manifestHash(dir) {
     if (!entries.has(name2))
       continue;
     try {
-      const stat6 = fs39.statSync(path77.join(dir, name2));
-      parts2.push(`${name2}:${stat6.size}:${stat6.mtimeMs}:${stat6.ino}`);
+      const stat7 = fs39.statSync(path77.join(dir, name2));
+      parts2.push(`${name2}:${stat7.size}:${stat7.mtimeMs}:${stat7.ino}`);
     } catch {}
   }
   return parts2.join("|");
@@ -94335,6 +94667,7 @@ SKILL COMPLIANCE REVIEW: When SKILLS_USED_BY_CODER is provided and not "none":
 - For each skill rule, verify the coder's changes comply
 - Flag violations at the same severity as logic errors
 - Report the overall compliance verdict in SKILL_COMPLIANCE field of your output
+- Report TASK: <task id> immediately before SKILL_COMPLIANCE when a task id is available
 - If you cannot load a skill (SKILL_LOAD_FAILED), report SKILL_COMPLIANCE: PARTIAL — [skill path] could not be loaded
 
 PROCESSING: If GATES is provided and includes passing results for lint, SAST, placeholder-scan, or secret-scan: skip the corresponding Tier 2 checks that those gates already cover. Focus Tier 2 time on checks NOT covered by automated gates.
@@ -94346,6 +94679,7 @@ VERDICT: APPROVED | REJECTED
 REUSE_RE_VERIFICATION: [VERIFIED | DUPLICATION_DETECTED | SKIPPED] — DUPLICATION_DETECTED is only valid when VERDICT is REJECTED
 RISK: LOW | MEDIUM | HIGH | CRITICAL
 ISSUES: list with line numbers, grouped by CHECK dimension
+TASK: [task id being reviewed, or "unknown"]
 SKILL_COMPLIANCE: COMPLIANT | PARTIAL | VIOLATED — [list of violations or "all rules followed"]
 DIRECTIVE_COMPLIANCE: one line per knowledge directive shown during this phase (IDs listed in the DIRECTIVES TO VERIFY block of your prompt, when present). Use exactly one of:
   VERIFIED:<id> evidence=<file:line | predicate_passed>
@@ -94926,7 +95260,7 @@ COVERAGE REPORTING:
 `;
 
 // src/agents/index.ts
-import { mkdir as mkdir17, writeFile as writeFile16 } from "node:fs/promises";
+import { mkdir as mkdir17, writeFile as writeFile15 } from "node:fs/promises";
 import * as path88 from "node:path";
 function stripSwarmPrefix(agentName, swarmPrefix) {
   if (!swarmPrefix || !agentName)
@@ -95406,7 +95740,7 @@ function getAgentConfigs(config3, directory, sessionId, projectContext) {
       generatedAt: new Date().toISOString(),
       agents: agentToolSnapshot
     }, null, 2);
-    mkdir17(evidenceDir, { recursive: true }).then(() => writeFile16(path88.join(evidenceDir, filename), snapshotData)).catch(() => {});
+    mkdir17(evidenceDir, { recursive: true }).then(() => writeFile15(path88.join(evidenceDir, filename), snapshotData)).catch(() => {});
   }
   return result;
 }
@@ -100118,8 +100452,8 @@ import {
   readdir as readdir6,
   readFile as readFile22,
   realpath as realpath3,
-  stat as stat8,
-  writeFile as writeFile18
+  stat as stat9,
+  writeFile as writeFile17
 } from "node:fs/promises";
 import * as path119 from "node:path";
 function normalizeSeparators(filePath) {
@@ -100201,8 +100535,8 @@ async function scanDocIndex(directory) {
       for (const file3 of existingManifest.files) {
         try {
           const fullPath = path119.join(directory, file3.path);
-          const stat9 = fs71.statSync(fullPath);
-          if (stat9.mtimeMs > file3.mtime) {
+          const stat10 = fs71.statSync(fullPath);
+          if (stat10.mtimeMs > file3.mtime) {
             cacheValid = false;
             break;
           }
@@ -100240,7 +100574,7 @@ async function scanDocIndex(directory) {
           const rel = path119.relative(resolvedDirectory, resolved);
           if (rel.startsWith("..") || path119.isAbsolute(rel))
             continue;
-          const targetStat = await stat8(symlinkPath);
+          const targetStat = await stat9(symlinkPath);
           isFile = targetStat.isFile();
         } catch {
           continue;
@@ -100269,7 +100603,7 @@ async function scanDocIndex(directory) {
         continue;
       let fileStat;
       try {
-        fileStat = await stat8(fullPath);
+        fileStat = await stat9(fullPath);
       } catch {
         continue;
       }
@@ -100317,7 +100651,7 @@ async function scanDocIndex(directory) {
   };
   try {
     await mkdir20(path119.dirname(manifestPath), { recursive: true });
-    await writeFile18(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    await writeFile17(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   } catch {}
   return { manifest, cached: false };
 }
@@ -101004,7 +101338,7 @@ async function searchKnowledge(params) {
       const confBoost = context && entry.confidence >= minConf && (ds.actionHit || ds.agentHit) ? 0.25 : 0;
       const generatedSkillBoost = entry.generated_skill_path && entry.status !== "archived" ? 0.05 : 0;
       const outcomeBoost = computeOutcomeSignal(retrievalOutcomes) * OUTCOME_RANK_WEIGHT;
-      const coldStartBonus = retrievalOutcomes.applied_count === 0 && entryAgePhases(entry) < (config3.retrieval?.cold_start_max_age_phases ?? DEFAULT_COLD_START_MAX_AGE_PHASES) ? config3.retrieval?.cold_start_bonus ?? DEFAULT_COLD_START_BONUS : 0;
+      const coldStartBonus = (retrievalOutcomes.applied_explicit_count ?? 0) === 0 && entryAgePhases(entry) < (config3.retrieval?.cold_start_max_age_phases ?? DEFAULT_COLD_START_MAX_AGE_PHASES) ? config3.retrieval?.cold_start_bonus ?? DEFAULT_COLD_START_BONUS : 0;
       let synonymBoost = 0;
       if (synonymTokens.length > 0) {
         const entryHay = normalize4(entryText(entry));
@@ -101029,6 +101363,7 @@ async function searchKnowledge(params) {
         ...entry,
         retrieval_outcomes: retrievalOutcomes,
         finalScore,
+        coldStartBoost: coldStartBonus,
         __critical: isCritical
       };
     });
@@ -101060,7 +101395,8 @@ async function searchKnowledge(params) {
       }
     }
     results = top.map(({ __critical: _c, ...rest }) => rest);
-  } catch {
+  } catch (err2) {
+    warn(`[search-knowledge] retrieval failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
     results = [];
   }
   if (emitEvent) {
@@ -101100,6 +101436,7 @@ var TEXT_WEIGHT = 0.6, META_WEIGHT = 0.4, DIRECTIVE_BOOST_MIN_CONFIDENCE = 0.75,
 var init_search_knowledge = __esm(() => {
   init_schema();
   init_synonym_map();
+  init_logger();
   init_knowledge_events();
   init_knowledge_reader();
   init_knowledge_store();
@@ -101485,8 +101822,8 @@ async function runDesignDocDriftCheck(directory, phase, outDir) {
     const traceabilityAbs = path165.join(outAbs, TRACEABILITY_REL);
     let registry3 = null;
     try {
-      const stat10 = await fs112.promises.stat(traceabilityAbs);
-      if (stat10.size <= MAX_TRACEABILITY_BYTES) {
+      const stat11 = await fs112.promises.stat(traceabilityAbs);
+      if (stat11.size <= MAX_TRACEABILITY_BYTES) {
         const raw = await fs112.promises.readFile(traceabilityAbs, "utf-8");
         const parsed = JSON.parse(raw);
         registry3 = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
@@ -102799,8 +103136,8 @@ function writeProjectConfigIfNew(directory, quiet = false) {
     const dest = path92.join(opencodeDir, "opencode-swarm.json");
     const normalizePathForCompare = (p) => process.platform === "win32" ? p.toLowerCase() : p;
     try {
-      const stat6 = fs50.lstatSync(opencodeDir);
-      if (stat6.isSymbolicLink())
+      const stat7 = fs50.lstatSync(opencodeDir);
+      if (stat7.isSymbolicLink())
         return;
       const resolvedDir = fs50.realpathSync(opencodeDir);
       const canonicalOpencode = path92.join(fs50.realpathSync(directory), ".opencode");
@@ -102973,8 +103310,8 @@ function extractFileSummary(filePath, content, absolutePath, existingEntry) {
   let mtimeMs = 0;
   if (absolutePath) {
     try {
-      const stat6 = fs52.statSync(absolutePath);
-      mtimeMs = stat6.mtimeMs;
+      const stat7 = fs52.statSync(absolutePath);
+      mtimeMs = stat7.mtimeMs;
     } catch {}
   }
   const base = {
@@ -105924,9 +106261,9 @@ function createPhaseMonitorHook(directory, preflightManager, curatorRunner, dele
           const initResult = await runner(directory, curatorConfig, llmDelegate);
           if (initResult.briefing) {
             const briefingPath = path103.join(directory, ".swarm", "curator-briefing.md");
-            const { mkdir: mkdir18, writeFile: writeFile17 } = await import("node:fs/promises");
+            const { mkdir: mkdir18, writeFile: writeFile16 } = await import("node:fs/promises");
             await mkdir18(path103.dirname(briefingPath), { recursive: true });
-            await writeFile17(briefingPath, initResult.briefing, "utf-8");
+            await writeFile16(briefingPath, initResult.briefing, "utf-8");
             const { buildApprovedReceipt: buildApprovedReceipt2, persistReviewReceipt: persistReviewReceipt2 } = await Promise.resolve().then(() => (init_review_receipt(), exports_review_receipt));
             const initReceipt = buildApprovedReceipt2({
               agent: "curator",
@@ -108515,16 +108852,16 @@ function tryResolveTSJS(rawModule, sourceFileAbs) {
     for (const ext of RESOLVE_EXTENSION_CANDIDATES) {
       const test = basePath + ext;
       try {
-        const stat8 = fs66.statSync(test);
-        if (stat8.isFile())
+        const stat9 = fs66.statSync(test);
+        if (stat9.isFile())
           return test;
       } catch {}
     }
     for (const indexFile of RESOLVE_INDEX_CANDIDATES) {
       const test = path113.join(basePath, indexFile);
       try {
-        const stat8 = fs66.statSync(test);
-        if (stat8.isFile())
+        const stat9 = fs66.statSync(test);
+        if (stat9.isFile())
           return test;
       } catch {}
     }
@@ -108555,8 +108892,8 @@ function tryResolvePython(rawModule, sourceFileAbs, workspaceRoot) {
   const baseAbs = path113.resolve(sourceDir, upDirs + remainder);
   const accept = (test) => {
     try {
-      const stat8 = fs66.statSync(test);
-      if (stat8.isFile()) {
+      const stat9 = fs66.statSync(test);
+      if (stat9.isFile()) {
         const rel = path113.relative(workspaceRoot, test).replace(/\\/g, "/");
         if (rel.startsWith(".."))
           return null;
@@ -109409,8 +109746,8 @@ function saveGraph2(workspaceRoot, graph) {
   const file3 = getGraphPath2(workspaceRoot);
   const dir = path116.dirname(file3);
   try {
-    const stat8 = fs68.lstatSync(dir);
-    if (stat8.isSymbolicLink()) {
+    const stat9 = fs68.lstatSync(dir);
+    if (stat9.isSymbolicLink()) {
       throw new Error(`refusing to write graph: ${SWARM_DIR}/ is a symbolic link`);
     }
   } catch (err2) {
@@ -109446,15 +109783,15 @@ function isGraphFresh(graph, maxAgeMs = 5 * 60 * 1000) {
 var cache2 = new Map;
 function getCachedGraph2(directory) {
   const file3 = getGraphPath2(directory);
-  let stat8;
+  let stat9;
   try {
-    stat8 = fs69.statSync(file3);
+    stat9 = fs69.statSync(file3);
   } catch {
     cache2.delete(directory);
     return null;
   }
   const cached3 = cache2.get(directory);
-  if (cached3 && cached3.mtimeMs === stat8.mtimeMs && cached3.size === stat8.size) {
+  if (cached3 && cached3.mtimeMs === stat9.mtimeMs && cached3.size === stat9.size) {
     return cached3.graph;
   }
   const graph = loadGraph2(directory);
@@ -109462,7 +109799,7 @@ function getCachedGraph2(directory) {
     cache2.delete(directory);
     return null;
   }
-  cache2.set(directory, { graph, mtimeMs: stat8.mtimeMs, size: stat8.size });
+  cache2.set(directory, { graph, mtimeMs: stat9.mtimeMs, size: stat9.size });
   return graph;
 }
 function buildCoderLocalizationBlock(directory, targetFile) {
@@ -112023,6 +112360,7 @@ import { appendFile as appendFile13, mkdir as mkdir22 } from "node:fs/promises";
 import * as path124 from "node:path";
 
 // src/hooks/knowledge-application.ts
+init_task_file();
 init_logger();
 init_knowledge_store();
 var import_proper_lockfile9 = __toESM(require_proper_lockfile(), 1);
@@ -112032,6 +112370,7 @@ import * as path122 from "node:path";
 function resolveApplicationLogPath(directory) {
   return path122.join(directory, ".swarm", "knowledge-application.jsonl");
 }
+var MAX_LEGACY_APPLICATION_LOG_ENTRIES = 5000;
 var ACK_PATTERN = /KNOWLEDGE_(APPLIED|IGNORED|VIOLATED|N_A)\s*:\s*([0-9a-fA-F-]{8,64})(?:\s+reason\s*=\s*([^\n\r]+?))?(?=$|[\n\r]|\s+KNOWLEDGE_)/g;
 function parseAcknowledgments(text) {
   if (!text || typeof text !== "string")
@@ -112048,9 +112387,29 @@ function parseAcknowledgments(text) {
 }
 async function appendAudit(directory, record3) {
   const filePath = resolveApplicationLogPath(directory);
-  await mkdir21(path122.dirname(filePath), { recursive: true });
-  await appendFile11(filePath, `${JSON.stringify(record3)}
+  const dirPath = path122.dirname(filePath);
+  await mkdir21(dirPath, { recursive: true });
+  let release;
+  try {
+    release = await import_proper_lockfile9.default.lock(dirPath, {
+      retries: { retries: 50, minTimeout: 10, maxTimeout: 100 },
+      stale: 5000
+    });
+    await appendFile11(filePath, `${JSON.stringify(record3)}
 `, "utf-8");
+    const content = await readFile24(filePath, "utf-8");
+    const lines = content.split(`
+`).filter((line) => line.trim().length > 0);
+    if (lines.length > MAX_LEGACY_APPLICATION_LOG_ENTRIES) {
+      const trimmed = lines.slice(-MAX_LEGACY_APPLICATION_LOG_ENTRIES);
+      await atomicWriteFile(filePath, `${trimmed.join(`
+`)}
+`);
+    }
+  } finally {
+    if (release)
+      await release().catch(() => {});
+  }
 }
 async function bumpCountersBatch(directory, bumps) {
   const filteredBumps = bumps.filter((b) => b.ids.length > 0);
@@ -112088,14 +112447,10 @@ async function bumpCountersBatch(directory, bumps) {
     return updated;
   };
   const swarmPath = resolveSwarmKnowledgePath(directory);
-  const swarm = await readKnowledge(swarmPath);
-  if (applyOne(swarm))
-    await rewriteKnowledge(swarmPath, swarm);
+  await transactKnowledge(swarmPath, (swarm) => applyOne(swarm) ? swarm : null);
   const hivePath = resolveHiveKnowledgePath();
   if (existsSync69(hivePath)) {
-    const hive = await readKnowledge(hivePath);
-    if (applyOne(hive))
-      await rewriteKnowledge(hivePath, hive);
+    await transactKnowledge(hivePath, (hive) => applyOne(hive) ? hive : null);
   }
 }
 async function bumpCounters(directory, ids, field) {
@@ -112165,7 +112520,7 @@ init_knowledge_events();
 // src/hooks/knowledge-injector.ts
 init_schema();
 init_manager();
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 
 // src/services/run-memory.ts
 import * as crypto11 from "node:crypto";
@@ -112342,6 +112697,7 @@ init_extractors();
 init_knowledge_escalator();
 init_knowledge_events();
 init_knowledge_store();
+init_model_limits();
 init_search_knowledge();
 init_utils2();
 var INJECTION_SENTINEL = `${String.fromCharCode(8204)}[[KNOWLEDGE-INJECTED]]`;
@@ -112658,7 +113014,7 @@ function injectKnowledgeMessage(output, text) {
   };
   output.messages.splice(insertIdx, 0, knowledgeMessage);
 }
-function createKnowledgeInjectorHook(directory, config3) {
+function createKnowledgeInjectorHook(directory, config3, modelLimitOverrides = {}) {
   function buildContextCacheKey(phase, ctx) {
     const parts2 = [
       String(phase),
@@ -112668,7 +113024,7 @@ function createKnowledgeInjectorHook(directory, config3) {
       ctx.taskId ?? "",
       (ctx.filePaths ?? []).slice(0, 8).join(",")
     ].join("|");
-    return createHash11("sha1").update(parts2).digest("hex").slice(0, 16);
+    return createHash12("sha1").update(parts2).digest("hex").slice(0, 16);
   }
   let lastSeenCacheKey = null;
   let cachedInjectionText = null;
@@ -112679,7 +113035,9 @@ function createKnowledgeInjectorHook(directory, config3) {
     const plan = await loadPlan(directory);
     const currentPhase = plan?.current_phase ?? 1;
     const CHARS_PER_TOKEN = 1 / 0.33;
-    const MODEL_LIMIT_CHARS = Math.floor(128000 * CHARS_PER_TOKEN);
+    const { modelID, providerID } = extractModelInfo(output.messages);
+    const modelLimitTokens = resolveModelLimit(modelID, providerID, modelLimitOverrides);
+    const MODEL_LIMIT_CHARS = Math.floor(modelLimitTokens * CHARS_PER_TOKEN);
     const existingChars = output.messages.reduce((sum, msg) => {
       return sum + (msg.parts?.reduce((s, p) => s + (p.text?.length ?? 0), 0) ?? 0);
     }, 0);
@@ -115919,8 +116277,8 @@ async function cleanupOldTrajectoryFiles(directory, maxAgeDays = 7) {
           continue;
         const filePath = path131.join(dirPath, entry.name);
         try {
-          const stat10 = await fs81.stat(filePath);
-          if (now - stat10.mtimeMs > cutoffMs) {
+          const stat11 = await fs81.stat(filePath);
+          if (now - stat11.mtimeMs > cutoffMs) {
             await fs81.unlink(filePath);
           }
         } catch {}
@@ -118786,8 +119144,8 @@ function estimateCyclomaticComplexity(content) {
 }
 function getComplexityForFile(filePath) {
   try {
-    const stat10 = fs87.statSync(filePath);
-    if (stat10.size > MAX_FILE_SIZE_BYTES4) {
+    const stat11 = fs87.statSync(filePath);
+    if (stat11.size > MAX_FILE_SIZE_BYTES4) {
       return null;
     }
     const content = fs87.readFileSync(filePath, "utf-8");
@@ -118988,8 +119346,8 @@ async function computeDuplicationRatio(files, workingDir) {
       continue;
     }
     try {
-      const stat10 = fs87.statSync(fullPath);
-      if (stat10.size > MAX_FILE_SIZE_BYTES4) {
+      const stat11 = fs87.statSync(fullPath);
+      if (stat11.size > MAX_FILE_SIZE_BYTES4) {
         continue;
       }
       const content = fs87.readFileSync(fullPath, "utf-8");
@@ -119449,8 +119807,8 @@ async function getGitChurn(days, directory) {
 }
 function getComplexityForFile2(filePath) {
   try {
-    const stat10 = fs88.statSync(filePath);
-    if (stat10.size > MAX_FILE_SIZE_BYTES5) {
+    const stat11 = fs88.statSync(filePath);
+    if (stat11.size > MAX_FILE_SIZE_BYTES5) {
       return null;
     }
     const content = fs88.readFileSync(filePath, "utf-8");
@@ -121919,8 +122277,8 @@ function readEvidenceFiles(evidenceDir, _cwd) {
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
-      const stat10 = fs93.lstatSync(filePath);
-      if (!stat10.isFile()) {
+      const stat11 = fs93.lstatSync(filePath);
+      if (!stat11.isFile()) {
         continue;
       }
     } catch {
@@ -122342,11 +122700,11 @@ var external_skill_delete = createSwarmTool({
 // src/tools/external-skill-discover.ts
 init_zod();
 init_loader();
-import { createHash as createHash13, randomUUID as randomUUID13 } from "node:crypto";
+import { createHash as createHash14, randomUUID as randomUUID13 } from "node:crypto";
 
 // src/services/external-skill-validator.ts
 init_knowledge_validator();
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 var PROMPT_INJECTION_PATTERNS = [
   {
     pattern: /system\s*:/i,
@@ -122480,31 +122838,31 @@ var UNSAFE_INSTRUCTION_PATTERNS = [
     pattern: /\bkill\s+-9\b/,
     name: "force_kill",
     description: "Force process termination",
-    severity: "error"
+    severity: "warning"
   },
   {
     pattern: /\bpkill\b/,
     name: "process_group_kill",
     description: "Process group kill",
-    severity: "error"
+    severity: "warning"
   },
   {
     pattern: /\bkillall\b/,
     name: "kill_all_processes",
     description: "Kill all processes by name",
-    severity: "error"
+    severity: "warning"
   },
   {
     pattern: /`[^`]*`/,
     name: "backtick_execution",
     description: "Backtick shell execution",
-    severity: "error"
+    severity: "warning"
   },
   {
     pattern: /\$\([^)]*\)/,
     name: "shell_substitution",
     description: "Shell command substitution",
-    severity: "error"
+    severity: "warning"
   },
   {
     pattern: /disable\s+.{0,50}firewall/i,
@@ -122639,6 +122997,9 @@ function scanInvisibleFormatChars(text, fieldName) {
   }
   return findings;
 }
+function stripMarkdownCodeForUnsafeScan(text) {
+  return text.replace(/```[\s\S]*?```/g, " ").replace(/~~~[\s\S]*?~~~/g, " ").replace(/`[^`\n]*`/g, " ");
+}
 function scanPromptInjection(candidate, trustLevel = "low") {
   const fields = extractCandidateFields(candidate);
   const findings = [];
@@ -122705,8 +123066,9 @@ function scanUnsafeInstructions(candidate, trustLevel = "low") {
   const fieldsScanned = [];
   for (const { field, value } of fields) {
     fieldsScanned.push(field);
+    const scanValue = field === "skill_body" ? stripMarkdownCodeForUnsafeScan(value) : value;
     for (const entry of UNSAFE_INSTRUCTION_PATTERNS) {
-      const match = entry.pattern.exec(value);
+      const match = entry.pattern.exec(scanValue);
       if (match !== null) {
         findings.push({
           pattern: entry.name,
@@ -122877,7 +123239,8 @@ function evaluateCandidate(candidate, options) {
 }
 var _internals78 = {
   getTimestamp: () => new Date().toISOString(),
-  computeSha256: (content) => createHash12("sha256").update(content).digest("hex")
+  computeSha256: (content) => createHash13("sha256").update(content).digest("hex"),
+  stripMarkdownCodeForUnsafeScan
 };
 
 // src/tools/external-skill-discover.ts
@@ -122898,7 +123261,7 @@ var _internals79 = {
     return { content, finalUrl: response.url };
   },
   getTimestamp: () => new Date().toISOString(),
-  computeSha256: (content) => createHash13("sha256").update(content).digest("hex"),
+  computeSha256: (content) => createHash14("sha256").update(content).digest("hex"),
   uuid: () => randomUUID13()
 };
 var SOURCE_TRUST_LEVELS = {
@@ -123284,7 +123647,7 @@ var external_skill_list = createSwarmTool({
 // src/tools/external-skill-promote.ts
 init_zod();
 init_loader();
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 import * as fs95 from "node:fs/promises";
 import * as path146 from "node:path";
 init_create_tool();
@@ -123449,7 +123812,7 @@ var external_skill_promote = createSwarmTool({
         }
         throw writeErr;
       }
-      const promotedContentHash = createHash14("sha256").update(skillMarkdown).digest("hex");
+      const promotedContentHash = createHash15("sha256").update(skillMarkdown).digest("hex");
       const prePromotionHistory = candidate.evaluation_history;
       const lastPrePromotionEntry = prePromotionHistory.length > 0 ? prePromotionHistory[prePromotionHistory.length - 1] : undefined;
       const originalEvaluation = lastPrePromotionEntry ? {
@@ -124418,8 +124781,8 @@ var git_blame = createSwarmTool({
         lines: []
       });
     }
-    const stat10 = fs97.statSync(resolvedPath);
-    if (stat10.isDirectory()) {
+    const stat11 = fs97.statSync(resolvedPath);
+    if (stat11.isDirectory()) {
       return JSON.stringify({
         error: "path is a directory, not a file",
         file: file3,
@@ -124536,6 +124899,102 @@ var git_blame = createSwarmTool({
 
 // src/tools/gitingest.ts
 init_zod();
+
+// src/services/external-content-scanner.ts
+init_knowledge_validator();
+function scanInvisibleFormatChars2(text) {
+  const findings = [];
+  const matches = text.match(INVISIBLE_FORMAT_CHARS);
+  if (matches !== null && matches.length > 0) {
+    for (const match of matches) {
+      findings.push({
+        pattern: "invisible_format_chars",
+        field: "external_content",
+        description: `Invisible format characters detected (${matches.length} occurrence(s))`,
+        severity: "error",
+        match: match.slice(0, 100)
+      });
+    }
+  }
+  return findings;
+}
+function neutralizeThreatPatterns(text, findings) {
+  if (findings.length === 0) {
+    return text;
+  }
+  let result = text;
+  for (const finding of findings.filter((f) => f.severity === "error")) {
+    const escapedMatch = finding.match.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(escapedMatch, "g");
+    result = result.replace(pattern, () => `[EXTERNAL_CONTENT_THREAT: ${finding.pattern}] ${finding.match} [/EXTERNAL_CONTENT_THREAT]`);
+  }
+  return result;
+}
+function scanExternalContent(text, options) {
+  const trustLevel = options?.trustLevel ?? "low";
+  const maxLength = options?.maxLength ?? 50000;
+  if (text == null) {
+    text = "";
+  }
+  const originalLength = text.length;
+  const findings = [];
+  if (text.length > maxLength) {
+    findings.push({
+      pattern: "oversized_content",
+      field: "external_content",
+      description: `External content exceeds safe size threshold (${text.length} > ${maxLength} bytes)`,
+      severity: "error",
+      match: `${text.length} bytes`
+    });
+  }
+  findings.push(...scanInvisibleFormatChars2(text));
+  for (const entry of PROMPT_INJECTION_PATTERNS) {
+    const match = entry.pattern.exec(text);
+    if (match !== null) {
+      findings.push({
+        pattern: entry.name,
+        field: "external_content",
+        description: entry.description,
+        severity: entry.severity,
+        match: match[0]
+      });
+    }
+  }
+  for (const entry of UNSAFE_INSTRUCTION_PATTERNS) {
+    const match = entry.pattern.exec(text);
+    if (match !== null) {
+      findings.push({
+        pattern: entry.name,
+        field: "external_content",
+        description: entry.description,
+        severity: entry.severity,
+        match: match[0]
+      });
+    }
+  }
+  const promoteWarnings = trustLevel === "low";
+  const modulatedFindings = findings.map((f) => promoteWarnings && f.severity === "warning" ? { ...f, severity: "error" } : f);
+  const hasErrors = modulatedFindings.some((f) => f.severity === "error");
+  const hasWarnings = modulatedFindings.some((f) => f.severity === "warning");
+  let threatLevel;
+  if (hasErrors) {
+    threatLevel = "error";
+  } else if (hasWarnings) {
+    threatLevel = "warning";
+  } else {
+    threatLevel = "none";
+  }
+  const neutralized = neutralizeThreatPatterns(text, modulatedFindings.filter((f) => f.severity === "error"));
+  return {
+    clean: threatLevel === "none",
+    findings: modulatedFindings,
+    threatLevel,
+    originalLength,
+    neutralized
+  };
+}
+
+// src/tools/gitingest.ts
 init_create_tool();
 var GITINGEST_TIMEOUT_MS = 1e4;
 var GITINGEST_MAX_RESPONSE_BYTES = 5242880;
@@ -124573,7 +125032,31 @@ async function fetchGitingest(args2) {
       if (Number.isFinite(contentLength) && contentLength > GITINGEST_MAX_RESPONSE_BYTES) {
         throw new Error("gitingest response too large");
       }
-      const text = await response.text();
+      let text;
+      const reader = response.body?.getReader();
+      if (reader) {
+        let buffer = "";
+        const decoder = new TextDecoder;
+        let totalBytes = 0;
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            totalBytes += value.byteLength;
+            if (totalBytes > GITINGEST_MAX_RESPONSE_BYTES) {
+              throw new Error("gitingest response too large");
+            }
+            buffer += decoder.decode(value, { stream: true });
+          }
+          buffer += decoder.decode();
+          text = buffer;
+        } finally {
+          reader.cancel().catch(() => {});
+        }
+      } else {
+        text = await response.text();
+      }
       if (Buffer.byteLength(text) > GITINGEST_MAX_RESPONSE_BYTES) {
         throw new Error("gitingest response too large");
       }
@@ -124583,11 +125066,24 @@ async function fetchGitingest(args2) {
       } catch {
         throw new Error(`gitingest API returned non-JSON response (${text.length} chars, starts: ${text.slice(0, 80)})`);
       }
-      return `${data.summary}
+      const combined = `${data.summary}
 
 ${data.tree}
 
 ${data.content}`;
+      const scanResult = scanExternalContent(combined, { trustLevel: "low" });
+      let result = combined;
+      if (!scanResult.clean) {
+        const threatSummary = scanResult.findings.filter((f) => f.severity === "error").map((f) => `- ${f.pattern}: ${f.description}`).join(`
+`);
+        result = `[GITINGEST SECURITY NOTE: External repository content scanned and contains potential threat patterns]
+${threatSummary}
+
+[Content follows with threats marked for LLM awareness]
+
+${scanResult.neutralized}`;
+      }
+      return result;
     } catch (error93) {
       if (error93 instanceof DOMException && (error93.name === "TimeoutError" || error93.name === "AbortError")) {
         if (attempt >= GITINGEST_MAX_RETRIES) {
@@ -124806,9 +125302,9 @@ function findSourceFiles3(dir, files = [], stats = { skippedDirs: [], skippedFil
       continue;
     }
     const fullPath = path150.join(dir, entry);
-    let stat10;
+    let stat11;
     try {
-      stat10 = fs98.statSync(fullPath);
+      stat11 = fs98.statSync(fullPath);
     } catch (e) {
       stats.fileErrors.push({
         path: fullPath,
@@ -124816,9 +125312,9 @@ function findSourceFiles3(dir, files = [], stats = { skippedDirs: [], skippedFil
       });
       continue;
     }
-    if (stat10.isDirectory()) {
+    if (stat11.isDirectory()) {
       findSourceFiles3(fullPath, files, stats);
-    } else if (stat10.isFile()) {
+    } else if (stat11.isFile()) {
       const ext = path150.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS3.includes(ext)) {
         files.push(fullPath);
@@ -124913,8 +125409,8 @@ var imports = createSwarmTool({
         if (consumers.length >= MAX_CONSUMERS)
           break;
         try {
-          const stat10 = fs98.statSync(filePath);
-          if (stat10.size > MAX_FILE_SIZE_BYTES7) {
+          const stat11 = fs98.statSync(filePath);
+          if (stat11.size > MAX_FILE_SIZE_BYTES7) {
             skippedFileCount++;
             continue;
           }
@@ -125276,10 +125772,12 @@ init_knowledge_store();
 init_logger();
 init_create_tool();
 var MODES2 = ["archive", "quarantine", "purge"];
+var TIERS = ["swarm", "hive"];
 var knowledge_archive = createSwarmTool({
-  description: "Archive (default), quarantine, or purge a swarm knowledge entry by ID, appending an immutable audit tombstone. 'archive'/'quarantine' set the entry status reversibly and hide it from recall; 'purge' hard-deletes and requires allow_purge:true.",
+  description: "Archive (default), quarantine, or purge a swarm or hive knowledge entry by ID, appending an immutable audit tombstone. 'archive'/'quarantine' set the entry status reversibly and hide it from recall; 'purge' hard-deletes and requires allow_purge:true.",
   args: {
     id: exports_external.string().min(1).describe("UUID of the knowledge entry"),
+    tier: exports_external.enum(TIERS).optional().describe("Knowledge tier to modify; default 'swarm'"),
     reason: exports_external.string().min(1).max(500).describe("Why the entry is being archived/quarantined/purged"),
     evidence: exports_external.string().max(1000).optional().describe('Supporting evidence (e.g. "ignored 8 times, contradicted by tests")'),
     mode: exports_external.enum(MODES2).optional().describe("Default 'archive'"),
@@ -125302,6 +125800,7 @@ var knowledge_archive = createSwarmTool({
       });
     }
     const evidence = typeof a.evidence === "string" ? a.evidence : undefined;
+    const tier = a.tier === "hive" ? "hive" : "swarm";
     const mode = a.mode === "quarantine" || a.mode === "purge" ? a.mode : "archive";
     if (mode === "purge" && a.allow_purge !== true) {
       return JSON.stringify({
@@ -125309,44 +125808,40 @@ var knowledge_archive = createSwarmTool({
         error: "purge requires allow_purge:true (admin flag)"
       });
     }
-    const swarmPath = resolveSwarmKnowledgePath(directory);
-    let entries;
-    try {
-      entries = await readKnowledge(swarmPath);
-    } catch (err2) {
-      return JSON.stringify({
-        success: false,
-        error: err2 instanceof Error ? err2.message : "Unknown error"
-      });
-    }
-    const target = entries.find((e) => e.id === id);
-    if (!target) {
-      return JSON.stringify({ success: false, message: "entry not found" });
-    }
-    const previousStatus = target.status;
+    const knowledgePath = tier === "hive" ? resolveHiveKnowledgePath() : resolveSwarmKnowledgePath(directory);
+    let found = false;
+    let previousStatus;
     const now = new Date().toISOString();
-    let nextEntries;
     let resultStatus;
-    if (mode === "purge") {
-      warn(`[knowledge_archive] PURGE: hard-deleting entry id=${id} actor=${ctx?.agent ?? "unknown"} reason=${reason}`);
-      nextEntries = entries.filter((e) => e.id !== id);
-      resultStatus = "purged";
-    } else {
-      const newStatus = mode === "quarantine" ? "quarantined" : "archived";
-      nextEntries = entries.map((e) => e.id === id ? { ...e, status: newStatus, updated_at: now } : e);
-      resultStatus = newStatus;
-    }
     try {
-      await rewriteKnowledge(swarmPath, nextEntries);
+      await transactKnowledge(knowledgePath, (entries) => {
+        const target = entries.find((e) => e.id === id);
+        if (!target)
+          return null;
+        found = true;
+        previousStatus = target.status;
+        if (mode === "purge") {
+          warn(`[knowledge_archive] PURGE: hard-deleting ${tier} entry id=${id} actor=${ctx?.agent ?? "unknown"} reason=${reason}`);
+          resultStatus = "purged";
+          return entries.filter((e) => e.id !== id);
+        }
+        const newStatus = mode === "quarantine" ? "quarantined" : "archived";
+        resultStatus = newStatus;
+        return entries.map((e) => e.id === id ? { ...e, status: newStatus, updated_at: now } : e);
+      });
     } catch (err2) {
       return JSON.stringify({
         success: false,
         error: err2 instanceof Error ? err2.message : "Unknown error"
       });
     }
+    if (!found) {
+      return JSON.stringify({ success: false, message: "entry not found" });
+    }
     await recordKnowledgeEvent(directory, {
       type: "archived",
       entry_id: id,
+      tier,
       actor: ctx?.agent ?? "unknown",
       reason,
       mode,
@@ -125356,6 +125851,7 @@ var knowledge_archive = createSwarmTool({
     return JSON.stringify({
       success: true,
       id,
+      tier,
       mode,
       previous_status: previousStatus,
       status: resultStatus
@@ -130326,12 +130822,11 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
       const projectName = path166.basename(dir);
-      const skillImproverCfg = SkillImproverConfigSchema.parse(config3.skill_improver ?? {});
       const curationResult = await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig, {
         llmDelegate: createCuratorLLMDelegate(dir, "phase", sessionID),
         enrichmentQuota: {
-          maxCalls: skillImproverCfg.max_calls_per_day,
-          window: skillImproverCfg.quota_window
+          maxCalls: knowledgeConfig.enrichment.max_calls_per_day,
+          window: knowledgeConfig.enrichment.quota_window
         }
       });
       if (curationResult) {
@@ -132432,8 +132927,8 @@ async function placeholderScan(input, directory) {
     }
     let content;
     try {
-      const stat10 = fs115.statSync(fullPath);
-      if (stat10.size > MAX_FILE_SIZE) {
+      const stat11 = fs115.statSync(fullPath);
+      if (stat11.size > MAX_FILE_SIZE) {
         continue;
       }
       content = fs115.readFileSync(fullPath, "utf-8");
@@ -134614,14 +135109,14 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      let stat10;
+      let stat11;
       try {
-        stat10 = fs119.statSync(file3);
+        stat11 = fs119.statSync(file3);
       } catch {
         skippedFiles++;
         continue;
       }
-      if (stat10.size > MAX_FILE_SIZE_BYTES9) {
+      if (stat11.size > MAX_FILE_SIZE_BYTES9) {
         skippedFiles++;
         continue;
       }
@@ -135400,8 +135895,8 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
   for (const entry of entries) {
     const entryPath = path174.join(evidenceDir, entry);
     try {
-      const stat10 = fs120.statSync(entryPath);
-      if (!stat10.isDirectory()) {
+      const stat11 = fs120.statSync(entryPath);
+      if (!stat11.isDirectory()) {
         continue;
       }
     } catch {
@@ -135421,11 +135916,11 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
       if (!resolvedPath.startsWith(evidenceDirResolved + path174.sep)) {
         continue;
       }
-      const stat10 = fs120.lstatSync(evidenceFilePath);
-      if (!stat10.isFile()) {
+      const stat11 = fs120.lstatSync(evidenceFilePath);
+      if (!stat11.isFile()) {
         continue;
       }
-      if (stat10.size > MAX_FILE_SIZE_BYTES9) {
+      if (stat11.size > MAX_FILE_SIZE_BYTES9) {
         continue;
       }
     } catch {
@@ -138176,6 +138671,11 @@ var skill_improve = createSwarmTool({
     const a = args2 ?? {};
     const { config: config3 } = loadPluginConfigWithMeta(directory);
     const parsed = SkillImproverConfigSchema.parse(config3.skill_improver ?? {});
+    const knowledgeConfig = KnowledgeConfigSchema.parse(config3.knowledge ?? {});
+    const enrichmentConfig = knowledgeConfig.enrichment ?? {
+      max_calls_per_day: 30,
+      quota_window: "utc"
+    };
     if (!parsed.enabled) {
       return JSON.stringify({
         ran: false,
@@ -138188,7 +138688,11 @@ var skill_improve = createSwarmTool({
       targets: a.targets,
       mode: a.mode,
       maxCalls: a.max_calls,
-      sessionId: ctx?.sessionID
+      sessionId: ctx?.sessionID,
+      enrichmentQuota: {
+        maxCalls: enrichmentConfig.max_calls_per_day,
+        window: enrichmentConfig.quota_window
+      }
     });
     return JSON.stringify(result, null, 2);
   }
@@ -138270,7 +138774,7 @@ init_zod();
 init_config();
 init_schema();
 init_create_tool();
-import { mkdir as mkdir30, rename as rename12, writeFile as writeFile22 } from "node:fs/promises";
+import { mkdir as mkdir30, rename as rename12, writeFile as writeFile21 } from "node:fs/promises";
 import * as path179 from "node:path";
 var MAX_SPEC_BYTES2 = 256 * 1024;
 var spec_write = createSwarmTool({
@@ -138332,7 +138836,7 @@ ${content}
         }
       } catch {}
     }
-    await writeFile22(tmp, finalContent, "utf-8");
+    await writeFile21(tmp, finalContent, "utf-8");
     await rename12(tmp, target);
     return JSON.stringify({ written: true, path: target, bytes: finalContent.length }, null, 2);
   }
@@ -139551,8 +140055,8 @@ async function syntaxCheck(input, directory, config3) {
         return { result, counted: false, failed: false, skipped: true };
       }
       try {
-        const stat10 = fs126.statSync(fullPath);
-        if (stat10.size >= MAX_FILE_SIZE2) {
+        const stat11 = fs126.statSync(fullPath);
+        if (stat11.size >= MAX_FILE_SIZE2) {
           result.skipped_reason = "file_too_large";
           return { result, counted: false, failed: false, skipped: true };
         }
@@ -139784,15 +140288,15 @@ function findSourceFiles4(dir, files = []) {
       continue;
     }
     const fullPath = path183.join(dir, entry);
-    let stat10;
+    let stat11;
     try {
-      stat10 = fs127.statSync(fullPath);
+      stat11 = fs127.statSync(fullPath);
     } catch {
       continue;
     }
-    if (stat10.isDirectory()) {
+    if (stat11.isDirectory()) {
       findSourceFiles4(fullPath, files);
-    } else if (stat10.isFile()) {
+    } else if (stat11.isFile()) {
       if (isSupportedExtension(fullPath)) {
         files.push(fullPath);
       }
@@ -139889,8 +140393,8 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const filesToScan = [];
-    const stat10 = fs127.statSync(scanPath);
-    if (stat10.isFile()) {
+    const stat11 = fs127.statSync(scanPath);
+    if (stat11.isFile()) {
       if (isSupportedExtension(scanPath)) {
         filesToScan.push(scanPath);
       } else {
@@ -141010,7 +141514,7 @@ import * as zlib from "node:zlib";
 // src/evidence/documents.ts
 init_utils2();
 init_redaction();
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 import { appendFile as appendFile17, mkdir as mkdir31 } from "node:fs/promises";
 import * as path188 from "node:path";
 var EVIDENCE_CACHE_FILE = "evidence-cache/documents.jsonl";
@@ -141054,7 +141558,7 @@ function createEvidenceDocumentRecord(input, defaultCapturedAt) {
   };
 }
 function createEvidenceDocumentId(input) {
-  const hash4 = createHash16("sha256").update([
+  const hash4 = createHash17("sha256").update([
     input.sourceType,
     input.query ?? "",
     input.title ?? "",
@@ -141951,6 +142455,20 @@ var web_search = createSwarmTool({
         freshness
       });
       const evidence = await captureSearchEvidence(dirResult.directory, policy.query, results);
+      const scannedResults = results.map(({ title, url: url3, snippet }) => {
+        const titleScan = scanExternalContent(title, { trustLevel: "low" });
+        const snippetScan = scanExternalContent(snippet, {
+          trustLevel: "low"
+        });
+        const threatLevel = titleScan.threatLevel === "error" || snippetScan.threatLevel === "error" ? "error" : titleScan.threatLevel === "warning" || snippetScan.threatLevel === "warning" ? "warning" : "none";
+        return {
+          title: titleScan.clean ? title : titleScan.neutralized,
+          url: url3,
+          snippet: snippetScan.clean ? snippet : snippetScan.neutralized,
+          evidenceRef: evidence.refByUrl.get(url3),
+          threatLevel
+        };
+      });
       const ok2 = {
         success: true,
         query: policy.query,
@@ -141959,12 +142477,7 @@ var web_search = createSwarmTool({
         freshness,
         removedStaleYears: policy.removedStaleYears,
         totalResults: results.length,
-        results: results.map(({ title, url: url3, snippet }) => ({
-          title,
-          url: url3,
-          snippet,
-          evidenceRef: evidence.refByUrl.get(url3)
-        })),
+        results: scannedResults,
         evidence: {
           stored: evidence.stored,
           path: evidence.path,
@@ -142104,13 +142617,12 @@ var write_architecture_supervisor_evidence = createSwarmTool({
       if (config3.architectural_supervision?.persist_knowledge_recommendations && args2.knowledge_recommendations.length > 0) {
         const knowledgeConfig = KnowledgeConfigSchema.parse(config3.knowledge ?? {});
         const lessons = args2.knowledge_recommendations.map((r) => r.lesson);
-        const skillImproverCfg = SkillImproverConfigSchema.parse(config3.skill_improver ?? {});
         const result = await curateAndStoreSwarm(lessons, path189.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, {
           skipAutoPromotion: true,
           llmDelegate: createCuratorLLMDelegate(dirResult.directory, "phase"),
           enrichmentQuota: {
-            maxCalls: skillImproverCfg.max_calls_per_day,
-            window: skillImproverCfg.quota_window
+            maxCalls: knowledgeConfig.enrichment.max_calls_per_day,
+            window: knowledgeConfig.enrichment.quota_window
           }
         });
         knowledgeProposed = result.stored;
@@ -143127,11 +143639,16 @@ async function initializeOpenCodeSwarm(ctx) {
   const summaryConfig = SummaryConfigSchema.parse(config3.summaries ?? {});
   const toolSummarizerHook = createToolSummarizerHook(summaryConfig, ctx.directory);
   const knowledgeConfig = KnowledgeConfigSchema.parse(config3.knowledge ?? {});
-  const skillImproverConfig = SkillImproverConfigSchema.parse(config3.skill_improver ?? {});
   const skillPropagationConfig = SkillPropagationConfigSchema.parse(config3.skillPropagation ?? {});
-  const knowledgeCuratorHook = knowledgeConfig.enabled ? createKnowledgeCuratorHook(ctx.directory, knowledgeConfig) : undefined;
+  const knowledgeCuratorHook = knowledgeConfig.enabled ? createKnowledgeCuratorHook(ctx.directory, knowledgeConfig, {
+    llmDelegateFactory: (sessionID) => createCuratorLLMDelegate(ctx.directory, "phase", sessionID),
+    enrichmentQuota: {
+      maxCalls: knowledgeConfig.enrichment.max_calls_per_day,
+      window: knowledgeConfig.enrichment.quota_window
+    }
+  }) : undefined;
   const hivePromoterHook = knowledgeConfig.enabled && knowledgeConfig.hive_enabled ? createHivePromoterHook(ctx.directory, knowledgeConfig) : undefined;
-  const knowledgeInjectorHook = knowledgeConfig.enabled ? createKnowledgeInjectorHook(ctx.directory, knowledgeConfig) : undefined;
+  const knowledgeInjectorHook = knowledgeConfig.enabled ? createKnowledgeInjectorHook(ctx.directory, knowledgeConfig, config3.context_budget?.model_limits ?? {}) : undefined;
   const steeringConsumedHook = createSteeringConsumedHook(ctx.directory);
   const coChangeSuggesterHook = createCoChangeSuggesterHook(ctx.directory);
   const darkMatterDetectorHook = createDarkMatterDetectorHook(ctx.directory);
@@ -143858,8 +144375,8 @@ ${usedByCoderLine}`;
           await safeHook(() => collectDelegateAcksAfter(ctx.directory, input, output))(input, output);
           await safeHook(() => collectReviewerVerdictsAfter(ctx.directory, input, output))(input, output);
           await safeHook(() => microReflectorAfter(ctx.directory, input, output, createCuratorLLMDelegate(ctx.directory, "phase", input.sessionID), {
-            maxCalls: skillImproverConfig.max_calls_per_day,
-            window: skillImproverConfig.quota_window
+            maxCalls: knowledgeConfig.enrichment.max_calls_per_day,
+            window: knowledgeConfig.enrichment.quota_window
           }))(input, output);
         }
         await safeHook(prmHook.toolAfter)(input, output);