opencode-swarm 7.46.0 → 7.46.2

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.46.0",
+    version: "7.46.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",
@@ -59489,6 +59489,244 @@ var init_hive_promoter = __esm(() => {
   init_utils2();
 });
 
+// src/hooks/knowledge-events.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { existsSync as existsSync16 } from "node:fs";
+import { appendFile as appendFile5, mkdir as mkdir6, readFile as readFile7, writeFile as writeFile6 } from "node:fs/promises";
+import * as path28 from "node:path";
+function resolveKnowledgeEventsPath(directory) {
+  return path28.join(directory, ".swarm", "knowledge-events.jsonl");
+}
+function resolveLegacyApplicationLogPath(directory) {
+  return path28.join(directory, ".swarm", "knowledge-application.jsonl");
+}
+function newTraceId() {
+  return randomUUID4();
+}
+function newEventId() {
+  return randomUUID4();
+}
+function withDefaults(event) {
+  return {
+    schema_version: KNOWLEDGE_EVENT_SCHEMA_VERSION,
+    ...event,
+    event_id: event.event_id || newEventId(),
+    timestamp: event.timestamp || new Date().toISOString()
+  };
+}
+async function appendKnowledgeEvent(directory, event) {
+  const populated = withDefaults(event);
+  const filePath = resolveKnowledgeEventsPath(directory);
+  const dirPath = path28.dirname(filePath);
+  await mkdir6(dirPath, { recursive: true });
+  let release;
+  try {
+    release = await import_proper_lockfile5.default.lock(dirPath, {
+      retries: { retries: 200, minTimeout: 10, maxTimeout: 100 }
+    });
+    await appendFile5(filePath, `${JSON.stringify(populated)}
+`, "utf-8");
+    try {
+      const content = await readFile7(filePath, "utf-8");
+      const lines = content.split(`
+`).filter((line) => line.trim().length > 0);
+      if (lines.length > MAX_EVENT_LOG_ENTRIES) {
+        const trimmed = lines.slice(lines.length - MAX_EVENT_LOG_ENTRIES);
+        await writeFile6(filePath, `${trimmed.join(`
+`)}
+`, "utf-8");
+      }
+    } catch (err2) {
+      warn(`[knowledge-events] local cap trim failed (non-fatal): ${err2 instanceof Error ? err2.message : String(err2)}`);
+    }
+  } finally {
+    if (release)
+      await release().catch(() => {});
+  }
+  return populated;
+}
+async function recordKnowledgeEvent(directory, event) {
+  try {
+    return await appendKnowledgeEvent(directory, event);
+  } catch (err2) {
+    warn(`[knowledge-events] recordKnowledgeEvent failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
+    return null;
+  }
+}
+async function readKnowledgeEvents(directory) {
+  const filePath = resolveKnowledgeEventsPath(directory);
+  if (!existsSync16(filePath))
+    return [];
+  const content = await readFile7(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;
+}
+async function readLegacyApplicationRecords(directory) {
+  const filePath = resolveLegacyApplicationLogPath(directory);
+  if (!existsSync16(filePath))
+    return [];
+  const content = await readFile7(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;
+}
+function emptyRollup() {
+  return {
+    shown_count: 0,
+    acknowledged_count: 0,
+    applied_explicit_count: 0,
+    ignored_count: 0,
+    violated_count: 0,
+    contradicted_count: 0,
+    succeeded_after_shown_count: 0,
+    failed_after_shown_count: 0,
+    partial_after_shown_count: 0
+  };
+}
+function get(map3, id) {
+  let r = map3.get(id);
+  if (!r) {
+    r = emptyRollup();
+    map3.set(id, r);
+  }
+  return r;
+}
+function maxIso(current, candidate) {
+  if (!current)
+    return candidate;
+  return candidate > current ? candidate : current;
+}
+function recomputeCounters(events, legacyRecords = []) {
+  const map3 = new Map;
+  const retrievedIds = new Set;
+  for (const e of events) {
+    switch (e.type) {
+      case "retrieved": {
+        for (const id of e.result_ids) {
+          retrievedIds.add(id);
+          get(map3, id).shown_count += 1;
+        }
+        break;
+      }
+      case "acknowledged": {
+        const r = get(map3, e.knowledge_id);
+        r.acknowledged_count += 1;
+        r.last_acknowledged_at = maxIso(r.last_acknowledged_at, e.timestamp);
+        break;
+      }
+      case "applied": {
+        const r = get(map3, e.knowledge_id);
+        r.applied_explicit_count += 1;
+        r.last_applied_at = maxIso(r.last_applied_at, e.timestamp);
+        break;
+      }
+      case "ignored":
+        get(map3, e.knowledge_id).ignored_count += 1;
+        break;
+      case "violated":
+        get(map3, e.knowledge_id).violated_count += 1;
+        break;
+      case "contradicted":
+        get(map3, e.knowledge_id).contradicted_count += 1;
+        break;
+      case "outcome": {
+        if (!e.knowledge_id)
+          break;
+        const r = get(map3, e.knowledge_id);
+        if (e.outcome === "success")
+          r.succeeded_after_shown_count += 1;
+        else if (e.outcome === "failure")
+          r.failed_after_shown_count += 1;
+        else if (e.outcome === "partial")
+          r.partial_after_shown_count += 1;
+        break;
+      }
+    }
+  }
+  for (const rec of legacyRecords) {
+    const r = get(map3, rec.knowledgeId);
+    switch (rec.result) {
+      case "shown":
+        if (!retrievedIds.has(rec.knowledgeId))
+          r.shown_count += 1;
+        break;
+      case "acknowledged":
+        r.acknowledged_count += 1;
+        r.last_acknowledged_at = maxIso(r.last_acknowledged_at, rec.timestamp);
+        break;
+      case "applied":
+        r.applied_explicit_count += 1;
+        r.last_applied_at = maxIso(r.last_applied_at, rec.timestamp);
+        break;
+      case "ignored":
+        r.ignored_count += 1;
+        break;
+      case "violated":
+        r.violated_count += 1;
+        break;
+    }
+  }
+  return map3;
+}
+async function readKnowledgeCounterRollups(directory) {
+  try {
+    const [events, legacyRecords] = await Promise.all([
+      readKnowledgeEvents(directory),
+      readLegacyApplicationRecords(directory)
+    ]);
+    return recomputeCounters(events, legacyRecords);
+  } catch (err2) {
+    warn(`[knowledge-events] readKnowledgeCounterRollups failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
+    return new Map;
+  }
+}
+function effectiveRetrievalOutcomes(stored, rollup) {
+  const base = stored ?? {
+    applied_count: 0,
+    succeeded_after_count: 0,
+    failed_after_count: 0
+  };
+  if (!rollup)
+    return base;
+  return {
+    ...base,
+    ...rollup
+  };
+}
+var import_proper_lockfile5, KNOWLEDGE_EVENT_SCHEMA_VERSION = 1, MAX_EVENT_LOG_ENTRIES = 5000, RECEIPT_EVENT_TYPES;
+var init_knowledge_events = __esm(() => {
+  init_logger();
+  import_proper_lockfile5 = __toESM(require_proper_lockfile(), 1);
+  RECEIPT_EVENT_TYPES = new Set([
+    "acknowledged",
+    "applied",
+    "ignored",
+    "contradicted",
+    "violated"
+  ]);
+});
+
 // src/hooks/knowledge-curator.ts
 function pruneSeenRetroSections() {
   const cutoff = Date.now() - 86400000;
@@ -59730,11 +59968,12 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
 async function runAutoPromotion(directory, config3) {
   const knowledgePath = resolveSwarmKnowledgePath(directory);
   const entries = await readKnowledge(knowledgePath) ?? [];
+  const counterRollups = await readKnowledgeCounterRollups(directory);
   let changed = false;
   for (const entry of entries) {
     if (entry.status === "promoted")
       continue;
-    if (computeOutcomeSignal(entry.retrieval_outcomes) <= OUTCOME_PROMOTION_BLOCK) {
+    if (computeOutcomeSignal(effectiveRetrievalOutcomes(entry.retrieval_outcomes, counterRollups.get(entry.id))) <= OUTCOME_PROMOTION_BLOCK) {
       continue;
     }
     const distinctPhases = new Set((entry.confirmed_by ?? []).map((c) => c.phase_number)).size;
@@ -59836,6 +60075,7 @@ function createKnowledgeCuratorHook(directory, config3) {
 }
 var seenRetroSections, OUTCOME_PROMOTION_BLOCK = -0.3, _internals21;
 var init_knowledge_curator = __esm(() => {
+  init_knowledge_events();
   init_knowledge_store();
   init_knowledge_validator();
   init_utils2();
@@ -59958,11 +60198,11 @@ var init_skill_improver_llm_factory = __esm(() => {
 });
 
 // src/services/skill-improver-quota.ts
-import { existsSync as existsSync16 } from "node:fs";
-import { mkdir as mkdir6, readFile as readFile7, rename as rename4, writeFile as writeFile6 } from "node:fs/promises";
-import * as path28 from "node:path";
+import { existsSync as existsSync17 } from "node:fs";
+import { mkdir as mkdir7, readFile as readFile8, rename as rename4, writeFile as writeFile7 } from "node:fs/promises";
+import * as path29 from "node:path";
 async function acquireLock(dir) {
-  const acquire = import_proper_lockfile5.default.lock(dir, LOCK_RETRY_OPTS);
+  const acquire = import_proper_lockfile6.default.lock(dir, LOCK_RETRY_OPTS);
   let timer;
   const timeout = new Promise((_, reject) => {
     timer = setTimeout(() => {
@@ -59978,7 +60218,7 @@ async function acquireLock(dir) {
   }
 }
 function resolveQuotaPath(directory) {
-  return path28.join(directory, ".swarm", "skill-improver-quota.json");
+  return path29.join(directory, ".swarm", "skill-improver-quota.json");
 }
 function todayKey(window2, now = new Date) {
   if (window2 === "utc") {
@@ -59990,10 +60230,10 @@ function todayKey(window2, now = new Date) {
   return `${yr}-${m}-${d}`;
 }
 async function readState(filePath) {
-  if (!existsSync16(filePath))
+  if (!existsSync17(filePath))
     return null;
   try {
-    const raw = await readFile7(filePath, "utf-8");
+    const raw = await readFile8(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.date !== "string" || typeof parsed.calls_used !== "number" || typeof parsed.max_calls !== "number" || parsed.window !== "utc" && parsed.window !== "local") {
       return null;
@@ -60004,9 +60244,9 @@ async function readState(filePath) {
   }
 }
 async function writeState(filePath, state) {
-  await mkdir6(path28.dirname(filePath), { recursive: true });
+  await mkdir7(path29.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}`;
-  await writeFile6(tmp, JSON.stringify(state, null, 2), "utf-8");
+  await writeFile7(tmp, JSON.stringify(state, null, 2), "utf-8");
   await rename4(tmp, filePath);
 }
 async function getQuotaState(directory, opts) {
@@ -60027,10 +60267,10 @@ async function getQuotaState(directory, opts) {
 }
 async function reserveQuota(directory, opts) {
   const filePath = resolveQuotaPath(directory);
-  await mkdir6(path28.dirname(filePath), { recursive: true });
+  await mkdir7(path29.dirname(filePath), { recursive: true });
   let release = null;
   try {
-    release = await acquireLock(path28.dirname(filePath));
+    release = await acquireLock(path29.dirname(filePath));
     const state = await getQuotaState(directory, opts);
     if (state.calls_used + opts.nCalls > opts.maxCalls) {
       return {
@@ -60057,10 +60297,10 @@ async function reserveQuota(directory, opts) {
 }
 async function releaseQuota(directory, opts) {
   const filePath = resolveQuotaPath(directory);
-  await mkdir6(path28.dirname(filePath), { recursive: true });
+  await mkdir7(path29.dirname(filePath), { recursive: true });
   let release = null;
   try {
-    release = await acquireLock(path28.dirname(filePath));
+    release = await acquireLock(path29.dirname(filePath));
     const state = await getQuotaState(directory, opts);
     const next = {
       ...state,
@@ -60077,9 +60317,9 @@ async function releaseQuota(directory, opts) {
     }
   }
 }
-var import_proper_lockfile5, LOCK_ACQUIRE_TIMEOUT_MS = 1e4, LOCK_RETRY_OPTS;
+var import_proper_lockfile6, LOCK_ACQUIRE_TIMEOUT_MS = 1e4, LOCK_RETRY_OPTS;
 var init_skill_improver_quota = __esm(() => {
-  import_proper_lockfile5 = __toESM(require_proper_lockfile(), 1);
+  import_proper_lockfile6 = __toESM(require_proper_lockfile(), 1);
   LOCK_RETRY_OPTS = {
     retries: {
       retries: 30,
@@ -60092,22 +60332,22 @@ var init_skill_improver_quota = __esm(() => {
 });
 
 // src/services/skill-improver.ts
-import { existsSync as existsSync17 } from "node:fs";
-import { mkdir as mkdir7, rename as rename5, writeFile as writeFile7 } from "node:fs/promises";
-import * as path29 from "node:path";
+import { existsSync as existsSync18 } from "node:fs";
+import { mkdir as mkdir8, rename as rename5, writeFile as writeFile8 } from "node:fs/promises";
+import * as path30 from "node:path";
 function timestampSlug(d) {
   return d.toISOString().replace(/[:.]/g, "-");
 }
 async function atomicWrite3(p, content) {
-  await mkdir7(path29.dirname(p), { recursive: true });
+  await mkdir8(path30.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile7(tmp, content, "utf-8");
+  await writeFile8(tmp, content, "utf-8");
   await rename5(tmp, p);
 }
 async function gatherInventory(directory) {
   const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
   const hivePath = resolveHiveKnowledgePath();
-  const hive = existsSync17(hivePath) ? await readKnowledge(hivePath) : [];
+  const hive = existsSync18(hivePath) ? await readKnowledge(hivePath) : [];
   const archived = [...swarm, ...hive].filter((e) => e.status === "archived").length;
   const skills = await listSkills(directory);
   const matureCandidates = swarm.concat(hive).filter((e) => e.status !== "archived" && e.confidence >= 0.85 && !e.generated_skill_slug && (e.confirmed_by ?? []).length >= 2);
@@ -60380,8 +60620,8 @@ async function runSkillImprover(req) {
     }
     throw err2;
   }
-  const proposalDir = path29.join(req.directory, ".swarm", "skill-improver", "proposals");
-  const proposalFile = path29.join(proposalDir, `${timestampSlug(now)}.md`);
+  const proposalDir = path30.join(req.directory, ".swarm", "skill-improver", "proposals");
+  const proposalFile = path30.join(proposalDir, `${timestampSlug(now)}.md`);
   const finalBody = source === "llm" ? buildLLMProposalFrame({
     body: body2,
     targets,
@@ -60777,7 +61017,7 @@ var init_write_retro = __esm(() => {
 
 // src/commands/close.ts
 import { promises as fs17 } from "node:fs";
-import path30 from "node:path";
+import path31 from "node:path";
 async function runAbortableSkillReview(req, timeoutMs) {
   const controller = new AbortController;
   let timeout;
@@ -60833,10 +61073,10 @@ function guaranteeAllPlansComplete(planData) {
 }
 async function handleCloseCommand(directory, args2, options = {}) {
   const planPath = validateSwarmPath(directory, "plan.json");
-  const swarmDir = path30.join(directory, ".swarm");
+  const swarmDir = path31.join(directory, ".swarm");
   let planExists = false;
   let planData = {
-    title: path30.basename(directory) || "Ad-hoc session",
+    title: path31.basename(directory) || "Ad-hoc session",
     phases: []
   };
   try {
@@ -60945,7 +61185,7 @@ async function handleCloseCommand(directory, args2, options = {}) {
       warnings.push(`Session retrospective write threw: ${retroError instanceof Error ? retroError.message : String(retroError)}`);
     }
   }
-  const lessonsFilePath = path30.join(swarmDir, "close-lessons.md");
+  const lessonsFilePath = path31.join(swarmDir, "close-lessons.md");
   let explicitLessons = [];
   try {
     const lessonsText = await fs17.readFile(lessonsFilePath, "utf-8");
@@ -60954,11 +61194,11 @@ async function handleCloseCommand(directory, args2, options = {}) {
   } catch {}
   const retroLessons = [];
   try {
-    const evidenceDir = path30.join(swarmDir, "evidence");
+    const evidenceDir = path31.join(swarmDir, "evidence");
     const evidenceEntries = await fs17.readdir(evidenceDir);
     const retroDirs = evidenceEntries.filter((e) => e.startsWith("retro-")).sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
     for (const retroDir of retroDirs) {
-      const evidencePath = path30.join(evidenceDir, retroDir, "evidence.json");
+      const evidencePath = path31.join(evidenceDir, retroDir, "evidence.json");
       try {
         const content = await fs17.readFile(evidencePath, "utf-8");
         const parsed = JSON.parse(content);
@@ -61093,7 +61333,7 @@ async function handleCloseCommand(directory, args2, options = {}) {
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
   const suffix = Math.random().toString(36).slice(2, 8);
-  const archiveDir = path30.join(swarmDir, "archive", `swarm-${timestamp}-${suffix}`);
+  const archiveDir = path31.join(swarmDir, "archive", `swarm-${timestamp}-${suffix}`);
   let archiveResult = "";
   let archivedFileCount = 0;
   const archivedActiveStateFiles = new Set;
@@ -61101,8 +61341,8 @@ async function handleCloseCommand(directory, args2, options = {}) {
   try {
     await fs17.mkdir(archiveDir, { recursive: true });
     for (const artifact of ARCHIVE_ARTIFACTS) {
-      const srcPath = path30.join(swarmDir, artifact);
-      const destPath = path30.join(archiveDir, artifact);
+      const srcPath = path31.join(swarmDir, artifact);
+      const destPath = path31.join(archiveDir, artifact);
       try {
         await fs17.copyFile(srcPath, destPath);
         archivedFileCount++;
@@ -61112,22 +61352,22 @@ async function handleCloseCommand(directory, args2, options = {}) {
       } catch {}
     }
     for (const dirName of ACTIVE_STATE_DIRS_TO_CLEAN) {
-      const srcDir = path30.join(swarmDir, dirName);
-      const destDir = path30.join(archiveDir, dirName);
+      const srcDir = path31.join(swarmDir, dirName);
+      const destDir = path31.join(archiveDir, dirName);
       try {
         const entries = await fs17.readdir(srcDir);
         if (entries.length > 0) {
           await fs17.mkdir(destDir, { recursive: true });
           for (const entry of entries) {
-            const srcEntry = path30.join(srcDir, entry);
-            const destEntry = path30.join(destDir, entry);
+            const srcEntry = path31.join(srcDir, entry);
+            const destEntry = path31.join(destDir, entry);
             try {
               const stat3 = await fs17.stat(srcEntry);
               if (stat3.isDirectory()) {
                 await fs17.mkdir(destEntry, { recursive: true });
                 const subEntries = await fs17.readdir(srcEntry);
                 for (const sub of subEntries) {
-                  await fs17.copyFile(path30.join(srcEntry, sub), path30.join(destEntry, sub)).catch(() => {});
+                  await fs17.copyFile(path31.join(srcEntry, sub), path31.join(destEntry, sub)).catch(() => {});
                 }
               } else {
                 await fs17.copyFile(srcEntry, destEntry);
@@ -61159,7 +61399,7 @@ async function handleCloseCommand(directory, args2, options = {}) {
         warnings.push(`Preserved ${artifact} because it was not successfully archived.`);
         continue;
       }
-      const filePath = path30.join(swarmDir, artifact);
+      const filePath = path31.join(swarmDir, artifact);
       try {
         await fs17.unlink(filePath);
         cleanedFiles.push(artifact);
@@ -61172,7 +61412,7 @@ async function handleCloseCommand(directory, args2, options = {}) {
     if (!archivedActiveStateDirs.has(dirName)) {
       continue;
     }
-    const dirPath = path30.join(swarmDir, dirName);
+    const dirPath = path31.join(swarmDir, dirName);
     try {
       await fs17.rm(dirPath, { recursive: true, force: true });
       cleanedFiles.push(`${dirName}/`);
@@ -61183,23 +61423,23 @@ async function handleCloseCommand(directory, args2, options = {}) {
     const configBackups = swarmFiles.filter((f) => f.startsWith("config-backup-") && f.endsWith(".json"));
     for (const backup of configBackups) {
       try {
-        await fs17.unlink(path30.join(swarmDir, backup));
+        await fs17.unlink(path31.join(swarmDir, backup));
         configBackupsRemoved++;
       } catch {}
     }
     const ledgerSiblings = swarmFiles.filter((f) => (f.startsWith("plan-ledger.archived-") || f.startsWith("plan-ledger.backup-")) && f.endsWith(".jsonl"));
     for (const sibling of ledgerSiblings) {
       try {
-        await fs17.unlink(path30.join(swarmDir, sibling));
+        await fs17.unlink(path31.join(swarmDir, sibling));
       } catch {}
     }
   } catch {}
   let swarmPlanFilesRemoved = 0;
   const candidates = [
-    path30.join(directory, ".swarm", "SWARM_PLAN.json"),
-    path30.join(directory, ".swarm", "SWARM_PLAN.md"),
-    path30.join(directory, "SWARM_PLAN.json"),
-    path30.join(directory, "SWARM_PLAN.md")
+    path31.join(directory, ".swarm", "SWARM_PLAN.json"),
+    path31.join(directory, ".swarm", "SWARM_PLAN.md"),
+    path31.join(directory, "SWARM_PLAN.json"),
+    path31.join(directory, "SWARM_PLAN.md")
   ];
   for (const candidate of candidates) {
     try {
@@ -61207,12 +61447,12 @@ async function handleCloseCommand(directory, args2, options = {}) {
       swarmPlanFilesRemoved++;
     } catch (err2) {
       if (err2?.code !== "ENOENT") {
-        warnings.push(`Failed to remove ${path30.basename(candidate)}: ${err2 instanceof Error ? err2.message : String(err2)}`);
+        warnings.push(`Failed to remove ${path31.basename(candidate)}: ${err2 instanceof Error ? err2.message : String(err2)}`);
       }
     }
   }
   clearAllScopes(directory);
-  const contextPath = path30.join(swarmDir, "context.md");
+  const contextPath = path31.join(swarmDir, "context.md");
   const contextContent = [
     "# Context",
     "",
@@ -61536,14 +61776,14 @@ var init_concurrency = __esm(() => {
 
 // src/commands/config.ts
 import * as os9 from "node:os";
-import * as path31 from "node:path";
+import * as path32 from "node:path";
 function getUserConfigDir2() {
-  return process.env.XDG_CONFIG_HOME || path31.join(os9.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path32.join(os9.homedir(), ".config");
 }
 async function handleConfigCommand(directory, _args) {
   const config3 = loadPluginConfig(directory);
-  const userConfigPath = path31.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path31.join(directory, ".opencode", "opencode-swarm.json");
+  const userConfigPath = path32.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path32.join(directory, ".opencode", "opencode-swarm.json");
   const lines = [
     "## Swarm Configuration",
     "",
@@ -61679,9 +61919,9 @@ __export(exports_co_change_analyzer, {
   _internals: () => _internals23
 });
 import * as child_process3 from "node:child_process";
-import { randomUUID as randomUUID4 } from "node:crypto";
-import { readdir as readdir2, readFile as readFile8, stat as stat3 } from "node:fs/promises";
-import * as path32 from "node:path";
+import { randomUUID as randomUUID5 } from "node:crypto";
+import { readdir as readdir2, readFile as readFile9, stat as stat3 } from "node:fs/promises";
+import * as path33 from "node:path";
 import { promisify } from "node:util";
 function getExecFileAsync() {
   return promisify(child_process3.execFile);
@@ -61785,7 +62025,7 @@ async function scanSourceFiles(dir) {
   try {
     const entries = await readdir2(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path32.join(dir, entry.name);
+      const fullPath = path33.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (skipDirs.has(entry.name)) {
           continue;
@@ -61793,7 +62033,7 @@ async function scanSourceFiles(dir) {
         const subFiles = await scanSourceFiles(fullPath);
         results.push(...subFiles);
       } else if (entry.isFile()) {
-        const ext = path32.extname(entry.name);
+        const ext = path33.extname(entry.name);
         if ([".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(ext)) {
           results.push(fullPath);
         }
@@ -61807,7 +62047,7 @@ async function getStaticEdges(directory) {
   const sourceFiles = await scanSourceFiles(directory);
   for (const sourceFile of sourceFiles) {
     try {
-      const content = await readFile8(sourceFile, "utf-8");
+      const content = await readFile9(sourceFile, "utf-8");
       const importRegex = /(?:import|require)\s*(?:\(?\s*['"`]|.*?from\s+['"`])([^'"`]+)['"`]/g;
       for (let match = importRegex.exec(content);match !== null; match = importRegex.exec(content)) {
         const importPath = match[1].trim();
@@ -61815,8 +62055,8 @@ async function getStaticEdges(directory) {
           continue;
         }
         try {
-          const sourceDir = path32.dirname(sourceFile);
-          const resolvedPath = path32.resolve(sourceDir, importPath);
+          const sourceDir = path33.dirname(sourceFile);
+          const resolvedPath = path33.resolve(sourceDir, importPath);
           const extensions = [
             "",
             ".ts",
@@ -61841,8 +62081,8 @@ async function getStaticEdges(directory) {
           if (!targetFile) {
             continue;
           }
-          const relSource = path32.relative(directory, sourceFile).replace(/\\/g, "/");
-          const relTarget = path32.relative(directory, targetFile).replace(/\\/g, "/");
+          const relSource = path33.relative(directory, sourceFile).replace(/\\/g, "/");
+          const relTarget = path33.relative(directory, targetFile).replace(/\\/g, "/");
           const [key] = relSource < relTarget ? [`${relSource}::${relTarget}`, relSource, relTarget] : [`${relTarget}::${relSource}`, relTarget, relSource];
           edges.add(key);
         } catch {}
@@ -61854,7 +62094,7 @@ async function getStaticEdges(directory) {
 function isTestImplementationPair(fileA, fileB) {
   const testPatterns = [".test.ts", ".test.js", ".spec.ts", ".spec.js"];
   const getBaseName = (filePath) => {
-    const base = path32.basename(filePath);
+    const base = path33.basename(filePath);
     for (const pattern of testPatterns) {
       if (base.endsWith(pattern)) {
         return base.slice(0, -pattern.length);
@@ -61864,16 +62104,16 @@ function isTestImplementationPair(fileA, fileB) {
   };
   const baseA = getBaseName(fileA);
   const baseB = getBaseName(fileB);
-  return baseA === baseB && baseA !== path32.basename(fileA) && baseA !== path32.basename(fileB);
+  return baseA === baseB && baseA !== path33.basename(fileA) && baseA !== path33.basename(fileB);
 }
 function hasSharedPrefix(fileA, fileB) {
-  const dirA = path32.dirname(fileA);
-  const dirB = path32.dirname(fileB);
+  const dirA = path33.dirname(fileA);
+  const dirB = path33.dirname(fileB);
   if (dirA !== dirB) {
     return false;
   }
-  const baseA = path32.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
-  const baseB = path32.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseA = path33.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseB = path33.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
   if (baseA.startsWith(baseB) || baseB.startsWith(baseA)) {
     return true;
   }
@@ -61928,8 +62168,8 @@ function darkMatterToKnowledgeEntries(pairs, projectName) {
   const entries = [];
   const now = new Date().toISOString();
   for (const pair of pairs.slice(0, 10)) {
-    const baseA = path32.basename(pair.fileA);
-    const baseB = path32.basename(pair.fileB);
+    const baseA = path33.basename(pair.fileA);
+    const baseB = path33.basename(pair.fileB);
     let lesson = `Files ${pair.fileA} and ${pair.fileB} co-change with NPMI=${pair.npmi.toFixed(3)} but have no import relationship. This hidden coupling suggests a shared architectural concern — changes to one likely require changes to the other.`;
     if (lesson.length > 280) {
       lesson = `Files ${baseA} and ${baseB} co-change with NPMI=${pair.npmi.toFixed(3)} but have no import relationship. This hidden coupling suggests a shared architectural concern — changes to one likely require changes to the other.`;
@@ -61942,7 +62182,7 @@ function darkMatterToKnowledgeEntries(pairs, projectName) {
     }
     const confidence = Math.min(0.3 + 0.2 * Math.min(pair.coChangeCount / 10, 1), 0.5);
     entries.push({
-      id: randomUUID4(),
+      id: randomUUID5(),
       tier: "swarm",
       lesson,
       category: "architecture",
@@ -62031,7 +62271,7 @@ var init_co_change_analyzer = __esm(() => {
 });
 
 // src/commands/dark-matter.ts
-import path33 from "node:path";
+import path34 from "node:path";
 async function handleDarkMatterCommand(directory, args2) {
   const options = {};
   for (let i2 = 0;i2 < args2.length; i2++) {
@@ -62063,7 +62303,7 @@ Ensure this is a git repository with commit history.`;
   const output = formatDarkMatterOutput(pairs);
   if (pairs.length > 0) {
     try {
-      const projectName = path33.basename(path33.resolve(directory));
+      const projectName = path34.basename(path34.resolve(directory));
       const entries = darkMatterToKnowledgeEntries(pairs, projectName);
       if (entries.length > 0) {
         const knowledgePath = resolveSwarmKnowledgePath(directory);
@@ -62200,26 +62440,26 @@ var init_deep_dive = __esm(() => {
 
 // src/config/cache-paths.ts
 import * as os10 from "node:os";
-import * as path34 from "node:path";
+import * as path35 from "node:path";
 function getPluginConfigDir() {
-  return path34.join(process.env.XDG_CONFIG_HOME || path34.join(os10.homedir(), ".config"), "opencode");
+  return path35.join(process.env.XDG_CONFIG_HOME || path35.join(os10.homedir(), ".config"), "opencode");
 }
 function getPluginCachePaths() {
-  const cacheBase = process.env.XDG_CACHE_HOME || path34.join(os10.homedir(), ".cache");
+  const cacheBase = process.env.XDG_CACHE_HOME || path35.join(os10.homedir(), ".cache");
   const configDir = getPluginConfigDir();
   const paths = [
-    path34.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
-    path34.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
-    path34.join(configDir, "node_modules", "opencode-swarm")
+    path35.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
+    path35.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
+    path35.join(configDir, "node_modules", "opencode-swarm")
   ];
   if (process.platform === "darwin") {
-    const libCaches = path34.join(os10.homedir(), "Library", "Caches");
-    paths.push(path34.join(libCaches, "opencode", "node_modules", "opencode-swarm"), path34.join(libCaches, "opencode", "packages", "opencode-swarm@latest"));
+    const libCaches = path35.join(os10.homedir(), "Library", "Caches");
+    paths.push(path35.join(libCaches, "opencode", "node_modules", "opencode-swarm"), path35.join(libCaches, "opencode", "packages", "opencode-swarm@latest"));
   }
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || path34.join(os10.homedir(), "AppData", "Local");
-    const appData = process.env.APPDATA || path34.join(os10.homedir(), "AppData", "Roaming");
-    paths.push(path34.join(localAppData, "opencode", "node_modules", "opencode-swarm"), path34.join(localAppData, "opencode", "packages", "opencode-swarm@latest"), path34.join(appData, "opencode", "node_modules", "opencode-swarm"));
+    const localAppData = process.env.LOCALAPPDATA || path35.join(os10.homedir(), "AppData", "Local");
+    const appData = process.env.APPDATA || path35.join(os10.homedir(), "AppData", "Roaming");
+    paths.push(path35.join(localAppData, "opencode", "node_modules", "opencode-swarm"), path35.join(localAppData, "opencode", "packages", "opencode-swarm@latest"), path35.join(appData, "opencode", "node_modules", "opencode-swarm"));
   }
   return paths;
 }
@@ -62339,81 +62579,6 @@ var init_gate_bridge = __esm(() => {
   };
 });
 
-// src/hooks/knowledge-events.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
-import { existsSync as existsSync18 } from "node:fs";
-import { appendFile as appendFile5, mkdir as mkdir8, readFile as readFile9 } from "node:fs/promises";
-import * as path35 from "node:path";
-function resolveKnowledgeEventsPath(directory) {
-  return path35.join(directory, ".swarm", "knowledge-events.jsonl");
-}
-function newTraceId() {
-  return randomUUID5();
-}
-function newEventId() {
-  return randomUUID5();
-}
-function withDefaults(event) {
-  return {
-    schema_version: KNOWLEDGE_EVENT_SCHEMA_VERSION,
-    ...event,
-    event_id: event.event_id || newEventId(),
-    timestamp: event.timestamp || new Date().toISOString()
-  };
-}
-async function appendKnowledgeEvent(directory, event) {
-  const populated = withDefaults(event);
-  const filePath = resolveKnowledgeEventsPath(directory);
-  await mkdir8(path35.dirname(filePath), { recursive: true });
-  await appendFile5(filePath, `${JSON.stringify(populated)}
-`, "utf-8");
-  try {
-    await enforceKnowledgeCap(filePath, MAX_EVENT_LOG_ENTRIES);
-  } catch (err2) {
-    warn(`[knowledge-events] enforceKnowledgeCap failed (non-fatal): ${err2 instanceof Error ? err2.message : String(err2)}`);
-  }
-  return populated;
-}
-async function recordKnowledgeEvent(directory, event) {
-  try {
-    return await appendKnowledgeEvent(directory, event);
-  } catch (err2) {
-    warn(`[knowledge-events] recordKnowledgeEvent failed: ${err2 instanceof Error ? err2.message : String(err2)}`);
-    return null;
-  }
-}
-async function readKnowledgeEvents(directory) {
-  const filePath = resolveKnowledgeEventsPath(directory);
-  if (!existsSync18(filePath))
-    return [];
-  const content = await readFile9(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;
-}
-var KNOWLEDGE_EVENT_SCHEMA_VERSION = 1, MAX_EVENT_LOG_ENTRIES = 5000, RECEIPT_EVENT_TYPES;
-var init_knowledge_events = __esm(() => {
-  init_logger();
-  init_knowledge_store();
-  RECEIPT_EVENT_TYPES = new Set([
-    "acknowledged",
-    "applied",
-    "ignored",
-    "contradicted",
-    "violated"
-  ]);
-});
-
 // src/services/version-check.ts
 import { existsSync as existsSync19, mkdirSync as mkdirSync12, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
@@ -66589,7 +66754,7 @@ function withStateLock(directory, fn2) {
       fs21.writeFileSync(lockTarget, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
     }
-    release = lockfile6.lockSync(lockTarget, {
+    release = lockfile7.lockSync(lockTarget, {
       retries: { retries: 5, minTimeout: 5, maxTimeout: 50 },
       stale: 5000
     });
@@ -66889,12 +67054,12 @@ function shouldPauseForDenials(state, config3) {
   }
   return { pause: false };
 }
-var import_proper_lockfile6, lockfile6, STATE_FILE = "full-auto-state.json", MAX_DENIAL_HISTORY = 100, stateUnreadable = false, stateUnreadableReason = "";
+var import_proper_lockfile7, lockfile7, STATE_FILE = "full-auto-state.json", MAX_DENIAL_HISTORY = 100, stateUnreadable = false, stateUnreadableReason = "";
 var init_state2 = __esm(() => {
   init_utils2();
   init_logger();
-  import_proper_lockfile6 = __toESM(require_proper_lockfile(), 1);
-  lockfile6 = import_proper_lockfile6.default;
+  import_proper_lockfile7 = __toESM(require_proper_lockfile(), 1);
+  lockfile7 = import_proper_lockfile7.default;
 });
 
 // src/commands/full-auto.ts
@@ -67920,7 +68085,7 @@ var KNOWLEDGE_SCHEMA_VERSION = 2;
 // src/hooks/knowledge-migrator.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { existsSync as existsSync26, readFileSync as readFileSync14 } from "node:fs";
-import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile9 } from "node:fs/promises";
 import * as path42 from "node:path";
 async function migrateKnowledgeToExternal(_directory, _config) {
   return {
@@ -68151,7 +68316,7 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     migration_tool: "knowledge-migrator.ts"
   };
   await mkdir9(path42.dirname(sentinelPath), { recursive: true });
-  await writeFile8(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
+  await writeFile9(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 var _internals29;
 var init_knowledge_migrator = __esm(() => {
@@ -69233,7 +69398,7 @@ import {
   mkdir as mkdir10,
   readFile as readFile12,
   rename as rename6,
-  writeFile as writeFile9
+  writeFile as writeFile10
 } from "node:fs/promises";
 import * as path43 from "node:path";
 
@@ -69644,7 +69809,7 @@ async function writeJsonlAtomic(filePath, values) {
   const content = values.map((value) => JSON.stringify(value)).join(`
 `) + (values.length > 0 ? `
 ` : "");
-  await writeFile9(tmp, content, "utf-8");
+  await writeFile10(tmp, content, "utf-8");
   await rename6(tmp, filePath);
 }
 var init_local_jsonl_provider = __esm(() => {
@@ -69739,7 +69904,7 @@ var init_prompt_block = __esm(() => {
 
 // src/memory/jsonl-migration.ts
 import { existsSync as existsSync28 } from "node:fs";
-import { copyFile, mkdir as mkdir11, readFile as readFile13, stat as stat4, writeFile as writeFile10 } from "node:fs/promises";
+import { copyFile, mkdir as mkdir11, readFile as readFile13, stat as stat4, writeFile as writeFile11 } from "node:fs/promises";
 import * as path44 from "node:path";
 function resolveMemoryStorageDir(rootDirectory, config3 = {}) {
   const resolved = resolveConfig(config3);
@@ -69787,14 +69952,14 @@ async function writeJsonlExport(rootDirectory, config3, memories, proposals) {
   await mkdir11(exportDir, { recursive: true });
   const memoriesPath = path44.join(exportDir, "memories.jsonl");
   const proposalsPath = path44.join(exportDir, "proposals.jsonl");
-  await writeFile10(memoriesPath, toJsonl(memories), "utf-8");
-  await writeFile10(proposalsPath, toJsonl(proposals), "utf-8");
+  await writeFile11(memoriesPath, toJsonl(memories), "utf-8");
+  await writeFile11(proposalsPath, toJsonl(proposals), "utf-8");
   return { directory: exportDir, memoriesPath, proposalsPath };
 }
 async function writeMigrationReport(rootDirectory, report, config3 = {}) {
   const reportPath = path44.join(resolveMemoryStorageDir(rootDirectory, config3), "migration-report.json");
   await mkdir11(path44.dirname(reportPath), { recursive: true });
-  await writeFile10(reportPath, `${JSON.stringify(report, null, 2)}
+  await writeFile11(reportPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
   return reportPath;
 }
@@ -82689,7 +82854,7 @@ ANTI-RATIONALIZATION: Context does not clarify. Models revert to CC training.
 ## IDENTITY
 
 Swarm: {{SWARM_ID}}
-Your agents: {{AGENT_PREFIX}}explorer, {{AGENT_PREFIX}}sme, {{AGENT_PREFIX}}coder, {{AGENT_PREFIX}}reviewer, {{AGENT_PREFIX}}test_engineer, {{AGENT_PREFIX}}critic, {{AGENT_PREFIX}}critic_sounding_board, {{AGENT_PREFIX}}skill_improver, {{AGENT_PREFIX}}spec_writer, {{AGENT_PREFIX}}docs, {{AGENT_PREFIX}}designer
+Your agents: {{AGENT_PREFIX}}explorer, {{AGENT_PREFIX}}sme, {{AGENT_PREFIX}}coder, {{AGENT_PREFIX}}reviewer, {{AGENT_PREFIX}}test_engineer, {{AGENT_PREFIX}}critic, {{AGENT_PREFIX}}critic_sounding_board, {{AGENT_PREFIX}}critic_drift_verifier, {{AGENT_PREFIX}}critic_hallucination_verifier, {{AGENT_PREFIX}}critic_architecture_supervisor, {{AGENT_PREFIX}}skill_improver, {{AGENT_PREFIX}}spec_writer, {{AGENT_PREFIX}}docs, {{AGENT_PREFIX}}designer
 
 ## PROJECT CONTEXT
 Session-start priming block. Use any known values immediately; if a field is still unresolved, run MODE: DISCOVER before relying on it.
@@ -83266,6 +83431,7 @@ Every loaded mode skill is written with active-swarm role phrases. Before follow
 - the active swarm's critic_drift_verifier agent = @{{AGENT_PREFIX}}critic_drift_verifier
 - the active swarm's critic_hallucination_verifier agent = @{{AGENT_PREFIX}}critic_hallucination_verifier
 - the active swarm's critic_sounding_board agent = @{{AGENT_PREFIX}}critic_sounding_board
+- the active swarm's critic_architecture_supervisor agent = @{{AGENT_PREFIX}}critic_architecture_supervisor
 - the active swarm's council_generalist agent = @{{AGENT_PREFIX}}council_generalist
 - the active swarm's council_skeptic agent = @{{AGENT_PREFIX}}council_skeptic
 - the active swarm's council_domain_expert agent = @{{AGENT_PREFIX}}council_domain_expert
@@ -83472,6 +83638,7 @@ ACTION: Load skill file:.opencode/skills/phase-wrap/SKILL.md immediately. Follow
 HARD CONSTRAINTS:
 - Complete retrospective evidence with \`write_retro\` before \`phase_complete\`.
 
+> **NOTE**: The \`critic_oversight\` agent (\`AUTONOMOUS_OVERSIGHT_PROMPT\`) is dispatched only via full-auto mode (\`src/full-auto/oversight.ts\`). It has no architect MODE dispatch path — it is **NOT** reachable from \`MODE: CRITIC-GATE\`, \`MODE: EXECUTE\`, or \`MODE: PHASE-WRAP\`. This is intentional: it serves as the sole quality gate in autonomous oversight mode.
 
 ## FILES
 
@@ -85704,7 +85871,7 @@ COVERAGE REPORTING:
 `;
 
 // src/agents/index.ts
-import { mkdir as mkdir13, writeFile as writeFile11 } from "node:fs/promises";
+import { mkdir as mkdir13, writeFile as writeFile12 } from "node:fs/promises";
 import * as path71 from "node:path";
 function stripSwarmPrefix(agentName, swarmPrefix) {
   if (!swarmPrefix || !agentName)
@@ -86120,7 +86287,7 @@ function getAgentConfigs(config3, directory, sessionId, projectContext) {
       generatedAt: new Date().toISOString(),
       agents: agentToolSnapshot
     }, null, 2);
-    mkdir13(evidenceDir, { recursive: true }).then(() => writeFile11(path71.join(evidenceDir, filename), snapshotData)).catch(() => {});
+    mkdir13(evidenceDir, { recursive: true }).then(() => writeFile12(path71.join(evidenceDir, filename), snapshotData)).catch(() => {});
   }
   return result;
 }
@@ -90659,7 +90826,7 @@ import {
   readFile as readFile16,
   realpath as realpath3,
   stat as stat7,
-  writeFile as writeFile13
+  writeFile as writeFile14
 } from "node:fs/promises";
 import * as path95 from "node:path";
 function normalizeSeparators(filePath) {
@@ -90857,7 +91024,7 @@ async function scanDocIndex(directory) {
   };
   try {
     await mkdir16(path95.dirname(manifestPath), { recursive: true });
-    await writeFile13(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    await writeFile14(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   } catch {}
   return { manifest, cached: false };
 }
@@ -91071,7 +91238,7 @@ var init_doc_scan = __esm(() => {
 
 // src/hooks/knowledge-reader.ts
 import { existsSync as existsSync52 } from "node:fs";
-import { mkdir as mkdir17, readFile as readFile17, writeFile as writeFile14 } from "node:fs/promises";
+import { mkdir as mkdir17, readFile as readFile17, writeFile as writeFile15 } from "node:fs/promises";
 import * as path96 from "node:path";
 function inferCategoriesFromPhase(phaseDescription) {
   const lower = phaseDescription.toLowerCase();
@@ -91128,7 +91295,7 @@ async function recordLessonsShown(directory, lessonIds, currentPhase) {
     const canonicalKey = phaseMatch ? `Phase ${phaseMatch[1]}` : currentPhase;
     shownData[canonicalKey] = lessonIds;
     await mkdir17(path96.dirname(shownFile), { recursive: true });
-    await writeFile14(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
+    await writeFile15(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
   } catch {
     warn("[swarm] Knowledge: failed to record shown lessons");
   }
@@ -91261,7 +91428,7 @@ async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
     const remainingIds = shownIds.filter((id) => !foundInSwarm.has(id));
     if (remainingIds.length === 0) {
       delete shownData[phaseInfo];
-      await writeFile14(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
+      await writeFile15(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
       return;
     }
     const hivePath = resolveHiveKnowledgePath();
@@ -91282,7 +91449,7 @@ async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
       await rewriteKnowledge(hivePath, hiveEntries);
     }
     delete shownData[phaseInfo];
-    await writeFile14(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
+    await writeFile15(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
   } catch {
     warn("[swarm] Knowledge: failed to update retrieval outcomes");
   }
@@ -91399,6 +91566,7 @@ async function searchKnowledge(params) {
     let candidates = await readMergedKnowledge(directory, mergeConfig, projected, {
       skipScopeFilter: !applyScopeFilter
     });
+    const counterRollups = await readKnowledgeCounterRollups(directory);
     candidates = candidates.filter((e) => {
       if (e.status === "quarantined")
         return false;
@@ -91423,15 +91591,21 @@ async function searchKnowledge(params) {
     const metaWeight = hasQuery ? META_WEIGHT : 1;
     const minConf = typeof config3.directive_min_confidence === "number" ? config3.directive_min_confidence : DIRECTIVE_BOOST_MIN_CONFIDENCE;
     const scored = candidates.map((entry) => {
+      const retrievalOutcomes = effectiveRetrievalOutcomes(entry.retrieval_outcomes, counterRollups.get(entry.id));
       const textScore = queryBigrams ? jaccardBigram(queryBigrams, wordBigrams(normalize3(entryText(entry)))) : 0;
       const metaScore = entry.finalScore;
       const ds = context ? scoreDirectiveAgainstContext(entry, context) : { triggerHit: false, actionHit: false, agentHit: false, score: 0 };
       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(entry.retrieval_outcomes) * OUTCOME_RANK_WEIGHT;
+      const outcomeBoost = computeOutcomeSignal(retrievalOutcomes) * OUTCOME_RANK_WEIGHT;
       const finalScore = Math.min(1, Math.max(0, textWeight * textScore + metaWeight * metaScore + ds.score + confBoost + generatedSkillBoost + outcomeBoost + (hasQuery ? statusBoost(entry.status) : 0)));
       const isCritical = entry.directive_priority === "critical" && (ds.triggerHit || ds.actionHit || ds.agentHit);
-      return { ...entry, finalScore, __critical: isCritical };
+      return {
+        ...entry,
+        retrieval_outcomes: retrievalOutcomes,
+        finalScore,
+        __critical: isCritical
+      };
     });
     scored.sort((a, b) => {
       const diff = b.finalScore - a.finalScore;
@@ -91826,7 +92000,7 @@ var init_curator_drift = __esm(() => {
 var exports_project_context = {};
 __export(exports_project_context, {
   buildProjectContext: () => buildProjectContext,
-  _internals: () => _internals67,
+  _internals: () => _internals68,
   LANG_BACKEND_DETECTION_TIMEOUT_MS: () => LANG_BACKEND_DETECTION_TIMEOUT_MS
 });
 import * as fs117 from "node:fs";
@@ -91910,7 +92084,7 @@ function selectLintCommand(backend, directory) {
   return null;
 }
 async function buildProjectContext(directory) {
-  const backend = await _internals67.pickBackend(directory);
+  const backend = await _internals68.pickBackend(directory);
   if (!backend)
     return null;
   const ctx = emptyProjectContext();
@@ -91941,16 +92115,16 @@ async function buildProjectContext(directory) {
   if (backend.prompts.reviewerChecklist.length > 0) {
     ctx.REVIEWER_CHECKLIST = bulletList(backend.prompts.reviewerChecklist);
   }
-  const profiles = _internals67.pickedProfiles(directory);
+  const profiles = _internals68.pickedProfiles(directory);
   if (profiles.length > 1) {
     ctx.PROJECT_CONTEXT_SECONDARY_LANGUAGES = profiles.slice(1).map((p) => p.id).join(", ");
   }
   return ctx;
 }
-var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals67;
+var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals68;
 var init_project_context = __esm(() => {
   init_dispatch();
-  _internals67 = {
+  _internals68 = {
     pickBackend,
     pickedProfiles
   };
@@ -94544,9 +94718,9 @@ function createPhaseMonitorHook(directory, preflightManager, curatorRunner, dele
           const initResult = await runner(directory, curatorConfig, llmDelegate);
           if (initResult.briefing) {
             const briefingPath = path79.join(directory, ".swarm", "curator-briefing.md");
-            const { mkdir: mkdir14, writeFile: writeFile12 } = await import("node:fs/promises");
+            const { mkdir: mkdir14, writeFile: writeFile13 } = await import("node:fs/promises");
             await mkdir14(path79.dirname(briefingPath), { recursive: true });
-            await writeFile12(briefingPath, initResult.briefing, "utf-8");
+            await writeFile13(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",
@@ -102042,7 +102216,7 @@ import * as path101 from "node:path";
 // src/hooks/knowledge-application.ts
 init_logger();
 init_knowledge_store();
-var import_proper_lockfile7 = __toESM(require_proper_lockfile(), 1);
+var import_proper_lockfile8 = __toESM(require_proper_lockfile(), 1);
 import { existsSync as existsSync56 } from "node:fs";
 import { appendFile as appendFile9, mkdir as mkdir18, readFile as readFile18 } from "node:fs/promises";
 import * as path100 from "node:path";
@@ -102461,10 +102635,12 @@ init_state();
 init_logger();
 init_curator_drift();
 init_extractors();
+init_knowledge_events();
 init_knowledge_store();
 init_search_knowledge();
 init_utils2();
 var INJECTION_SENTINEL = "‌[[KNOWLEDGE-INJECTED]]";
+var defaultSearchKnowledge = searchKnowledge;
 function buildKnowledgeBlock(entries, charBudget, cfg, currentProject) {
   if (entries.length === 0)
     return null;
@@ -102642,13 +102818,15 @@ function createKnowledgeInjectorHook(directory, config3) {
       projectName,
       currentPhase: phaseDescription
     };
-    const search = await searchKnowledge({
+    const searchFn = _internals48.searchKnowledge === defaultSearchKnowledge ? searchKnowledge : _internals48.searchKnowledge;
+    const search = await searchFn({
       directory,
       config: config3,
       context: retrievalCtx,
       mode: "auto_injection",
       agent: "architect",
-      sessionId: systemMsg?.info?.sessionID
+      sessionId: systemMsg?.info?.sessionID,
+      emitEvent: false
     });
     const entries = search.results;
     const filteredEntries = filterHighConfidenceKnowledge(entries);
@@ -102741,7 +102919,27 @@ ${freshPreamble}` : `<curator_briefing>${truncatedBriefing}</curator_briefing>`;
     }
     if (cachedShownIds.length > 0) {
       const phaseLabel = `Phase ${currentPhase}`;
-      recordKnowledgeShown(directory, cachedShownIds, {
+      const scoreById = new Map(entries.map((e) => [e.id, e.finalScore]));
+      const ranks = {};
+      const scores = {};
+      cachedShownIds.forEach((id, idx) => {
+        ranks[id] = idx + 1;
+        scores[id] = scoreById.get(id) ?? 0;
+      });
+      await _internals48.recordKnowledgeEvent(directory, {
+        type: "retrieved",
+        trace_id: search.trace_id,
+        session_id: systemMsg?.info?.sessionID ?? "unknown",
+        phase: retrievalCtx.currentPhase,
+        task_id: retrievalCtx.taskId,
+        agent: "architect",
+        query: retrievalCtx.lastUserMessage ?? retrievalCtx.currentPhase ?? "",
+        retrieval_mode: "auto_injection",
+        result_ids: cachedShownIds,
+        ranks,
+        scores
+      });
+      _internals48.recordKnowledgeShown(directory, cachedShownIds, {
         phase: phaseLabel,
         tool: retrievalCtx.currentTool,
         action: retrievalCtx.currentAction,
@@ -102751,6 +102949,11 @@ ${freshPreamble}` : `<curator_briefing>${truncatedBriefing}</curator_briefing>`;
     }
   });
 }
+var _internals48 = {
+  searchKnowledge,
+  recordKnowledgeEvent,
+  recordKnowledgeShown
+};
 
 // src/index.ts
 init_normalize_tool_name();
@@ -102894,7 +103097,7 @@ var TASK_DIVERSITY_WEIGHT = 0.05;
 var CONTEXT_WEIGHT = 0.2;
 var RECENCY_DECAY_MS = 30 * 24 * 60 * 60 * 1000;
 var SKILL_FRONTMATTER_READ_BYTES = 16 * 1024;
-var _internals48 = {
+var _internals49 = {
   computeSkillRelevanceScore: null,
   rankSkillsForContext: null,
   getSkillStats: null,
@@ -103113,7 +103316,7 @@ function formatSkillIndexWithContext(skills, directory) {
   } catch {}
   if (!hasHistory) {
     return skills.map((sp) => {
-      const meta3 = _internals48.readSkillMetadata(sp, directory);
+      const meta3 = _internals49.readSkillMetadata(sp, directory);
       return `  - file:${meta3.path} - ${meta3.name}: ${meta3.description}`;
     }).join(`
 `);
@@ -103121,7 +103324,7 @@ function formatSkillIndexWithContext(skills, directory) {
   const lines = [];
   for (const skillPath of skills) {
     const stats = getSkillStats(skillPath, directory);
-    const meta3 = _internals48.readSkillMetadata(skillPath, directory);
+    const meta3 = _internals49.readSkillMetadata(skillPath, directory);
     const compliancePct = Math.round(stats.complianceRate * 100);
     const topAgentNames = stats.topAgents.slice(0, 3).map((a) => a.agent).join(", ");
     lines.push(`  - file:${meta3.path} - ${meta3.name}: ${meta3.description} (used: ${stats.totalUsage}, compliance: ${compliancePct}%)` + (stats.topAgents.length > 0 ? ` → ${topAgentNames}` : ""));
@@ -103129,15 +103332,15 @@ function formatSkillIndexWithContext(skills, directory) {
   return lines.join(`
 `);
 }
-_internals48.computeSkillRelevanceScore = computeSkillRelevanceScore;
-_internals48.rankSkillsForContext = rankSkillsForContext;
-_internals48.getSkillStats = getSkillStats;
-_internals48.formatSkillIndexWithContext = formatSkillIndexWithContext;
-_internals48.parseSkillFrontmatter = parseSkillFrontmatter;
-_internals48.readSkillMetadata = readSkillMetadata;
-_internals48.extractSkillName = extractSkillName;
-_internals48.computeRecencyScore = computeRecencyScore;
-_internals48.computeContextMatchScore = computeContextMatchScore;
+_internals49.computeSkillRelevanceScore = computeSkillRelevanceScore;
+_internals49.rankSkillsForContext = rankSkillsForContext;
+_internals49.getSkillStats = getSkillStats;
+_internals49.formatSkillIndexWithContext = formatSkillIndexWithContext;
+_internals49.parseSkillFrontmatter = parseSkillFrontmatter;
+_internals49.readSkillMetadata = readSkillMetadata;
+_internals49.extractSkillName = extractSkillName;
+_internals49.computeRecencyScore = computeRecencyScore;
+_internals49.computeContextMatchScore = computeContextMatchScore;
 
 // src/hooks/skill-propagation-gate.ts
 init_skill_usage_log();
@@ -103240,10 +103443,10 @@ function parseYamlValue(value) {
 }
 function loadRoutingSkills(directory, targetAgent) {
   const routingPath = path105.join(directory, ".opencode", "skill-routing.yaml");
-  if (!_internals49.existsSync(routingPath))
+  if (!_internals50.existsSync(routingPath))
     return [];
   try {
-    const content = _internals49.readFileSync(routingPath, "utf-8");
+    const content = _internals50.readFileSync(routingPath, "utf-8");
     const config3 = parseSimpleYaml(content);
     if (!config3?.routing)
       return [];
@@ -103270,7 +103473,7 @@ var SKILL_SEARCH_ROOTS = [
   ".claude/skills"
 ];
 var MAX_SCORING_SESSION_ENTRIES = 500;
-var _internals49 = {
+var _internals50 = {
   readdirSync: fs67.readdirSync.bind(fs67),
   existsSync: fs67.existsSync.bind(fs67),
   statSync: fs67.statSync.bind(fs67),
@@ -103299,11 +103502,11 @@ function discoverAvailableSkills(directory) {
   const results = [];
   for (const root of SKILL_SEARCH_ROOTS) {
     const rootPath = path105.join(directory, root);
-    if (!_internals49.existsSync(rootPath))
+    if (!_internals50.existsSync(rootPath))
       continue;
     let entries;
     try {
-      entries = _internals49.readdirSync(rootPath);
+      entries = _internals50.readdirSync(rootPath);
     } catch {
       continue;
     }
@@ -103311,11 +103514,11 @@ function discoverAvailableSkills(directory) {
       if (entry.startsWith("."))
         continue;
       const skillDir = path105.join(rootPath, entry);
-      if (_internals49.existsSync(path105.join(skillDir, "retired.marker")))
+      if (_internals50.existsSync(path105.join(skillDir, "retired.marker")))
         continue;
       const skillFile = path105.join(skillDir, "SKILL.md");
       try {
-        if (_internals49.statSync(skillDir).isDirectory() && _internals49.existsSync(skillFile)) {
+        if (_internals50.statSync(skillDir).isDirectory() && _internals50.existsSync(skillFile)) {
           results.push(path105.join(root, entry, "SKILL.md").replace(/\\/g, "/"));
         }
       } catch (err2) {
@@ -103347,7 +103550,7 @@ function parseDelegationArgs(args2) {
   }
   if (!targetAgent)
     return null;
-  const skillsField = prompt ? _internals49.extractSkillsFieldFromPrompt(prompt) : "";
+  const skillsField = prompt ? _internals50.extractSkillsFieldFromPrompt(prompt) : "";
   return { targetAgent, skillsField };
 }
 function extractSkillsFieldFromPrompt(prompt) {
@@ -103388,10 +103591,10 @@ function writeWarnEvent2(directory, record3) {
   const filePath = path105.join(directory, ".swarm", "events.jsonl");
   try {
     const dir = path105.dirname(filePath);
-    if (!_internals49.existsSync(dir)) {
-      _internals49.mkdirSync(dir, { recursive: true });
+    if (!_internals50.existsSync(dir)) {
+      _internals50.mkdirSync(dir, { recursive: true });
     }
-    _internals49.appendFileSync(filePath, `${JSON.stringify(record3)}
+    _internals50.appendFileSync(filePath, `${JSON.stringify(record3)}
 `, "utf-8");
   } catch (err2) {
     warn(`[skill-propagation-gate] failed to write warning event: ${err2 instanceof Error ? err2.message : String(err2)}`);
@@ -103442,19 +103645,19 @@ async function skillPropagationGateBefore(directory, input, config3) {
   const baseAgent = stripKnownSwarmPrefix(agentRaw);
   if (baseAgent !== "architect")
     return { blocked: false, reason: null, recommendedSkills: undefined };
-  const parsed = _internals49.parseDelegationArgs(input.args);
+  const parsed = _internals50.parseDelegationArgs(input.args);
   if (!parsed)
     return { blocked: false, reason: null, recommendedSkills: undefined };
   const targetBase = stripKnownSwarmPrefix(parsed.targetAgent);
-  if (!_internals49.SKILL_CAPABLE_AGENTS.has(targetBase))
+  if (!_internals50.SKILL_CAPABLE_AGENTS.has(targetBase))
     return { blocked: false, reason: null, recommendedSkills: undefined };
   const sessionID = typeof input.sessionID === "string" ? input.sessionID : "unknown";
-  const availableSkills = _internals49.discoverAvailableSkills(directory);
+  const availableSkills = _internals50.discoverAvailableSkills(directory);
   const skillsValue = parsed.skillsField.trim();
   if (skillsValue && skillsValue.toLowerCase() !== "none") {
     const prompt = typeof input.args?.prompt === "string" ? String(input.args.prompt) : "";
-    const taskId = _internals49.extractTaskIdFromPrompt(prompt);
-    const skillPaths = _internals49.parseSkillPaths(skillsValue);
+    const taskId = _internals50.extractTaskIdFromPrompt(prompt);
+    const skillPaths = _internals50.parseSkillPaths(skillsValue);
     let coderSkillPaths = [];
     if (prompt) {
       for (const line of prompt.split(`
@@ -103462,7 +103665,7 @@ async function skillPropagationGateBefore(directory, input, config3) {
         const trimmed = line.trim();
         if (trimmed.startsWith("SKILLS_USED_BY_CODER:")) {
           const fieldVal = trimmed.slice("SKILLS_USED_BY_CODER:".length).trim();
-          coderSkillPaths = _internals49.parseSkillPaths(fieldVal);
+          coderSkillPaths = _internals50.parseSkillPaths(fieldVal);
           break;
         }
       }
@@ -103470,7 +103673,7 @@ async function skillPropagationGateBefore(directory, input, config3) {
     const allPaths = [...new Set([...skillPaths, ...coderSkillPaths])];
     for (const skillPath of allPaths) {
       try {
-        _internals49.appendSkillUsageEntry(directory, {
+        _internals50.appendSkillUsageEntry(directory, {
           skillPath,
           agentName: targetBase,
           taskID: taskId,
@@ -103487,17 +103690,17 @@ async function skillPropagationGateBefore(directory, input, config3) {
   let scored = [];
   if (skillsValue && skillsValue.toLowerCase() !== "none" && availableSkills.length > 0) {
     try {
-      const sessionEntries = _internals49.readSkillUsageEntriesTail(directory, {
+      const sessionEntries = _internals50.readSkillUsageEntriesTail(directory, {
         sessionID
       });
-      if (sessionEntries.length > _internals49.MAX_SCORING_SESSION_ENTRIES) {
+      if (sessionEntries.length > _internals50.MAX_SCORING_SESSION_ENTRIES) {
         scoringSkipped = true;
-        warn(`[skill-propagation-gate] skipping scoring — session has ${sessionEntries.length} entries (limit: ${_internals49.MAX_SCORING_SESSION_ENTRIES})`);
+        warn(`[skill-propagation-gate] skipping scoring — session has ${sessionEntries.length} entries (limit: ${_internals50.MAX_SCORING_SESSION_ENTRIES})`);
       } else {
         const prompt = typeof input.args?.prompt === "string" ? String(input.args.prompt) : "";
         scored = availableSkills.map((skillPath) => {
           const skillEntries = sessionEntries.filter((e) => e.skillPath === skillPath);
-          const score = _internals49.computeSkillRelevanceScore(skillPath, prompt, skillEntries);
+          const score = _internals50.computeSkillRelevanceScore(skillPath, prompt, skillEntries);
           return { skillPath, score, usageCount: skillEntries.length };
         }).sort((a, b) => b.score - a.score || b.usageCount - a.usageCount);
         if (scored.length > 0) {
@@ -103511,12 +103714,12 @@ async function skillPropagationGateBefore(directory, input, config3) {
     }
   }
   try {
-    const routingPaths = _internals49.loadRoutingSkills(directory, targetBase);
+    const routingPaths = _internals50.loadRoutingSkills(directory, targetBase);
     if (routingPaths.length > 0) {
       const existingPaths = new Set(scored.map((s) => s.skillPath));
       for (const routingPath of routingPaths) {
         const routedSkillDir = path105.dirname(path105.join(directory, routingPath));
-        if (_internals49.existsSync(path105.join(routedSkillDir, "retired.marker")))
+        if (_internals50.existsSync(path105.join(routedSkillDir, "retired.marker")))
           continue;
         if (!existingPaths.has(routingPath)) {
           scored.push({
@@ -103542,12 +103745,12 @@ async function skillPropagationGateBefore(directory, input, config3) {
       } else if (typeof scored !== "undefined" && scored.length > 0) {
         skillsForIndex = scored.map((r) => r.skillPath);
       }
-      const formattedIndex = _internals49.formatSkillIndexWithContext(skillsForIndex, directory);
+      const formattedIndex = _internals50.formatSkillIndexWithContext(skillsForIndex, directory);
       if (formattedIndex.length > 0) {
         const contextPath = path105.join(directory, ".swarm", "context.md");
         let existingContent = "";
-        if (_internals49.existsSync(contextPath)) {
-          existingContent = _internals49.readFileSync(contextPath, "utf-8");
+        if (_internals50.existsSync(contextPath)) {
+          existingContent = _internals50.readFileSync(contextPath, "utf-8");
         }
         const sectionHeader = "## Available Skills";
         const newSection = `${sectionHeader}
@@ -103567,10 +103770,10 @@ ${newSection}`;
           }
         }
         const swarmDir = path105.dirname(contextPath);
-        if (!_internals49.existsSync(swarmDir)) {
-          _internals49.mkdirSync(swarmDir, { recursive: true });
+        if (!_internals50.existsSync(swarmDir)) {
+          _internals50.mkdirSync(swarmDir, { recursive: true });
         }
-        _internals49.writeFileSync(contextPath, updatedContent, "utf-8");
+        _internals50.writeFileSync(contextPath, updatedContent, "utf-8");
       }
     } catch (err2) {
       warn(`[skill-propagation-gate] failed to write skill index to context.md: ${err2 instanceof Error ? err2.message : String(err2)}`);
@@ -103596,7 +103799,7 @@ ${newSection}`;
   });
   const warningMsg = `Skill propagation warning: Delegating to ${targetBase} without SKILLS field. ` + `Available skills: ${skillNames.join(", ")}`;
   try {
-    _internals49.writeWarnEvent(directory, {
+    _internals50.writeWarnEvent(directory, {
       type: "skill_propagation_warn",
       timestamp: new Date().toISOString(),
       tool: toolName,
@@ -103625,7 +103828,7 @@ async function skillPropagationTransformScan(directory, output, sessionID) {
   let dedupKeys = new Set;
   let existingEntries = [];
   try {
-    existingEntries = _internals49.readSkillUsageEntriesTail(directory, {
+    existingEntries = _internals50.readSkillUsageEntriesTail(directory, {
       sessionID
     });
     dedupKeys = new Set(existingEntries.map((e, i2) => {
@@ -103657,7 +103860,7 @@ async function skillPropagationTransformScan(directory, output, sessionID) {
 `)) {
       const coderMatch = line.trim().match(CODER_SKILLS_PATTERN);
       if (coderMatch) {
-        const parsed = _internals49.parseSkillPaths(coderMatch[1]);
+        const parsed = _internals50.parseSkillPaths(coderMatch[1]);
         skillPaths.push(...parsed);
       }
     }
@@ -103688,7 +103891,7 @@ async function skillPropagationTransformScan(directory, output, sessionID) {
         if (isDuplicate(skillPath, "reviewer", resolvedTaskID))
           continue;
         try {
-          _internals49.appendSkillUsageEntry(directory, {
+          _internals50.appendSkillUsageEntry(directory, {
             skillPath,
             agentName: "reviewer",
             taskID: resolvedTaskID,
@@ -103732,15 +103935,15 @@ async function skillPropagationTransformScan(directory, output, sessionID) {
         skillsField = trimmed.slice("SKILLS:".length).trim();
       }
       if (currentTargetAgent && skillsField && skillsField.toLowerCase() !== "none") {
-        const skillPaths = _internals49.parseSkillPaths(skillsField);
-        const taskId = _internals49.extractTaskIdFromPrompt(text);
+        const skillPaths = _internals50.parseSkillPaths(skillsField);
+        const taskId = _internals50.extractTaskIdFromPrompt(text);
         for (const skillPath of skillPaths) {
           if (hadRecordingError)
             break;
           if (isDuplicate(skillPath, currentTargetAgent, taskId))
             continue;
           try {
-            _internals49.appendSkillUsageEntry(directory, {
+            _internals50.appendSkillUsageEntry(directory, {
               skillPath,
               agentName: currentTargetAgent,
               taskID: taskId,
@@ -103760,16 +103963,16 @@ async function skillPropagationTransformScan(directory, output, sessionID) {
     break;
   }
 }
-_internals49.skillPropagationGateBefore = skillPropagationGateBefore;
-_internals49.skillPropagationTransformScan = skillPropagationTransformScan;
-_internals49.writeWarnEvent = writeWarnEvent2;
-_internals49.discoverAvailableSkills = discoverAvailableSkills;
-_internals49.parseDelegationArgs = parseDelegationArgs;
-_internals49.parseSkillPaths = parseSkillPaths;
-_internals49.extractTaskIdFromPrompt = extractTaskIdFromPrompt;
-_internals49.extractSkillsFieldFromPrompt = extractSkillsFieldFromPrompt;
-_internals49.formatSkillIndexWithContext = formatSkillIndexWithContext;
-_internals49.loadRoutingSkills = loadRoutingSkills;
+_internals50.skillPropagationGateBefore = skillPropagationGateBefore;
+_internals50.skillPropagationTransformScan = skillPropagationTransformScan;
+_internals50.writeWarnEvent = writeWarnEvent2;
+_internals50.discoverAvailableSkills = discoverAvailableSkills;
+_internals50.parseDelegationArgs = parseDelegationArgs;
+_internals50.parseSkillPaths = parseSkillPaths;
+_internals50.extractTaskIdFromPrompt = extractTaskIdFromPrompt;
+_internals50.extractSkillsFieldFromPrompt = extractSkillsFieldFromPrompt;
+_internals50.formatSkillIndexWithContext = formatSkillIndexWithContext;
+_internals50.loadRoutingSkills = loadRoutingSkills;
 
 // src/index.ts
 init_skill_usage_log();
@@ -107061,7 +107264,7 @@ var EVIDENCE_DIR2 = ".swarm/evidence";
 var VALID_TASK_ID = /^\d+\.\d+(\.\d+)*$/;
 var COUNCIL_GATE_NAME = "council";
 var COUNCIL_AGENT_ID = "architect";
-var _internals50 = {
+var _internals51 = {
   withTaskEvidenceLock
 };
 var FORBIDDEN_KEYS = new Set(["__proto__", "constructor", "prototype"]);
@@ -107096,7 +107299,7 @@ async function writeCouncilEvidence(workingDir, synthesis) {
   const dir = join95(workingDir, EVIDENCE_DIR2);
   mkdirSync28(dir, { recursive: true });
   const filePath = taskEvidencePath(workingDir, synthesis.taskId);
-  await _internals50.withTaskEvidenceLock(workingDir, synthesis.taskId, COUNCIL_AGENT_ID, async () => {
+  await _internals51.withTaskEvidenceLock(workingDir, synthesis.taskId, COUNCIL_AGENT_ID, async () => {
     const existingRoot = Object.create(null);
     if (existsSync63(filePath)) {
       try {
@@ -110737,7 +110940,8 @@ var knowledge_receipt = createSwarmTool({
     for (const item of newLessons) {
       const raw = await knowledge_add.execute({ lesson: item.lesson, category: item.category }, ctx);
       try {
-        newLessonResults.push(JSON.parse(raw));
+        const output = typeof raw === "string" ? raw : typeof raw === "object" && raw !== null && ("output" in raw) && typeof raw.output === "string" ? raw.output : "";
+        newLessonResults.push(JSON.parse(output));
       } catch {
         newLessonResults.push({ success: false });
       }
@@ -111200,7 +111404,7 @@ function listLaneEvidenceSync(directory, phase) {
   }
   return laneIds;
 }
-var _internals51 = {
+var _internals52 = {
   listActiveLocks,
   readPersisted: readPersisted2,
   readPlanJson: defaultReadPlanJson,
@@ -111261,7 +111465,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
       reason: "Lean Turbo state unreadable or missing"
     };
   }
-  const persisted = _internals51.readPersisted(directory);
+  const persisted = _internals52.readPersisted(directory);
   if (!persisted) {
     return {
       ok: false,
@@ -111325,7 +111529,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     }
   }
   if (runState.lanes.length > 0) {
-    const evidenceLaneIds = new Set(_internals51.listLaneEvidenceSync(directory, phase));
+    const evidenceLaneIds = new Set(_internals52.listLaneEvidenceSync(directory, phase));
     for (const lane of runState.lanes) {
       if ((lane.status === "completed" || lane.status === "failed") && !evidenceLaneIds.has(lane.laneId)) {
         return {
@@ -111335,7 +111539,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
       }
     }
   }
-  const activeLocks = _internals51.listActiveLocks(directory);
+  const activeLocks = _internals52.listActiveLocks(directory);
   const phaseLaneIds = new Set(laneIds);
   for (const lock of activeLocks) {
     if (lock.laneId && phaseLaneIds.has(lock.laneId)) {
@@ -111355,7 +111559,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   const serialDegradedTasks = runState.degradedTasks.filter((dt) => !laneTaskIds.has(dt.taskId));
   if (serialDegradedTasks.length > 0) {
-    const plan = _internals51.readPlanJson(directory);
+    const plan = _internals52.readPlanJson(directory);
     if (!plan) {
       return {
         ok: false,
@@ -111399,7 +111603,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   const serializedTasks = runState.serializedTasks;
   if (Array.isArray(serializedTasks) && serializedTasks.length > 0) {
-    const plan = _internals51.readPlanJson(directory);
+    const plan = _internals52.readPlanJson(directory);
     if (!plan) {
       return {
         ok: false,
@@ -111458,7 +111662,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   let reviewerVerdict = runState.lastReviewerVerdict;
   if (!reviewerVerdict) {
-    const evidence = _internals51.readReviewerEvidence(directory, phase);
+    const evidence = _internals52.readReviewerEvidence(directory, phase);
     reviewerVerdict = evidence?.verdict ?? undefined;
   }
   if (mergedConfig.phase_reviewer) {
@@ -111471,7 +111675,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
   }
   let criticVerdict = runState.lastCriticVerdict;
   if (!criticVerdict) {
-    const evidence = _internals51.readCriticEvidence(directory, phase);
+    const evidence = _internals52.readCriticEvidence(directory, phase);
     criticVerdict = evidence?.verdict ?? undefined;
   }
   if (mergedConfig.phase_critic) {
@@ -112449,7 +112653,7 @@ Findings: ${details.join("; ")}` : "";
       phase_critic: leanConfig.phase_critic,
       integrated_diff_required: leanConfig.integrated_diff_required
     } : undefined;
-    const leanCheck = _internals51.verifyLeanTurboPhaseReady(dir, phase, sessionID, leanPhaseReadyConfig);
+    const leanCheck = _internals52.verifyLeanTurboPhaseReady(dir, phase, sessionID, leanPhaseReadyConfig);
     if (!leanCheck.ok) {
       return JSON.stringify({
         success: false,
@@ -114667,11 +114871,11 @@ var quality_budget = createSwarmTool({
     }).optional().describe("Quality budget thresholds")
   },
   async execute(args2, directory) {
-    const result = await _internals52.qualityBudget(args2, directory);
+    const result = await _internals53.qualityBudget(args2, directory);
     return JSON.stringify(result);
   }
 });
-var _internals52 = {
+var _internals53 = {
   qualityBudget
 };
 
@@ -115400,7 +115604,7 @@ import * as path129 from "node:path";
 var semgrepAvailableCache = null;
 var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
 var DEFAULT_TIMEOUT_MS3 = 30000;
-var _internals53 = {
+var _internals54 = {
   isSemgrepAvailable,
   checkSemgrepAvailable,
   resetSemgrepCache,
@@ -115425,7 +115629,7 @@ function isSemgrepAvailable() {
   }
 }
 async function checkSemgrepAvailable() {
-  return _internals53.isSemgrepAvailable();
+  return _internals54.isSemgrepAvailable();
 }
 function resetSemgrepCache() {
   semgrepAvailableCache = null;
@@ -115522,12 +115726,12 @@ async function runSemgrep(options) {
   const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS3;
   if (files.length === 0) {
     return {
-      available: _internals53.isSemgrepAvailable(),
+      available: _internals54.isSemgrepAvailable(),
       findings: [],
       engine: "tier_a"
     };
   }
-  if (!_internals53.isSemgrepAvailable()) {
+  if (!_internals54.isSemgrepAvailable()) {
     return {
       available: false,
       findings: [],
@@ -115686,7 +115890,7 @@ function assignOccurrenceIndices(findings, directory) {
     }
     const occIdx = countMap.get(baseKey) ?? 0;
     countMap.set(baseKey, occIdx + 1);
-    const fp = _internals54.fingerprintFinding(finding, directory, occIdx);
+    const fp = _internals55.fingerprintFinding(finding, directory, occIdx);
     return {
       finding,
       index: occIdx,
@@ -115755,7 +115959,7 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       }
     } catch {}
     const scannedRelFiles = new Set(scannedFiles.map((f) => normalizeFindingPath(directory, f)));
-    const indexed = _internals54.assignOccurrenceIndices(findings, directory);
+    const indexed = _internals55.assignOccurrenceIndices(findings, directory);
     if (existing && !opts?.force) {
       const prunedFingerprints = existing.fingerprints.filter((fp) => {
         const relFile = fp.slice(0, fp.indexOf("|"));
@@ -115895,7 +116099,7 @@ function loadBaseline(directory, phase) {
     };
   }
 }
-var _internals54 = {
+var _internals55 = {
   fingerprintFinding,
   assignOccurrenceIndices,
   captureOrMergeBaseline,
@@ -116305,11 +116509,11 @@ var sast_scan = createSwarmTool({
       capture_baseline: safeArgs.capture_baseline,
       phase: safeArgs.phase
     };
-    const result = await _internals55.sastScan(input, directory);
+    const result = await _internals56.sastScan(input, directory);
     return JSON.stringify(result, null, 2);
   }
 });
-var _internals55 = {
+var _internals56 = {
   sastScan,
   sast_scan
 };
@@ -120232,7 +120436,7 @@ init_zod();
 init_config();
 init_schema();
 init_create_tool();
-import { mkdir as mkdir23, rename as rename9, writeFile as writeFile17 } from "node:fs/promises";
+import { mkdir as mkdir23, rename as rename9, writeFile as writeFile18 } from "node:fs/promises";
 import * as path139 from "node:path";
 var MAX_SPEC_BYTES = 256 * 1024;
 var spec_write = createSwarmTool({
@@ -120294,7 +120498,7 @@ ${content}
         }
       } catch {}
     }
-    await writeFile17(tmp, finalContent, "utf-8");
+    await writeFile18(tmp, finalContent, "utf-8");
     await rename9(tmp, target);
     return JSON.stringify({ written: true, path: target, bytes: finalContent.length }, null, 2);
   }
@@ -120726,7 +120930,7 @@ var swarm_memory_propose = createSwarmTool({
     evidenceRefs: exports_external.array(exports_external.string().min(1).max(500)).max(20).optional().describe("Evidence refs such as files, commits, test outputs, or URLs")
   },
   execute: async (args2, directory, ctx) => {
-    const { config: config3 } = _internals56.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals57.loadPluginConfigWithMeta(directory);
     if (config3.memory?.enabled !== true) {
       return JSON.stringify({
         success: false,
@@ -120742,7 +120946,7 @@ var swarm_memory_propose = createSwarmTool({
       });
     }
     const agent = getContextAgent2(ctx);
-    const gateway = _internals56.createMemoryGateway({
+    const gateway = _internals57.createMemoryGateway({
       directory,
       sessionID: ctx?.sessionID,
       agentRole: agent,
@@ -120767,7 +120971,7 @@ var swarm_memory_propose = createSwarmTool({
     }
   }
 });
-var _internals56 = {
+var _internals57 = {
   loadPluginConfigWithMeta,
   createMemoryGateway
 };
@@ -120804,7 +121008,7 @@ var swarm_memory_recall = createSwarmTool({
     maxItems: exports_external.number().int().min(1).max(20).optional().describe("Maximum memories to return")
   },
   execute: async (args2, directory, ctx) => {
-    const { config: config3 } = _internals57.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals58.loadPluginConfigWithMeta(directory);
     if (config3.memory?.enabled !== true) {
       return JSON.stringify({
         success: false,
@@ -120820,7 +121024,7 @@ var swarm_memory_recall = createSwarmTool({
       });
     }
     const agent = getContextAgent3(ctx);
-    const gateway = _internals57.createMemoryGateway({
+    const gateway = _internals58.createMemoryGateway({
       directory,
       sessionID: ctx?.sessionID,
       agentRole: agent,
@@ -120853,7 +121057,7 @@ var RecallArgsSchema = exports_external.object({
   kinds: exports_external.array(exports_external.enum(MEMORY_KINDS2)).optional(),
   maxItems: exports_external.number().int().min(1).max(20).optional()
 });
-var _internals57 = {
+var _internals58 = {
   loadPluginConfigWithMeta,
   createMemoryGateway
 };
@@ -122098,7 +122302,7 @@ function resolveDefaultReviewerAgent(generatedAgentNames) {
 }
 async function compileReviewPackage(directory, phase, sessionID, requireDiffSummary) {
   const lanes = await listLaneEvidence(directory, phase);
-  const persisted = _internals58.readPersisted?.(directory) ?? null;
+  const persisted = _internals59.readPersisted?.(directory) ?? null;
   if (persisted) {
     let matchingRunState = null;
     for (const sessionState of Object.values(persisted.sessions)) {
@@ -122290,7 +122494,7 @@ Be specific and evidence-based. Do not approve a phase with unresolved degraded
     client.session.delete({ path: { id: sessionId } }).catch(() => {});
   }
 }
-var _internals58 = {
+var _internals59 = {
   compileReviewPackage,
   parseReviewerVerdict,
   writeReviewerEvidence,
@@ -122307,28 +122511,28 @@ async function dispatchPhaseReviewer(directory, phase, sessionID, config3) {
   };
   const generatedAgentNames = swarmState.generatedAgentNames;
   const agentName = mergedConfig.reviewerAgent || resolveDefaultReviewerAgent(generatedAgentNames);
-  const pkg = await _internals58.compileReviewPackage(directory, phase, sessionID, mergedConfig.requireDiffSummary);
+  const pkg = await _internals59.compileReviewPackage(directory, phase, sessionID, mergedConfig.requireDiffSummary);
   let responseText;
   try {
-    responseText = await _internals58.dispatchReviewerAgent(directory, pkg, agentName, mergedConfig.timeoutMs);
+    responseText = await _internals59.dispatchReviewerAgent(directory, pkg, agentName, mergedConfig.timeoutMs);
   } catch (error93) {
-    const evidencePath2 = await _internals58.writeReviewerEvidence(directory, phase, "REJECTED", error93 instanceof Error ? error93.message : String(error93));
+    const evidencePath2 = await _internals59.writeReviewerEvidence(directory, phase, "REJECTED", error93 instanceof Error ? error93.message : String(error93));
     return {
       verdict: "REJECTED",
       reason: `Reviewer dispatch failed: ${error93 instanceof Error ? error93.message : String(error93)}`,
       evidencePath: evidencePath2
     };
   }
-  const parsed = _internals58.parseReviewerVerdict(responseText);
+  const parsed = _internals59.parseReviewerVerdict(responseText);
   if (!parsed) {
-    const evidencePath2 = await _internals58.writeReviewerEvidence(directory, phase, "REJECTED", "Reviewer response could not be parsed");
+    const evidencePath2 = await _internals59.writeReviewerEvidence(directory, phase, "REJECTED", "Reviewer response could not be parsed");
     return {
       verdict: "REJECTED",
       reason: "Reviewer response could not be parsed",
       evidencePath: evidencePath2
     };
   }
-  const evidencePath = await _internals58.writeReviewerEvidence(directory, phase, parsed.verdict, parsed.reason);
+  const evidencePath = await _internals59.writeReviewerEvidence(directory, phase, parsed.verdict, parsed.reason);
   return {
     verdict: parsed.verdict,
     reason: parsed.reason,
@@ -122834,7 +123038,7 @@ ${fileList}
 
 // src/tools/lean-turbo-run-phase.ts
 init_create_tool();
-var _internals59 = {
+var _internals60 = {
   LeanTurboRunner,
   loadPluginConfigWithMeta
 };
@@ -122844,9 +123048,9 @@ async function executeLeanTurboRunPhase(args2) {
   let runError = null;
   let runner = null;
   try {
-    const { config: config3 } = _internals59.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals60.loadPluginConfigWithMeta(directory);
     const leanConfig = config3.turbo?.strategy === "lean" ? config3.turbo.lean : undefined;
-    runner = new _internals59.LeanTurboRunner({
+    runner = new _internals60.LeanTurboRunner({
       directory,
       sessionID,
       opencodeClient: swarmState.opencodeClient ?? null,
@@ -123200,7 +123404,7 @@ function isStaticallyEquivalent(originalCode, mutatedCode) {
   const strippedMutated = stripCode(mutatedCode);
   return strippedOriginal === strippedMutated;
 }
-var _internals60 = {
+var _internals61 = {
   isStaticallyEquivalent,
   checkEquivalence,
   batchCheckEquivalence
@@ -123240,7 +123444,7 @@ async function batchCheckEquivalence(patches, llmJudge) {
   const results = [];
   for (const { patch, originalCode, mutatedCode } of patches) {
     try {
-      const result = await _internals60.checkEquivalence(patch, originalCode, mutatedCode, llmJudge);
+      const result = await _internals61.checkEquivalence(patch, originalCode, mutatedCode, llmJudge);
       results.push(result);
     } catch (err3) {
       results.push({
@@ -123259,7 +123463,7 @@ async function batchCheckEquivalence(patches, llmJudge) {
 var MUTATION_TIMEOUT_MS = 30000;
 var TOTAL_BUDGET_MS = 300000;
 var GIT_APPLY_TIMEOUT_MS = 5000;
-var _internals61 = {
+var _internals62 = {
   executeMutation,
   computeReport,
   executeMutationSuite,
@@ -123291,7 +123495,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
       };
     }
     try {
-      const applyResult = _internals61.spawnSync("git", ["apply", "--", patchFile], {
+      const applyResult = _internals62.spawnSync("git", ["apply", "--", patchFile], {
         cwd: workingDir,
         timeout: GIT_APPLY_TIMEOUT_MS,
         stdio: "pipe"
@@ -123320,7 +123524,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
     }
     let testPassed = false;
     try {
-      const spawnResult = _internals61.spawnSync(testCommand[0], testCommand.slice(1), {
+      const spawnResult = _internals62.spawnSync(testCommand[0], testCommand.slice(1), {
         cwd: workingDir,
         timeout: MUTATION_TIMEOUT_MS,
         stdio: "pipe"
@@ -123353,7 +123557,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
   } finally {
     if (patchFile) {
       try {
-        const revertResult = _internals61.spawnSync("git", ["apply", "-R", "--", patchFile], {
+        const revertResult = _internals62.spawnSync("git", ["apply", "-R", "--", patchFile], {
           cwd: workingDir,
           timeout: GIT_APPLY_TIMEOUT_MS,
           stdio: "pipe"
@@ -123546,7 +123750,7 @@ async function executeMutationSuite(patches, testCommand, testFiles, workingDir,
 }
 
 // src/mutation/gate.ts
-var _internals62 = {
+var _internals63 = {
   evaluateMutationGate,
   buildTestImprovementPrompt,
   buildMessage
@@ -123567,8 +123771,8 @@ function evaluateMutationGate(report, passThreshold = PASS_THRESHOLD, warnThresh
   } else {
     verdict = "fail";
   }
-  const testImprovementPrompt = _internals62.buildTestImprovementPrompt(report, passThreshold, verdict);
-  const message = _internals62.buildMessage(verdict, adjustedKillRate, report.killed, report.totalMutants, report.equivalent, warnThreshold);
+  const testImprovementPrompt = _internals63.buildTestImprovementPrompt(report, passThreshold, verdict);
+  const message = _internals63.buildMessage(verdict, adjustedKillRate, report.killed, report.totalMutants, report.equivalent, warnThreshold);
   return {
     verdict,
     killRate: report.killRate,
@@ -124195,7 +124399,7 @@ import * as path152 from "node:path";
 init_bun_compat();
 import * as fs109 from "node:fs";
 import * as path151 from "node:path";
-var _internals63 = { bunSpawn };
+var _internals64 = { bunSpawn };
 var _swarmGitExcludedChecked = false;
 function fileCoversSwarm(content) {
   for (const rawLine of content.split(`
@@ -124228,7 +124432,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
       checkIgnoreExitCode
     ] = await Promise.all([
       (async () => {
-        const proc = _internals63.bunSpawn(["git", "-C", directory, "rev-parse", "--show-toplevel"], GIT_SPAWN_OPTIONS);
+        const proc = _internals64.bunSpawn(["git", "-C", directory, "rev-parse", "--show-toplevel"], GIT_SPAWN_OPTIONS);
         try {
           return await Promise.all([proc.exited, proc.stdout.text()]);
         } finally {
@@ -124238,7 +124442,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       })(),
       (async () => {
-        const proc = _internals63.bunSpawn(["git", "-C", directory, "rev-parse", "--git-path", "info/exclude"], GIT_SPAWN_OPTIONS);
+        const proc = _internals64.bunSpawn(["git", "-C", directory, "rev-parse", "--git-path", "info/exclude"], GIT_SPAWN_OPTIONS);
         try {
           return await Promise.all([proc.exited, proc.stdout.text()]);
         } finally {
@@ -124248,7 +124452,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       })(),
       (async () => {
-        const proc = _internals63.bunSpawn(["git", "-C", directory, "check-ignore", "-q", ".swarm/.gitkeep"], GIT_SPAWN_OPTIONS);
+        const proc = _internals64.bunSpawn(["git", "-C", directory, "check-ignore", "-q", ".swarm/.gitkeep"], GIT_SPAWN_OPTIONS);
         try {
           return await proc.exited;
         } finally {
@@ -124287,7 +124491,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       } catch {}
     }
-    const trackedProc = _internals63.bunSpawn(["git", "-C", directory, "ls-files", "--", ".swarm"], GIT_SPAWN_OPTIONS);
+    const trackedProc = _internals64.bunSpawn(["git", "-C", directory, "ls-files", "--", ".swarm"], GIT_SPAWN_OPTIONS);
     let trackedExitCode;
     let trackedOutput;
     try {
@@ -124312,7 +124516,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
 }
 
 // src/hooks/diff-scope.ts
-var _internals64 = { bunSpawn };
+var _internals65 = { bunSpawn };
 function getDeclaredScope(taskId, directory) {
   try {
     const planPath = path152.join(directory, ".swarm", "plan.json");
@@ -124347,7 +124551,7 @@ var GIT_DIFF_SPAWN_OPTIONS = {
 };
 async function getChangedFiles(directory) {
   try {
-    const proc = _internals64.bunSpawn(["git", "diff", "--name-only", "HEAD~1"], {
+    const proc = _internals65.bunSpawn(["git", "diff", "--name-only", "HEAD~1"], {
       cwd: directory,
       ...GIT_DIFF_SPAWN_OPTIONS
     });
@@ -124364,7 +124568,7 @@ async function getChangedFiles(directory) {
       return stdout.trim().split(`
 `).map((f) => f.trim()).filter((f) => f.length > 0);
     }
-    const proc2 = _internals64.bunSpawn(["git", "diff", "--name-only", "HEAD"], {
+    const proc2 = _internals65.bunSpawn(["git", "diff", "--name-only", "HEAD"], {
       cwd: directory,
       ...GIT_DIFF_SPAWN_OPTIONS
     });
@@ -124422,7 +124626,7 @@ init_telemetry();
 init_file_locks();
 import * as fs111 from "node:fs";
 import * as path153 from "node:path";
-var _internals65 = {
+var _internals66 = {
   listActiveLocks,
   verifyLeanTurboTaskCompletion
 };
@@ -124564,7 +124768,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
       }
     };
   }
-  const activeLocks = _internals65.listActiveLocks(directory);
+  const activeLocks = _internals66.listActiveLocks(directory);
   const laneLocks = activeLocks.filter((lock) => lock.laneId === lane.laneId);
   if (laneLocks.length > 0) {
     return {
@@ -125493,7 +125697,7 @@ var web_search = createSwarmTool({
 });
 async function captureSearchEvidence(directory, query, results) {
   try {
-    const written = await _internals66.writeEvidenceDocuments(directory, results.map((result) => ({
+    const written = await _internals67.writeEvidenceDocuments(directory, results.map((result) => ({
       sourceType: "web_search",
       query,
       title: result.title,
@@ -125521,7 +125725,7 @@ async function captureSearchEvidence(directory, query, results) {
     };
   }
 }
-var _internals66 = {
+var _internals67 = {
   writeEvidenceDocuments
 };
 // src/tools/write-drift-evidence.ts