opencode-swarm 7.93.1 → 7.94.0

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.93.1",
+    version: "7.94.0",
     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",
@@ -645,6 +645,10 @@ var init_tool_metadata = __esm(() => {
       description: "inspect the content and source entries of a skill file",
       agents: ["architect", "skill_improver"]
     },
+    run_stale_reconciliation: {
+      description: "reconcile skills against the knowledge store: mark skills stale when source knowledge is archived or deleted, or clear stale markers",
+      agents: ["architect"]
+    },
     skill_regenerate: {
       description: "regenerate an active skill by re-clustering its source knowledge entries and updating the SKILL.md in place",
       agents: ["architect"]
@@ -61550,6 +61554,7 @@ __export(exports_knowledge_store, {
   jaccardBigram: () => jaccardBigram,
   inferTags: () => inferTags,
   getPlatformConfigDir: () => getPlatformConfigDir,
+  getArchivedKnowledgeIds: () => getArchivedKnowledgeIds,
   findNearDuplicate: () => findNearDuplicate,
   enforceKnowledgeCap: () => enforceKnowledgeCap,
   computeOutcomeSignal: () => computeOutcomeSignal,
@@ -61790,6 +61795,38 @@ async function transactKnowledge(filePath, mutate) {
     await atomicWriteFile(fp, content);
   }, mutate);
 }
+async function getArchivedKnowledgeIds(directory) {
+  const archived = new Set;
+  const swarmPath = resolveSwarmKnowledgePath(directory);
+  try {
+    const content = await readFile5(swarmPath, "utf-8");
+    const lines = content.split(`
+`).filter((l) => l.trim());
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.status === "archived" || entry.status === "quarantined" || entry.status === "quarantined_unactionable") {
+          archived.add(entry.id);
+        }
+      } catch {}
+    }
+  } catch {}
+  const hivePath = resolveHiveKnowledgePath();
+  try {
+    const content = await readFile5(hivePath, "utf-8");
+    const lines = content.split(`
+`).filter((l) => l.trim());
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.status === "archived" || entry.status === "quarantined" || entry.status === "quarantined_unactionable") {
+          archived.add(entry.id);
+        }
+      } catch {}
+    }
+  } catch {}
+  return archived;
+}
 async function appendKnowledgeWithCapEnforcement(filePath, entry, maxEntries) {
   return transactKnowledge(filePath, (entries) => {
     const updated = [...entries, entry];
@@ -62084,7 +62121,8 @@ var init_knowledge_store = __esm(() => {
     computeOutcomeSignal,
     selectKnowledgeCapSurvivors,
     inferTags,
-    bumpKnowledgeConfidenceBatch
+    bumpKnowledgeConfidenceBatch,
+    getArchivedKnowledgeIds
   };
 });
 
@@ -63776,6 +63814,8 @@ function countWindowedReceipts(events, entryId, windowMs, nowMs) {
       continue;
     if (e.knowledge_id !== entryId)
       continue;
+    if (e.timestamp === undefined)
+      continue;
     const t = Date.parse(e.timestamp);
     if (Number.isNaN(t) || t < cutoff)
       continue;
@@ -63863,6 +63903,8 @@ async function computeLearningMetrics(directory, options) {
     throwIfAborted(options?.signal);
     if (!isReceiptType(e))
       continue;
+    if (e.timestamp === undefined)
+      continue;
     const t = Date.parse(e.timestamp);
     if (Number.isNaN(t))
       continue;
@@ -65183,16 +65225,21 @@ __export(exports_skill_generator, {
   selectCandidateEntries: () => selectCandidateEntries,
   sanitizeSlug: () => sanitizeSlug,
   retireSkill: () => retireSkill,
+  retireOrMarkStale: () => retireOrMarkStale,
   renderSkillMarkdown: () => renderSkillMarkdown,
   regenerateSkill: () => regenerateSkill,
   proposalPath: () => proposalPath,
   parseDraftFrontmatter: () => parseDraftFrontmatter,
+  markSkillStale: () => markSkillStale,
   listSkills: () => listSkills,
   isValidSlug: () => isValidSlug2,
   isSkillMaturityEligible: () => isSkillMaturityEligible,
   inspectSkill: () => inspectSkill,
   generateSkills: () => generateSkills,
+  findStaleSkillsBySourceKnowledgeId: () => findStaleSkillsBySourceKnowledgeId,
+  findSkillsBySourceKnowledgeId: () => findSkillsBySourceKnowledgeId,
   clusterEntries: () => clusterEntries,
+  clearSkillStale: () => clearSkillStale,
   autoApplyProposals: () => autoApplyProposals,
   activeRepoRelativePath: () => activeRepoRelativePath,
   activePath: () => activePath,
@@ -65204,7 +65251,7 @@ __export(exports_skill_generator, {
   DEFAULT_SKILL_MIN_CONFIDENCE: () => DEFAULT_SKILL_MIN_CONFIDENCE
 });
 import { existsSync as existsSync23, unlinkSync as unlinkSync7 } from "node:fs";
-import { mkdir as mkdir10, readFile as readFile9, rename as rename4, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir10, readFile as readFile9, rename as rename4, unlink as unlink3, writeFile as writeFile6 } from "node:fs/promises";
 import * as path47 from "node:path";
 function sanitizeSlug(input) {
   const lc = input.toLowerCase().trim();
@@ -65895,10 +65942,81 @@ async function activateProposal(directory, slug, force = false, options = {}) {
     };
   }
 }
+async function findSkillsBySourceKnowledgeId(directory, sourceId) {
+  const activeDir = path47.join(directory, ".opencode", "skills", "generated");
+  const fs23 = await import("node:fs/promises");
+  if (!existsSync23(activeDir))
+    return [];
+  const entries = await fs23.readdir(activeDir, { withFileTypes: true });
+  const matches = [];
+  for (const e of entries) {
+    if (!e.isDirectory())
+      continue;
+    const skillDir = path47.join(activeDir, e.name);
+    const retiredMarker = path47.join(skillDir, "retired.marker");
+    if (existsSync23(retiredMarker))
+      continue;
+    const staleMarker = path47.join(skillDir, "stale.marker");
+    if (existsSync23(staleMarker))
+      continue;
+    const skillPath = path47.join(skillDir, "SKILL.md");
+    if (!existsSync23(skillPath))
+      continue;
+    let content;
+    try {
+      content = await fs23.readFile(skillPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const fm = parseDraftFrontmatter(content);
+    if (fm?.sourceKnowledgeIds.includes(sourceId)) {
+      matches.push(skillDir);
+    }
+  }
+  return matches;
+}
+async function findStaleSkillsBySourceKnowledgeId(directory, archivedIds) {
+  const activeDir = path47.join(directory, ".opencode", "skills", "generated");
+  if (!existsSync23(activeDir))
+    return [];
+  const fs23 = await import("node:fs/promises");
+  const entries = await fs23.readdir(activeDir, { withFileTypes: true });
+  const matches = [];
+  for (const e of entries) {
+    if (!e.isDirectory())
+      continue;
+    const skillDir = path47.join(activeDir, e.name);
+    const retiredMarker = path47.join(skillDir, "retired.marker");
+    if (existsSync23(retiredMarker))
+      continue;
+    const staleMarker = path47.join(skillDir, "stale.marker");
+    if (!existsSync23(staleMarker))
+      continue;
+    const skillPath = path47.join(skillDir, "SKILL.md");
+    if (!existsSync23(skillPath))
+      continue;
+    let content;
+    try {
+      content = await fs23.readFile(skillPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const fm = parseDraftFrontmatter(content);
+    const sourceIds = fm?.sourceKnowledgeIds ?? [];
+    if (sourceIds.length === 0)
+      continue;
+    const allArchived = sourceIds.every((id) => archivedIds.has(id));
+    if (allArchived) {
+      matches.push(skillDir);
+    }
+  }
+  return matches;
+}
 async function listSkills(directory) {
   const result = {
     proposals: [],
-    active: []
+    active: [],
+    stale: []
   };
   const proposalsDir = path47.join(directory, ".swarm", "skills", "proposals");
   const activeDir = path47.join(directory, ".opencode", "skills", "generated");
@@ -65923,6 +66041,16 @@ async function listSkills(directory) {
       const retiredMarker = path47.join(activeDir, e.name, "retired.marker");
       if (existsSync23(retiredMarker))
         continue;
+      const staleMarker = path47.join(activeDir, e.name, "stale.marker");
+      if (existsSync23(staleMarker)) {
+        let reason = "stale";
+        try {
+          const content = await fs23.readFile(staleMarker, "utf-8");
+          reason = content.trim() || "stale";
+        } catch {}
+        result.stale.push({ slug: e.name, reason });
+        continue;
+      }
       const skillPath = path47.join(activeDir, e.name, "SKILL.md");
       if (existsSync23(skillPath)) {
         result.active.push({
@@ -66008,7 +66136,34 @@ async function inspectSkill(directory, slug, prefer = "auto") {
   for (const c of candidates) {
     if (existsSync23(c.p)) {
       const content = await readFile9(c.p, "utf-8");
-      return { found: true, path: c.p, content, mode: c.m };
+      const result = { found: true, path: c.p, content, mode: c.m };
+      const fm = parseDraftFrontmatter(content);
+      if (fm && fm.sourceKnowledgeIds.length > 0) {
+        const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
+        const hivePath = resolveHiveKnowledgePath();
+        const hive = existsSync23(hivePath) ? await readKnowledge(hivePath) : [];
+        const allEntries = [...swarm, ...hive];
+        const entryMap = new Map(allEntries.map((e) => [e.id, e]));
+        result.source_knowledge_status = fm.sourceKnowledgeIds.map((id) => {
+          const entry = entryMap.get(id);
+          if (!entry)
+            return { id, status: "deleted" };
+          if (entry.status === "archived" || entry.status === "quarantined") {
+            return { id, status: "archived" };
+          }
+          return { id, status: "active" };
+        });
+      }
+      if (c.m === "active") {
+        const skillDir = path47.join(directory, ".opencode", "skills", "generated", cleanSlug);
+        const staleMarker = path47.join(skillDir, "stale.marker");
+        if (existsSync23(staleMarker)) {
+          try {
+            result.stale_reason = await readFile9(staleMarker, "utf-8");
+          } catch {}
+        }
+      }
+      return result;
     }
   }
   return { found: false };
@@ -66047,6 +66202,54 @@ async function retireSkill(directory, slug, reason) {
     reason
   };
 }
+async function markSkillStale(skillDir, reason) {
+  await mkdir10(skillDir, { recursive: true });
+  await writeFile6(path47.join(skillDir, "stale.marker"), reason, "utf-8");
+}
+async function clearSkillStale(skillDir) {
+  const markerPath = path47.join(skillDir, "stale.marker");
+  try {
+    await unlink3(markerPath);
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return;
+    }
+    warn(`[skill-generator] failed to remove stale.marker at ${markerPath}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function retireOrMarkStale(directory, skillDir, archivedKnowledgeIds) {
+  const fs23 = await import("node:fs/promises");
+  const skillPath = path47.join(skillDir, "SKILL.md");
+  if (!existsSync23(skillPath)) {
+    await markSkillStale(skillDir, "source knowledge archived, SKILL.md missing");
+    const slug2 = path47.basename(skillDir);
+    return { action: "stale", slug: slug2, skillDir };
+  }
+  let content;
+  try {
+    content = await fs23.readFile(skillPath, "utf-8");
+  } catch {
+    await markSkillStale(skillDir, "source knowledge archived, SKILL.md unreadable");
+    const slug2 = path47.basename(skillDir);
+    return { action: "stale", slug: slug2, skillDir };
+  }
+  const fm = parseDraftFrontmatter(content);
+  const sourceIds = fm?.sourceKnowledgeIds ?? [];
+  if (sourceIds.length === 0) {
+    await markSkillStale(skillDir, "source knowledge archived, no source_knowledge_ids in frontmatter");
+    const slug2 = path47.basename(skillDir);
+    return { action: "stale", slug: slug2, skillDir };
+  }
+  const allArchived = sourceIds.every((id) => archivedKnowledgeIds.has(id));
+  const slug = path47.basename(skillDir);
+  if (allArchived) {
+    await retireSkill(directory, slug, "all source knowledge entries archived or deleted");
+    return { action: "retire", slug, skillDir };
+  } else {
+    await markSkillStale(skillDir, "one or more source knowledge entries archived");
+    return { action: "stale", slug, skillDir };
+  }
+}
 async function regenerateSkill(directory, slug, options = {}) {
   const cleanSlug = sanitizeSlug(slug);
   if (!isValidSlug2(cleanSlug)) {
@@ -66206,6 +66409,7 @@ async function regenerateSkill(directory, slug, options = {}) {
   try {
     await atomicWrite3(skillPath, content);
     await stampSourceEntries(directory, cleanSlug, matchedEntries.map((e) => e.id));
+    await clearSkillStale(path47.dirname(activePath(directory, cleanSlug)));
   } catch (writeErr) {
     return {
       regenerated: false,
@@ -66249,11 +66453,15 @@ var init_skill_generator = __esm(() => {
     generateSkills,
     activateProposal,
     listSkills,
+    findSkillsBySourceKnowledgeId,
+    findStaleSkillsBySourceKnowledgeId,
     inspectSkill,
     stampSourceEntries,
     parseDraftFrontmatter,
     retireSkill,
+    retireOrMarkStale,
     regenerateSkill,
+    clearSkillStale,
     autoApplyProposals,
     unlinkSync: unlinkSync7
   };
@@ -67199,11 +67407,12 @@ ${digest2.summary}`).join(`
 
 `);
 }
-async function autoRetireSkills(directory, curatorKnowledgePath, excludeSlugs) {
+async function autoRetireSkills(directory, _curatorKnowledgePath, excludeSlugs) {
   const observations = [];
   try {
     const skillListResult = await _internals32.listSkills(directory);
     const usageEntries = _internals32.readSkillUsageEntries(directory);
+    const allArchivedIds = await _internals32.getArchivedKnowledgeIds(directory);
     for (const active of skillListResult.active) {
       if (excludeSlugs?.has(active.slug))
         continue;
@@ -67223,30 +67432,20 @@ async function autoRetireSkills(directory, curatorKnowledgePath, excludeSlugs) {
       });
       const violations = skillUsage.filter((e) => e.complianceVerdict === "violated").length;
       const violationRate = skillUsage.length > 0 ? violations / skillUsage.length : 0;
-      let allArchived = false;
-      try {
-        const content = await _internals32.readFileAsync(active.path, "utf-8");
-        const fm = _internals32.parseDraftFrontmatter(content);
-        if (fm && fm.sourceKnowledgeIds.length > 0) {
-          const swarmKnowledge = await _internals32.readKnowledge(curatorKnowledgePath);
-          let hiveKnowledge = [];
-          try {
-            const hivePath = resolveHiveKnowledgePath();
-            if (fs24.existsSync(hivePath)) {
-              hiveKnowledge = await _internals32.readKnowledge(hivePath);
-            }
-          } catch {}
-          const allKnowledge = [...swarmKnowledge, ...hiveKnowledge];
-          const sourceIds = new Set(fm.sourceKnowledgeIds);
-          const sources = allKnowledge.filter((e) => sourceIds.has(e.id));
-          allArchived = sources.length === sourceIds.size && sources.every((e) => e.status === "archived");
-        }
-      } catch {}
-      if (violationRate > 0.3 || allArchived) {
-        const reason = violationRate > 0.3 ? `auto-retire: violation rate ${(violationRate * 100).toFixed(0)}% exceeds 30% threshold` : "auto-retire: all source knowledge entries archived";
+      if (violationRate > 0.3) {
+        const reason = `auto-retire: violation rate ${(violationRate * 100).toFixed(0)}% exceeds 30% threshold`;
         await _internals32.retireSkill(directory, active.slug, reason);
         observations.push(`Skill '${active.slug}' auto-retired: ${reason}`);
         warn(`[curator] ${observations[observations.length - 1]}`);
+        continue;
+      }
+      const result = await _internals32.retireOrMarkStale(directory, path50.dirname(active.path), allArchivedIds);
+      if (result.action === "retire") {
+        observations.push(`Skill '${active.slug}' auto-retired: all source knowledge entries archived`);
+        warn(`[curator] ${observations[observations.length - 1]}`);
+      } else if (result.action === "stale") {
+        observations.push(`Skill '${active.slug}' marked stale: some source knowledge entries archived`);
+        warn(`[curator] ${observations[observations.length - 1]}`);
       }
     }
   } catch (autoRetireErr) {
@@ -68015,6 +68214,29 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config3, know
       const retireNote = ` [${autoRetireObservations.length} skill(s) auto-retired]`;
       phaseDigest.summary += retireNote;
     }
+    try {
+      const eventsContent = await readSwarmFileAsync(directory, "knowledge-events.jsonl");
+      if (eventsContent) {
+        const lines = eventsContent.split(`
+`).filter((l) => l.trim());
+        const batchEvents = [];
+        for (const line of lines) {
+          try {
+            const event = JSON.parse(line);
+            if (event.type === "skill-stale-batch") {
+              batchEvents.push({
+                skillIds: event.skillIds ?? [],
+                retiredCount: event.retiredCount ?? 0,
+                staleCount: event.staleCount ?? 0
+              });
+            }
+          } catch {}
+        }
+        for (const batch of batchEvents) {
+          warn(`[curator] skill-stale-batch: ${batch.skillIds.length} skills affected (${batch.retiredCount} retired, ${batch.staleCount} stale)`);
+        }
+      }
+    } catch {}
     try {
       const metrics = await computeLearningMetrics(directory, {
         currentPhase: phase
@@ -68245,7 +68467,9 @@ var init_curator = __esm(() => {
     readSkillUsageEntries,
     listSkills,
     parseDraftFrontmatter,
+    retireOrMarkStale,
     retireSkill,
+    getArchivedKnowledgeIds,
     readFileAsync: (filePath, encoding) => import("node:fs/promises").then((fs25) => fs25.readFile(filePath, encoding)),
     readKnowledge,
     reviseSkill,
@@ -68546,7 +68770,7 @@ import {
   readFile as readFile12,
   rename as rename7,
   stat as stat8,
-  unlink as unlink3,
+  unlink as unlink4,
   writeFile as writeFile9
 } from "node:fs/promises";
 import * as path52 from "node:path";
@@ -68751,7 +68975,7 @@ async function writeSynonymMapAtomic(filePath, map3) {
     await rename7(tmp, filePath);
   } finally {
     try {
-      await unlink3(tmp);
+      await unlink4(tmp);
     } catch {}
   }
 }
@@ -69314,7 +69538,7 @@ function discoverAvailableSkills(directory) {
       if (entry.startsWith("."))
         continue;
       const skillDir = path54.join(rootPath, entry);
-      if (_internals34.existsSync(path54.join(skillDir, "retired.marker")))
+      if (_internals34.existsSync(path54.join(skillDir, "retired.marker")) || _internals34.existsSync(path54.join(skillDir, "stale.marker")))
         continue;
       const skillFile = path54.join(skillDir, "SKILL.md");
       try {
@@ -69520,7 +69744,7 @@ async function skillPropagationGateBefore(directory, input, config3) {
       const existingPaths = new Set(scored.map((s) => s.skillPath));
       for (const routingPath of routingPaths) {
         const routedSkillDir = path54.dirname(path54.join(directory, routingPath));
-        if (_internals34.existsSync(path54.join(routedSkillDir, "retired.marker")))
+        if (_internals34.existsSync(path54.join(routedSkillDir, "retired.marker")) || _internals34.existsSync(path54.join(routedSkillDir, "stale.marker")))
           continue;
         if (!existingPaths.has(routingPath)) {
           scored.push({
@@ -69831,7 +70055,7 @@ var init_skill_propagation_gate = __esm(() => {
 });
 
 // src/hooks/micro-reflector.ts
-import { existsSync as existsSync28 } from "node:fs";
+import { existsSync as existsSync27 } from "node:fs";
 import { readFile as readFile13, writeFile as writeFile10 } from "node:fs/promises";
 import * as path55 from "node:path";
 function resolveInsightCandidatesPath(directory) {
@@ -69866,7 +70090,7 @@ async function readTaskTrajectory(directory, taskId) {
   try {
     const rel = path55.join("evidence", sanitizeTaskId2(taskId), "trajectory.jsonl");
     const filePath = validateSwarmPath(directory, rel);
-    if (!existsSync28(filePath))
+    if (!existsSync27(filePath))
       return [];
     const content = await readFile13(filePath, "utf-8");
     const out = [];
@@ -70110,7 +70334,7 @@ var init_micro_reflector = __esm(() => {
 
 // src/hooks/knowledge-curator.ts
 import { createHash as createHash9 } from "node:crypto";
-import { existsSync as existsSync29 } from "node:fs";
+import { existsSync as existsSync28 } from "node:fs";
 import { appendFile as appendFile8, mkdir as mkdir13, readFile as readFile14, writeFile as writeFile11 } from "node:fs/promises";
 import * as path56 from "node:path";
 function pruneSeenRetroSections() {
@@ -70535,7 +70759,7 @@ function readInsightJsonl2(content) {
 async function consumeInsightCandidates(directory, batchLimit = MESO_INSIGHT_BATCH_LIMIT) {
   try {
     const filePath = resolveInsightCandidatesPath(directory);
-    if (!existsSync29(filePath))
+    if (!existsSync28(filePath))
       return [];
     const consumed = [];
     await transactFile(filePath, async (p) => readInsightJsonl2(await readFile14(p, "utf-8").catch(() => "")), async (p, data) => {
@@ -71676,12 +71900,12 @@ var init_trajectory_cluster = __esm(() => {
 });
 
 // src/services/unactionable-hardening.ts
-import { existsSync as existsSync30 } from "node:fs";
+import { existsSync as existsSync29 } from "node:fs";
 async function hardenUnactionableEntries(params) {
   const result = { hardened: 0, retired: 0, remaining: 0 };
   try {
     const queuePath = resolveUnactionablePath(params.directory);
-    if (!existsSync30(queuePath))
+    if (!existsSync29(queuePath))
       return result;
     const limit = params.batchLimit ?? HARDENING_BATCH_LIMIT;
     const dedupThreshold = params.dedupThreshold ?? 0.6;
@@ -71788,7 +72012,7 @@ var init_unactionable_hardening = __esm(() => {
 });
 
 // src/services/skill-improver.ts
-import { existsSync as existsSync31 } from "node:fs";
+import { existsSync as existsSync30 } from "node:fs";
 import { mkdir as mkdir15, readFile as readFile15, rename as rename8, writeFile as writeFile13 } from "node:fs/promises";
 import * as path59 from "node:path";
 function timestampSlug(d) {
@@ -71803,7 +72027,7 @@ async function atomicWrite4(p, content) {
 async function gatherInventory(directory) {
   const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
   const hivePath = resolveHiveKnowledgePath();
-  const hive = existsSync31(hivePath) ? await readKnowledge(hivePath) : [];
+  const hive = existsSync30(hivePath) ? await readKnowledge(hivePath) : [];
   const archived = [...swarm, ...hive].filter((e) => e.status === "archived").length;
   const skills = await listSkills(directory);
   const knowledgeById = new Map([...swarm, ...hive].map((entry) => [entry.id, entry]));
@@ -74042,7 +74266,7 @@ __export(exports_skill_consolidation, {
   consolidationStatePath: () => consolidationStatePath,
   _internals: () => _internals39
 });
-import { existsSync as existsSync33 } from "node:fs";
+import { existsSync as existsSync32 } from "node:fs";
 import { mkdir as mkdir16, readFile as readFile16, rename as rename9, writeFile as writeFile14 } from "node:fs/promises";
 import * as path62 from "node:path";
 function consolidationStatePath(directory) {
@@ -74050,7 +74274,7 @@ function consolidationStatePath(directory) {
 }
 async function readState2(directory) {
   const filePath = consolidationStatePath(directory);
-  if (!existsSync33(filePath))
+  if (!existsSync32(filePath))
     return {};
   try {
     const parsed = JSON.parse(await readFile16(filePath, "utf-8"));
@@ -75679,7 +75903,7 @@ var init_gate_bridge = __esm(() => {
 });
 
 // src/services/version-check.ts
-import { existsSync as existsSync34, mkdirSync as mkdirSync21, readFileSync as readFileSync18, writeFileSync as writeFileSync13 } from "node:fs";
+import { existsSync as existsSync33, mkdirSync as mkdirSync21, readFileSync as readFileSync18, writeFileSync as writeFileSync13 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
 import { join as join51 } from "node:path";
 function cacheDir() {
@@ -75693,7 +75917,7 @@ function cacheFile() {
 function readVersionCache() {
   try {
     const path67 = cacheFile();
-    if (!existsSync34(path67))
+    if (!existsSync33(path67))
       return null;
     const raw = readFileSync18(path67, "utf-8");
     const parsed = JSON.parse(raw);
@@ -75791,10 +76015,10 @@ var init_version_check = __esm(() => {
 });
 
 // src/services/knowledge-diagnostics.ts
-import { existsSync as existsSync35 } from "node:fs";
+import { existsSync as existsSync34 } from "node:fs";
 import { readFile as readFile18 } from "node:fs/promises";
 async function readRawLines(filePath) {
-  if (!existsSync35(filePath))
+  if (!existsSync34(filePath))
     return { entries: [], corrupt: 0 };
   const content = await readFile18(filePath, "utf-8");
   const entries = [];
@@ -75919,7 +76143,7 @@ async function computeKnowledgeDebug(directory) {
   };
 }
 async function safeJsonlCount(filePath) {
-  if (!filePath || !existsSync35(filePath))
+  if (!filePath || !existsSync34(filePath))
     return 0;
   try {
     const content = await readFile18(filePath, "utf-8");
@@ -76002,7 +76226,7 @@ var init_knowledge_diagnostics = __esm(() => {
 
 // src/services/diagnose-service.ts
 import * as child_process6 from "node:child_process";
-import { existsSync as existsSync36, readdirSync as readdirSync7, readFileSync as readFileSync19, statSync as statSync11 } from "node:fs";
+import { existsSync as existsSync35, readdirSync as readdirSync7, readFileSync as readFileSync19, statSync as statSync11 } from "node:fs";
 import path67 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function validateTaskDag(plan) {
@@ -76250,7 +76474,7 @@ async function checkConfigBackups(directory) {
 }
 async function checkGitRepository(directory) {
   try {
-    if (!existsSync36(directory) || !statSync11(directory).isDirectory()) {
+    if (!existsSync35(directory) || !statSync11(directory).isDirectory()) {
       return {
         name: "Git Repository",
         status: "❌",
@@ -76315,7 +76539,7 @@ async function checkSpecStaleness(directory, plan) {
 }
 async function checkConfigParseability(directory) {
   const configPath = path67.join(directory, ".opencode/opencode-swarm.json");
-  if (!existsSync36(configPath)) {
+  if (!existsSync35(configPath)) {
     return {
       name: "Config Parseability",
       status: "✅",
@@ -76370,11 +76594,11 @@ async function checkGrammarWasmFiles() {
   const thisDir = path67.dirname(fileURLToPath2(import.meta.url));
   const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync36(path67.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync35(path67.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file3 of grammarFiles) {
-    if (!existsSync36(path67.join(grammarDir, file3))) {
+    if (!existsSync35(path67.join(grammarDir, file3))) {
       missing.push(file3);
     }
   }
@@ -76393,7 +76617,7 @@ async function checkGrammarWasmFiles() {
 }
 async function checkCheckpointManifest(directory) {
   const manifestPath = path67.join(directory, ".swarm/checkpoints.json");
-  if (!existsSync36(manifestPath)) {
+  if (!existsSync35(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
       status: "✅",
@@ -76445,7 +76669,7 @@ async function checkCheckpointManifest(directory) {
 }
 async function checkEventStreamIntegrity(directory) {
   const eventsPath = path67.join(directory, ".swarm/events.jsonl");
-  if (!existsSync36(eventsPath)) {
+  if (!existsSync35(eventsPath)) {
     return {
       name: "Event Stream",
       status: "✅",
@@ -76486,7 +76710,7 @@ async function checkEventStreamIntegrity(directory) {
 }
 async function checkSteeringDirectives(directory) {
   const eventsPath = path67.join(directory, ".swarm/events.jsonl");
-  if (!existsSync36(eventsPath)) {
+  if (!existsSync35(eventsPath)) {
     return {
       name: "Steering Directives",
       status: "✅",
@@ -76542,7 +76766,7 @@ async function checkCurator(directory) {
       };
     }
     const summaryPath = path67.join(directory, ".swarm/curator-summary.json");
-    if (!existsSync36(summaryPath)) {
+    if (!existsSync35(summaryPath)) {
       return {
         name: "Curator",
         status: "✅",
@@ -76744,7 +76968,7 @@ async function getDiagnoseData(directory) {
   checks5.push(await checkKnowledgeHealth(directory));
   try {
     const evidenceDir = path67.join(directory, ".swarm", "evidence");
-    const snapshotFiles = existsSync36(evidenceDir) ? readdirSync7(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
+    const snapshotFiles = existsSync35(evidenceDir) ? readdirSync7(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
       checks5.push({
@@ -76777,7 +77001,7 @@ async function getDiagnoseData(directory) {
   const cacheRows = [];
   for (const cachePath of cachePaths) {
     try {
-      if (!existsSync36(cachePath)) {
+      if (!existsSync35(cachePath)) {
         cacheRows.push(`⬜ ${cachePath} — absent`);
         continue;
       }
@@ -82711,7 +82935,7 @@ var KNOWLEDGE_SCHEMA_VERSION = 2;
 
 // src/hooks/knowledge-migrator.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { existsSync as existsSync43, readFileSync as readFileSync26 } from "node:fs";
+import { existsSync as existsSync42, readFileSync as readFileSync26 } from "node:fs";
 import { mkdir as mkdir17, readFile as readFile19, writeFile as writeFile15 } from "node:fs/promises";
 import * as os15 from "node:os";
 import * as path75 from "node:path";
@@ -82728,7 +82952,7 @@ async function migrateContextToKnowledge(directory, config3) {
   const sentinelPath = path75.join(directory, ".swarm", ".knowledge-migrated");
   const contextPath = path75.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
-  if (existsSync43(sentinelPath)) {
+  if (existsSync42(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -82737,7 +82961,7 @@ async function migrateContextToKnowledge(directory, config3) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync43(contextPath)) {
+  if (!existsSync42(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -82829,7 +83053,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
   const legacyHivePath = _internals51.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath();
   const sentinelPath = path75.join(path75.dirname(canonicalHivePath), ".hive-knowledge-migrated");
-  if (existsSync43(sentinelPath)) {
+  if (existsSync42(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -82838,7 +83062,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync43(legacyHivePath)) {
+  if (!existsSync42(legacyHivePath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -83040,7 +83264,7 @@ function truncateLesson2(text) {
 }
 function inferProjectName(directory) {
   const packageJsonPath = path75.join(directory, "package.json");
-  if (existsSync43(packageJsonPath)) {
+  if (existsSync42(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync26(packageJsonPath, "utf-8"));
       if (pkg.name && typeof pkg.name === "string") {
@@ -83433,12 +83657,12 @@ var init_identity = __esm(() => {
 });
 
 // src/commands/link.ts
-import { existsSync as existsSync44 } from "node:fs";
+import { existsSync as existsSync43 } from "node:fs";
 import * as path77 from "node:path";
 async function mergeLocalKnowledgeIntoLink(localSwarmDir, linkDir) {
   const localPath = path77.join(localSwarmDir, "knowledge.jsonl");
   const sharedPath = path77.join(linkDir, "knowledge.jsonl");
-  if (!existsSync44(localPath))
+  if (!existsSync43(localPath))
     return { merged: 0, skipped: 0 };
   let merged = 0;
   let skipped = 0;
@@ -84754,7 +84978,7 @@ var init_maintenance = __esm(() => {
 
 // src/memory/local-jsonl-provider.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
-import { existsSync as existsSync45 } from "node:fs";
+import { existsSync as existsSync44 } from "node:fs";
 import {
   appendFile as appendFile9,
   mkdir as mkdir18,
@@ -85105,7 +85329,7 @@ function validateLoadedProposals(values, config3) {
   return { records, invalidCount };
 }
 async function readJsonl(filePath) {
-  if (!existsSync45(filePath))
+  if (!existsSync44(filePath))
     return [];
   const content = await readFile20(filePath, "utf-8");
   const records = [];
@@ -85265,7 +85489,7 @@ var init_prompt_block = __esm(() => {
 });
 
 // src/memory/jsonl-migration.ts
-import { existsSync as existsSync46, renameSync as renameSync18, unlinkSync as unlinkSync13 } from "node:fs";
+import { existsSync as existsSync45, renameSync as renameSync18, unlinkSync as unlinkSync13 } from "node:fs";
 import { copyFile as copyFile2, mkdir as mkdir19, readFile as readFile21, stat as stat10, writeFile as writeFile17 } from "node:fs/promises";
 import * as path79 from "node:path";
 function resolveMemoryStorageDir(rootDirectory, config3 = {}) {
@@ -85297,10 +85521,10 @@ async function backupLegacyJsonl(rootDirectory, config3 = {}) {
   const results = [];
   for (const filename of ["memories.jsonl", "proposals.jsonl"]) {
     const source = path79.join(storageDir, filename);
-    if (!existsSync46(source))
+    if (!existsSync45(source))
       continue;
     const backup = path79.join(backupDir, `${filename}.pre-sqlite-migration`);
-    if (existsSync46(backup)) {
+    if (existsSync45(backup)) {
       results.push({ source, backup, created: false });
       continue;
     }
@@ -85354,7 +85578,7 @@ async function writeMigrationReport(rootDirectory, report, config3 = {}) {
 }
 async function readMigrationReport(rootDirectory, config3 = {}) {
   const reportPath = path79.join(resolveMemoryStorageDir(rootDirectory, config3), "migration-report.json");
-  if (!existsSync46(reportPath))
+  if (!existsSync45(reportPath))
     return null;
   try {
     return JSON.parse(await readFile21(reportPath, "utf-8"));
@@ -85368,13 +85592,13 @@ async function getLegacyJsonlFileStatus(rootDirectory, config3 = {}) {
   for (const file3 of ["memories.jsonl", "proposals.jsonl"]) {
     const filePath = path79.join(storageDir, file3);
     let sizeBytes = 0;
-    if (existsSync46(filePath)) {
+    if (existsSync45(filePath)) {
       sizeBytes = (await stat10(filePath)).size;
     }
     statuses.push({
       file: file3,
       path: filePath,
-      exists: existsSync46(filePath),
+      exists: existsSync45(filePath),
       sizeBytes
     });
   }
@@ -85455,7 +85679,7 @@ async function readProposalJsonl(filePath, config3) {
   return { records, invalidRows, totalRows: rows.totalRows };
 }
 async function readJsonlRows(filePath) {
-  if (!existsSync46(filePath)) {
+  if (!existsSync45(filePath)) {
     return { rows: [], invalidRows: [], totalRows: 0 };
   }
   const content = await readFile21(filePath, "utf-8");
@@ -86729,7 +86953,7 @@ var init_provider_pool = __esm(() => {
 
 // src/memory/gateway.ts
 import { createHash as createHash13 } from "node:crypto";
-import { existsSync as existsSync47, readFileSync as readFileSync27 } from "node:fs";
+import { existsSync as existsSync46, readFileSync as readFileSync27 } from "node:fs";
 import * as path82 from "node:path";
 
 class MemoryGateway {
@@ -87090,7 +87314,7 @@ function readGitRemoteUrl(directory) {
   if (gitRemoteUrlCache.has(directory))
     return gitRemoteUrlCache.get(directory);
   const gitConfigPath = path82.join(directory, ".git", "config");
-  if (!existsSync47(gitConfigPath)) {
+  if (!existsSync46(gitConfigPath)) {
     gitRemoteUrlCache.set(directory, undefined);
     return;
   }
@@ -88194,7 +88418,7 @@ var init_consolidation_log = __esm(() => {
 });
 
 // src/commands/memory.ts
-import { existsSync as existsSync48 } from "node:fs";
+import { existsSync as existsSync47 } from "node:fs";
 import * as path86 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 async function handleMemoryCommand(_directory, _args) {
@@ -88254,7 +88478,7 @@ async function handleMemoryStatusCommand(directory, _args) {
     `- Provider: \`${config3.provider}\``,
     `- Storage: \`${storageDir}\``,
     `- SQLite path: \`${sqlitePath}\``,
-    `- SQLite database exists: \`${existsSync48(sqlitePath)}\``,
+    `- SQLite database exists: \`${existsSync47(sqlitePath)}\``,
     `- Automatic destructive cleanup: \`disabled\``,
     "",
     "### Legacy JSONL"
@@ -93116,19 +93340,19 @@ function hasCompoundTestExtension(filename) {
   const lower = filename.toLowerCase();
   return COMPOUND_TEST_EXTENSIONS.some((ext) => lower.endsWith(ext));
 }
-function isLanguageSpecificTestFile(basename13) {
-  const lower = basename13.toLowerCase();
+function isLanguageSpecificTestFile(basename14) {
+  const lower = basename14.toLowerCase();
   if (lower.endsWith("_test.go"))
     return true;
   if (lower.endsWith(".py") && (lower.startsWith("test_") || lower.endsWith("_test.py")))
     return true;
   if (lower.endsWith("_spec.rb"))
     return true;
-  if (lower.endsWith(".java") && (/^Test[A-Z]/.test(basename13) || basename13.endsWith("Test.java") || basename13.endsWith("Tests.java") || lower.endsWith("it.java")))
+  if (lower.endsWith(".java") && (/^Test[A-Z]/.test(basename14) || basename14.endsWith("Test.java") || basename14.endsWith("Tests.java") || lower.endsWith("it.java")))
     return true;
   if (lower.endsWith(".cs") && (lower.endsWith("test.cs") || lower.endsWith("tests.cs")))
     return true;
-  if (lower.endsWith(".kt") && (/^Test[A-Z]/.test(basename13) || lower.endsWith("test.kt") || lower.endsWith("tests.kt")))
+  if (lower.endsWith(".kt") && (/^Test[A-Z]/.test(basename14) || lower.endsWith("test.kt") || lower.endsWith("tests.kt")))
     return true;
   if (lower.endsWith(".tests.ps1"))
     return true;
@@ -93136,23 +93360,23 @@ function isLanguageSpecificTestFile(basename13) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename13 = path99.basename(filePath);
-  return hasCompoundTestExtension(basename13) || basename13.includes(".spec.") || basename13.includes(".test.") || isLanguageSpecificTestFile(basename13) || isTestDirectoryPath(normalizedPath);
+  const basename14 = path99.basename(filePath);
+  return hasCompoundTestExtension(basename14) || basename14.includes(".spec.") || basename14.includes(".test.") || isLanguageSpecificTestFile(basename14) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file3 of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file3, workingDir);
     const relativeFile = path99.relative(workingDir, absoluteFile);
-    const basename13 = path99.basename(absoluteFile);
+    const basename14 = path99.basename(absoluteFile);
     const dirname45 = path99.dirname(absoluteFile);
     const preferRelativeOutput = !path99.isAbsolute(file3);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file3)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
-    const nameWithoutExt = basename13.replace(/\.[^.]+$/, "");
-    const ext = path99.extname(basename13);
+    const nameWithoutExt = basename14.replace(/\.[^.]+$/, "");
+    const ext = path99.extname(basename14);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -93163,7 +93387,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
       ...languageSpecificTestNames
     ].map((candidateName) => path99.join(dirname45, candidateName));
     const testDirectoryNames = [
-      basename13,
+      basename14,
       ...genericTestNames,
       ...languageSpecificTestNames
     ];
@@ -98740,12 +98964,12 @@ var init_turbo = __esm(() => {
 });
 
 // src/commands/unlink.ts
-import { existsSync as existsSync60 } from "node:fs";
+import { existsSync as existsSync59 } from "node:fs";
 import * as path110 from "node:path";
 async function copySharedKnowledgeToLocal(linkDir, localSwarmDir) {
   const sharedPath = path110.join(linkDir, "knowledge.jsonl");
   const localPath = path110.join(localSwarmDir, "knowledge.jsonl");
-  if (!existsSync60(sharedPath))
+  if (!existsSync59(sharedPath))
     return 0;
   const sharedEntries = await readKnowledge(sharedPath);
   if (sharedEntries.length === 0)
@@ -105556,11 +105780,11 @@ __export(exports_evidence_summary_integration, {
   createEvidenceSummaryIntegration: () => createEvidenceSummaryIntegration,
   EvidenceSummaryIntegration: () => EvidenceSummaryIntegration
 });
-import { existsSync as existsSync61, mkdirSync as mkdirSync32, writeFileSync as writeFileSync18 } from "node:fs";
+import { existsSync as existsSync60, mkdirSync as mkdirSync32, writeFileSync as writeFileSync18 } from "node:fs";
 import * as path114 from "node:path";
 function persistSummary(projectDir, artifact, filename) {
   const swarmPath = path114.join(projectDir, ".swarm");
-  if (!existsSync61(swarmPath)) {
+  if (!existsSync60(swarmPath)) {
     mkdirSync32(swarmPath, { recursive: true });
   }
   const artifactPath = path114.join(swarmPath, filename);
@@ -106572,7 +106796,7 @@ var init_schema3 = __esm(() => {
 
 // src/summaries/store.ts
 import {
-  existsSync as existsSync73,
+  existsSync as existsSync72,
   mkdirSync as mkdirSync39,
   readFileSync as readFileSync49,
   renameSync as renameSync26,
@@ -106587,7 +106811,7 @@ function writeRawSidecar(absPath, bundle) {
     writeFileSync25(tempFile, JSON.stringify(bundle, null, 2), "utf-8");
     renameSync26(tempFile, absPath);
   } finally {
-    if (existsSync73(tempFile)) {
+    if (existsSync72(tempFile)) {
       try {
         unlinkSync22(tempFile);
       } catch {}
@@ -106674,7 +106898,7 @@ function readSupervisorReportRaw(directory, phase) {
   } catch {
     return null;
   }
-  if (!existsSync73(abs))
+  if (!existsSync72(abs))
     return null;
   try {
     const parsed = JSON.parse(readFileSync49(abs, "utf-8"));
@@ -106773,7 +106997,7 @@ __export(exports_runtime, {
   clearParserCache: () => clearParserCache,
   _internals: () => _internals79
 });
-import { existsSync as existsSync74, statSync as statSync24 } from "node:fs";
+import { existsSync as existsSync73, statSync as statSync24 } from "node:fs";
 import * as path129 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { Language, Parser as TreeSitterParser } from "web-tree-sitter";
@@ -106842,7 +107066,7 @@ async function loadGrammar(languageId) {
     const parser = new TreeSitterParser;
     const wasmFileName = getWasmFileName(normalizedId);
     const wasmPath = path129.join(getGrammarsDirAbsolute(), wasmFileName);
-    if (!existsSync74(wasmPath)) {
+    if (!existsSync73(wasmPath)) {
       throw new Error(`Grammar file not found for ${languageId}: ${wasmPath}
 ` + `Make sure to run 'bun run build' to copy grammar files to dist/lang/grammars/`);
     }
@@ -107025,17 +107249,17 @@ function normalizeSeparators(filePath) {
 }
 function matchesDocPattern(filePath, patterns) {
   const normalizedPath = normalizeSeparators(filePath);
-  const basename16 = path142.basename(filePath);
+  const basename17 = path142.basename(filePath);
   for (const pattern of patterns) {
     if (!pattern.includes("/") && !pattern.includes("\\")) {
-      if (basename16 === pattern) {
+      if (basename17 === pattern) {
         return true;
       }
       continue;
     }
     if (pattern.startsWith("**/")) {
       const filenamePattern = pattern.slice(3);
-      if (basename16 === filenamePattern) {
+      if (basename17 === filenamePattern) {
         return true;
       }
       continue;
@@ -107428,7 +107652,7 @@ var init_doc_scan = __esm(() => {
 });
 
 // src/hooks/knowledge-reader.ts
-import { existsSync as existsSync79 } from "node:fs";
+import { existsSync as existsSync78 } from "node:fs";
 import { readFile as readFile29 } from "node:fs/promises";
 import * as path143 from "node:path";
 function inferCategoriesFromPhase(phaseDescription) {
@@ -107476,7 +107700,7 @@ function inferCategoriesFromPhase(phaseDescription) {
 }
 async function transactShownFile(shownFile, mutate) {
   return transactFile(shownFile, async (filePath) => {
-    if (!existsSync79(filePath))
+    if (!existsSync78(filePath))
       return {};
     try {
       const content = await readFile29(filePath, "utf-8");
@@ -107606,7 +107830,7 @@ async function readMergedKnowledge(directory, config3, context, opts) {
 async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
   const shownFile = path143.join(directory, ".swarm", ".knowledge-shown.json");
   try {
-    if (!existsSync79(shownFile)) {
+    if (!existsSync78(shownFile)) {
       return;
     }
     let shownIds;
@@ -108336,7 +108560,7 @@ __export(exports_design_doc_drift, {
   _internals: () => _internals111
 });
 import * as fs118 from "node:fs";
-import * as path188 from "node:path";
+import * as path190 from "node:path";
 function mtimeMsOrNull(absPath) {
   try {
     return fs118.statSync(absPath).mtimeMs;
@@ -108347,35 +108571,35 @@ function mtimeMsOrNull(absPath) {
 function resolveAnchorWithin(directory, anchor) {
   if (!anchor || typeof anchor !== "string")
     return null;
-  const root = path188.resolve(directory);
-  const resolved = path188.resolve(root, anchor);
-  const rel = path188.relative(root, resolved);
-  if (rel.startsWith("..") || path188.isAbsolute(rel))
+  const root = path190.resolve(directory);
+  const resolved = path190.resolve(root, anchor);
+  const rel = path190.relative(root, resolved);
+  if (rel.startsWith("..") || path190.isAbsolute(rel))
     return null;
   return resolved;
 }
 async function runDesignDocDriftCheck(directory, phase, outDir) {
   try {
-    const root = path188.resolve(directory);
-    const outAbs = path188.resolve(root, outDir);
-    const outRel = path188.relative(root, outAbs);
-    if (outRel.startsWith("..") || path188.isAbsolute(outRel)) {
+    const root = path190.resolve(directory);
+    const outAbs = path190.resolve(root, outDir);
+    const outRel = path190.relative(root, outAbs);
+    if (outRel.startsWith("..") || path190.isAbsolute(outRel)) {
       return null;
     }
     const docMtimes = new Map;
     const checkedDocs = [];
     const missingDocs = [];
     for (const [docName, relFile] of Object.entries(DESIGN_DOC_FILES)) {
-      const abs = path188.join(outAbs, relFile);
+      const abs = path190.join(outAbs, relFile);
       const mtime = mtimeMsOrNull(abs);
       docMtimes.set(docName, mtime);
       if (mtime === null) {
-        missingDocs.push(path188.join(outDir, relFile));
+        missingDocs.push(path190.join(outDir, relFile));
       } else {
-        checkedDocs.push(path188.join(outDir, relFile));
+        checkedDocs.push(path190.join(outDir, relFile));
       }
     }
-    const traceabilityAbs = path188.join(outAbs, TRACEABILITY_REL);
+    const traceabilityAbs = path190.join(outAbs, TRACEABILITY_REL);
     let registry3 = null;
     try {
       const stat14 = await fs118.promises.stat(traceabilityAbs);
@@ -108445,7 +108669,7 @@ async function runDesignDocDriftCheck(directory, phase, outDir) {
     };
     const filename = `${DOC_DRIFT_REPORT_PREFIX}${phase}.json`;
     const filePath = validateSwarmPath(directory, filename);
-    await fs118.promises.mkdir(path188.dirname(filePath), { recursive: true });
+    await fs118.promises.mkdir(path190.dirname(filePath), { recursive: true });
     await fs118.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
     getGlobalEventBus().publish("curator.docdrift.completed", {
       phase,
@@ -108477,10 +108701,10 @@ var init_design_doc_drift = __esm(() => {
     domain: "domain.md",
     "technical-spec": "technical-spec.md",
     "behavior-spec": "behavior-spec.md",
-    "reference-impl": path188.join("reference", "reference-impl.md"),
-    "idiom-notes": path188.join("reference", "idiom-notes.md")
+    "reference-impl": path190.join("reference", "reference-impl.md"),
+    "idiom-notes": path190.join("reference", "idiom-notes.md")
   };
-  TRACEABILITY_REL = path188.join("reference", "traceability.json");
+  TRACEABILITY_REL = path190.join("reference", "traceability.json");
   _internals111 = {
     mtimeMsOrNull,
     resolveAnchorWithin,
@@ -108492,11 +108716,11 @@ var init_design_doc_drift = __esm(() => {
 var exports_project_context = {};
 __export(exports_project_context, {
   buildProjectContext: () => buildProjectContext,
-  _internals: () => _internals124,
+  _internals: () => _internals125,
   LANG_BACKEND_DETECTION_TIMEOUT_MS: () => LANG_BACKEND_DETECTION_TIMEOUT_MS
 });
 import * as fs142 from "node:fs";
-import * as path217 from "node:path";
+import * as path219 from "node:path";
 function detectFileExists2(directory, pattern) {
   if (pattern.includes("*") || pattern.includes("?")) {
     try {
@@ -108508,7 +108732,7 @@ function detectFileExists2(directory, pattern) {
     }
   }
   try {
-    fs142.accessSync(path217.join(directory, pattern));
+    fs142.accessSync(path219.join(directory, pattern));
     return true;
   } catch {
     return false;
@@ -108517,7 +108741,7 @@ function detectFileExists2(directory, pattern) {
 function selectTestCommandFromScriptsTest(backend, directory) {
   let pkgRaw;
   try {
-    pkgRaw = fs142.readFileSync(path217.join(directory, "package.json"), "utf-8");
+    pkgRaw = fs142.readFileSync(path219.join(directory, "package.json"), "utf-8");
   } catch {
     return null;
   }
@@ -108576,7 +108800,7 @@ function selectLintCommand(backend, directory) {
   return null;
 }
 async function buildProjectContext(directory) {
-  const backend = await _internals124.pickBackend(directory);
+  const backend = await _internals125.pickBackend(directory);
   if (!backend)
     return null;
   const ctx = emptyProjectContext();
@@ -108615,17 +108839,17 @@ async function buildProjectContext(directory) {
   if (backend.prompts.reviewerChecklist.length > 0) {
     ctx.REVIEWER_CHECKLIST = bulletList(backend.prompts.reviewerChecklist);
   }
-  const profiles = _internals124.pickedProfiles(directory);
+  const profiles = _internals125.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, _internals124;
+var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals125;
 var init_project_context = __esm(() => {
   init_dispatch();
   init_framework_detector();
-  _internals124 = {
+  _internals125 = {
     pickBackend,
     pickedProfiles
   };
@@ -108635,7 +108859,7 @@ var init_project_context = __esm(() => {
 init_package();
 init_agents2();
 init_critic();
-import * as path218 from "node:path";
+import * as path220 from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // src/background/index.ts
@@ -113337,7 +113561,7 @@ import * as path138 from "node:path";
 // src/tools/repo-graph/builder.ts
 init_profiles();
 import * as fsSync8 from "node:fs";
-import { existsSync as existsSync75, realpathSync as realpathSync14 } from "node:fs";
+import { existsSync as existsSync74, realpathSync as realpathSync14 } from "node:fs";
 import * as fsPromises5 from "node:fs/promises";
 import * as os17 from "node:os";
 import * as path133 from "node:path";
@@ -115549,7 +115773,7 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
       if (realRoot === null) {
         return null;
       }
-      if (!existsSync75(resolved)) {
+      if (!existsSync74(resolved)) {
         const EXTENSIONS = [
           ".ts",
           ".tsx",
@@ -115563,7 +115787,7 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
         let found = null;
         for (const ext of EXTENSIONS) {
           const candidate = resolved + ext;
-          if (existsSync75(candidate)) {
+          if (existsSync74(candidate)) {
             found = candidate;
             break;
           }
@@ -116061,7 +116285,7 @@ async function buildWorkspaceGraphAsync(workspaceRoot, options) {
   const walkBudgetMs = options?.walkBudgetMs ?? DEFAULT_WALK_BUDGET_MS;
   const followSymlinks = options?.followSymlinks ?? false;
   const absoluteRoot = path133.resolve(workspaceRoot);
-  if (!existsSync75(absoluteRoot)) {
+  if (!existsSync74(absoluteRoot)) {
     throw new Error(`Workspace directory does not exist: ${workspaceRoot}`);
   }
   if (isRefusedWorkspaceRoot(absoluteRoot)) {
@@ -116170,7 +116394,7 @@ function getCachedMtime(workspace) {
 // src/tools/repo-graph/incremental.ts
 init_logger();
 init_path_security();
-import { existsSync as existsSync77 } from "node:fs";
+import { existsSync as existsSync76 } from "node:fs";
 import * as fsPromises7 from "node:fs/promises";
 import * as path137 from "node:path";
 
@@ -116862,7 +117086,7 @@ function buildOntologyPreflightPacket(graph, filePaths = [], options = {}) {
 init_utils2();
 init_logger();
 init_path_security();
-import { constants as constants5, existsSync as existsSync76, readFileSync as readFileSync52, statSync as statSync27 } from "node:fs";
+import { constants as constants5, existsSync as existsSync75, readFileSync as readFileSync52, statSync as statSync27 } from "node:fs";
 import * as fsPromises6 from "node:fs/promises";
 import * as path136 from "node:path";
 var WINDOWS_RENAME_MAX_RETRIES2 = 5;
@@ -116934,7 +117158,7 @@ async function loadGraph(workspace) {
   if (cached3 && !isDirty(normalized)) {
     try {
       const graphPath = getGraphPath(workspace);
-      if (existsSync76(graphPath)) {
+      if (existsSync75(graphPath)) {
         const stats2 = await fsPromises6.stat(graphPath);
         const cachedMtime = getCachedMtime(normalized);
         if (cachedMtime !== undefined && stats2.mtimeMs !== cachedMtime) {
@@ -116951,7 +117175,7 @@ async function loadGraph(workspace) {
   }
   try {
     const graphPath = getGraphPath(workspace);
-    if (!existsSync76(graphPath)) {
+    if (!existsSync75(graphPath)) {
       return null;
     }
     const stats2 = await fsPromises6.stat(graphPath);
@@ -116985,7 +117209,7 @@ function loadGraphSync(workspace) {
   const normalized = path136.normalize(workspace);
   try {
     const graphPath = getGraphPath(workspace);
-    if (!existsSync76(graphPath))
+    if (!existsSync75(graphPath))
       return null;
     const stats2 = statSync27(graphPath);
     const content = readFileSync52(graphPath, "utf-8");
@@ -117115,7 +117339,7 @@ async function updateGraphForFiles(workspaceRoot, filePaths, options) {
   const updatedPaths = new Set;
   for (const rawFilePath of filePaths) {
     const normalizedPath = normalizeGraphPath(rawFilePath);
-    const fileExists = existsSync77(rawFilePath);
+    const fileExists = existsSync76(rawFilePath);
     if (fileExists) {
       graph.edges = graph.edges.filter((e) => normalizeGraphPath(e.source) !== normalizedPath);
       if (graph.symbolEdges) {
@@ -117190,7 +117414,7 @@ async function updateGraphForFiles(workspaceRoot, filePaths, options) {
   if (loadedMtime !== undefined) {
     try {
       const graphPath = getGraphPath(workspaceRoot);
-      if (existsSync77(graphPath)) {
+      if (existsSync76(graphPath)) {
         const currentStats = await fsPromises7.stat(graphPath);
         if (currentStats.mtimeMs !== loadedMtime) {
           warn(`[repo-graph] Concurrent modification detected — falling back to full rebuild`);
@@ -121362,7 +121586,7 @@ init_logger();
 init_knowledge_link();
 init_knowledge_store();
 var import_proper_lockfile9 = __toESM(require_proper_lockfile(), 1);
-import { existsSync as existsSync81 } from "node:fs";
+import { existsSync as existsSync80 } from "node:fs";
 import { appendFile as appendFile14, mkdir as mkdir29, readFile as readFile31 } from "node:fs/promises";
 import * as path147 from "node:path";
 function resolveApplicationLogPath(directory) {
@@ -121451,7 +121675,7 @@ async function bumpCountersBatch(directory, bumps) {
   const swarmPath = resolveSwarmKnowledgePath(directory);
   await transactKnowledge(swarmPath, applyOne);
   const hivePath = resolveHiveKnowledgePath();
-  if (existsSync81(hivePath)) {
+  if (existsSync80(hivePath)) {
     await transactKnowledge(hivePath, applyOne);
   }
 }
@@ -122425,7 +122649,7 @@ init_extractors();
 // src/hooks/phase-directives.ts
 init_knowledge_events();
 init_knowledge_store();
-import { existsSync as existsSync82 } from "node:fs";
+import { existsSync as existsSync81 } from "node:fs";
 async function collectPhaseDirectiveIds(directory, phaseLabel) {
   const events = await readKnowledgeEvents(directory);
   const ids = new Set;
@@ -122445,7 +122669,7 @@ async function readEntriesById(directory) {
   for (const e of swarm)
     map3.set(e.id, e);
   const hivePath = resolveHiveKnowledgePath();
-  if (existsSync82(hivePath)) {
+  if (existsSync81(hivePath)) {
     const hive = await readKnowledge(hivePath);
     for (const e of hive)
       if (!map3.has(e.id))
@@ -124337,7 +124561,7 @@ init_schema();
 // src/services/directive-predicate-runner.ts
 init_bun_compat();
 init_logger();
-import { existsSync as existsSync85 } from "node:fs";
+import { existsSync as existsSync84 } from "node:fs";
 import * as path153 from "node:path";
 var PREDICATE_TIMEOUT_MS = 15000;
 var TOOL_BINARY_ALLOWLIST = new Set([
@@ -124379,7 +124603,7 @@ function findBinaryInPath(binary) {
     if (!dir)
       continue;
     const candidate = path153.join(dir, exeName);
-    if (existsSync85(candidate))
+    if (existsSync84(candidate))
       return candidate;
   }
   return null;
@@ -125454,7 +125678,7 @@ init_zod();
 init_path_security();
 init_create_tool();
 import {
-  existsSync as existsSync87,
+  existsSync as existsSync86,
   mkdirSync as mkdirSync40,
   mkdtempSync as mkdtempSync2,
   readFileSync as readFileSync57,
@@ -125817,13 +126041,13 @@ function atomicWriteFileSync2(targetPath, content) {
     writeFileSync26(tempPath, content, "utf-8");
     renameSync29(tempPath, targetPath);
   } finally {
-    if (existsSync87(tempPath)) {
+    if (existsSync86(tempPath)) {
       try {
         unlinkSync25(tempPath);
       } catch {}
     }
     const tempDir = path156.dirname(tempPath);
-    if (tempDir !== dir && existsSync87(tempDir)) {
+    if (tempDir !== dir && existsSync86(tempDir)) {
       try {
         rmdirSync(tempDir);
       } catch {}
@@ -125900,7 +126124,7 @@ function processFileDiff(fileDiff, targetPath, fullPath, workspace, dryRun, allo
       };
     }
     const parentDir = path156.dirname(fullPath);
-    if (!existsSync87(parentDir)) {
+    if (!existsSync86(parentDir)) {
       return {
         file: targetPath,
         status: "error",
@@ -125916,7 +126140,7 @@ function processFileDiff(fileDiff, targetPath, fullPath, workspace, dryRun, allo
         ]
       };
     }
-    if (existsSync87(fullPath)) {
+    if (existsSync86(fullPath)) {
       return {
         file: targetPath,
         status: "error",
@@ -125991,7 +126215,7 @@ function processFileDiff(fileDiff, targetPath, fullPath, workspace, dryRun, allo
         ]
       };
     }
-    if (!existsSync87(fullPath)) {
+    if (!existsSync86(fullPath)) {
       return {
         file: targetPath,
         status: "error",
@@ -126035,7 +126259,7 @@ function processFileDiff(fileDiff, targetPath, fullPath, workspace, dryRun, allo
       hunksFailed: 0
     };
   }
-  if (!existsSync87(fullPath)) {
+  if (!existsSync86(fullPath)) {
     return {
       file: targetPath,
       status: "error",
@@ -126190,7 +126414,7 @@ var swarmApplyPatch = createSwarmTool({
     const dryRun = obj.dryRun ?? false;
     const allowCreates = obj.allowCreates ?? false;
     const allowDeletes = obj.allowDeletes ?? false;
-    if (!existsSync87(directory)) {
+    if (!existsSync86(directory)) {
       return JSON.stringify(buildErrorResult("Workspace directory does not exist"), null, 2);
     }
     if (files.length === 0) {
@@ -127383,7 +127607,7 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename18 = path160.basename(filePath);
+  const basename19 = path160.basename(filePath);
   const _ext = path160.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
@@ -127399,7 +127623,7 @@ function isTestFile(filePath) {
     ".spec.jsx"
   ];
   for (const pattern of testPatterns) {
-    if (basename18.includes(pattern)) {
+    if (basename19.includes(pattern)) {
       return true;
     }
   }
@@ -128012,7 +128236,7 @@ ${body}`);
 // src/council/council-evidence-writer.ts
 init_zod();
 init_task_file();
-import { appendFileSync as appendFileSync18, existsSync as existsSync92, mkdirSync as mkdirSync42, readFileSync as readFileSync63 } from "node:fs";
+import { appendFileSync as appendFileSync18, existsSync as existsSync91, mkdirSync as mkdirSync42, readFileSync as readFileSync63 } from "node:fs";
 import { join as join128 } from "node:path";
 var EVIDENCE_DIR2 = ".swarm/evidence";
 var VALID_TASK_ID = /^\d+\.\d+(\.\d+)*$/;
@@ -128056,7 +128280,7 @@ async function writeCouncilEvidence(workingDir, synthesis) {
   const filePath = taskEvidencePath(workingDir, synthesis.taskId);
   await _internals90.withTaskEvidenceLock(workingDir, synthesis.taskId, COUNCIL_AGENT_ID, async () => {
     const existingRoot = Object.create(null);
-    if (existsSync92(filePath)) {
+    if (existsSync91(filePath)) {
       try {
         const parsed = EvidenceFileSchema.parse(JSON.parse(readFileSync63(filePath, "utf-8")));
         safeAssignOwnProps(existingRoot, parsed);
@@ -128451,7 +128675,7 @@ function buildFinalCouncilFeedback(projectSummary, verdict, vetoedBy, requiredFi
 // src/council/criteria-store.ts
 init_zod();
 init_task_file();
-import { existsSync as existsSync93, mkdirSync as mkdirSync43, readFileSync as readFileSync64 } from "node:fs";
+import { existsSync as existsSync92, mkdirSync as mkdirSync43, readFileSync as readFileSync64 } from "node:fs";
 import { join as join129 } from "node:path";
 var COUNCIL_DIR = ".swarm/council";
 var CouncilCriteriaSchema = exports_external.object({
@@ -128475,7 +128699,7 @@ async function writeCriteria(workingDir, taskId, criteria) {
 }
 function readCriteria(workingDir, taskId) {
   const filePath = join129(workingDir, COUNCIL_DIR, `${safeId(taskId)}.json`);
-  if (!existsSync93(filePath))
+  if (!existsSync92(filePath))
     return null;
   try {
     return CouncilCriteriaSchema.parse(JSON.parse(readFileSync64(filePath, "utf-8")));
@@ -130199,7 +130423,7 @@ init_zod();
 init_utils2();
 import { createHash as createHash19 } from "node:crypto";
 import {
-  existsSync as existsSync95,
+  existsSync as existsSync94,
   mkdirSync as mkdirSync44,
   readFileSync as readFileSync67,
   renameSync as renameSync30,
@@ -130250,7 +130474,7 @@ function storeLaneOutput(directory, input, now = Date.now) {
   const absPath = validateSwarmPath(directory, relPath);
   const timestamp = new Date(now()).toISOString();
   try {
-    if (existsSync95(absPath)) {
+    if (existsSync94(absPath)) {
       const existing = LaneOutputArtifactSchema.safeParse(JSON.parse(readFileSync67(absPath, "utf-8")));
       if (existing.success && existing.data.digest === digest3) {
         return {
@@ -130304,7 +130528,7 @@ function readLaneOutput(directory, ref) {
   if (!REF_RE.test(ref))
     return null;
   const absPath = validateSwarmPath(directory, laneOutputRelativePath(ref));
-  if (!existsSync95(absPath))
+  if (!existsSync94(absPath))
     return null;
   let parsed;
   try {
@@ -130406,7 +130630,7 @@ function writeAtomicJson(absPath, value) {
     if (lastRenameError)
       throw lastRenameError;
   } finally {
-    if (existsSync95(tempFile)) {
+    if (existsSync94(tempFile)) {
       try {
         unlinkSync26(tempFile);
       } catch {}
@@ -135442,9 +135666,9 @@ var _internals105 = {
   },
   getTimestamp: () => new Date().toISOString(),
   retireSkillFile: async (filePath) => {
-    const { unlink: unlink7 } = await import("node:fs/promises");
+    const { unlink: unlink8 } = await import("node:fs/promises");
     try {
-      await unlink7(filePath);
+      await unlink8(filePath);
       return true;
     } catch (err) {
       const error93 = err;
@@ -137188,8 +137412,10 @@ var knowledge_add = createSwarmTool({
 init_zod();
 init_knowledge_events();
 init_knowledge_store();
+init_skill_generator();
 init_logger();
 init_create_tool();
+import * as path175 from "node:path";
 var MODES2 = ["archive", "quarantine", "purge"];
 var TIERS = ["swarm", "hive"];
 var knowledge_archive = createSwarmTool({
@@ -137272,6 +137498,44 @@ var knowledge_archive = createSwarmTool({
     } else {
       await recordKnowledgeEvent(directory, tombstone);
     }
+    const allArchivedIds = await getArchivedKnowledgeIds(directory);
+    allArchivedIds.add(id);
+    queueMicrotask(async () => {
+      try {
+        const affectedSkillDirs = await findSkillsBySourceKnowledgeId(directory, id);
+        const staleSkillDirs = await findStaleSkillsBySourceKnowledgeId(directory, allArchivedIds);
+        const allSkillDirs = new Set([
+          ...affectedSkillDirs,
+          ...staleSkillDirs
+        ]);
+        if (allSkillDirs.size === 0)
+          return;
+        const slugSet = new Set;
+        let retiredCount = 0;
+        let staleCount = 0;
+        for (const skillDir of allSkillDirs) {
+          const slug = path175.basename(skillDir);
+          if (slugSet.has(slug))
+            continue;
+          slugSet.add(slug);
+          const result = await retireOrMarkStale(directory, skillDir, allArchivedIds);
+          if (result.action === "retire")
+            retiredCount++;
+          else
+            staleCount++;
+        }
+        const batchEvent = {
+          type: "skill-stale-batch",
+          skillIds: Array.from(slugSet),
+          archivedIds: Array.from(allArchivedIds),
+          retiredCount,
+          staleCount
+        };
+        await recordKnowledgeEvent(directory, batchEvent);
+      } catch (err) {
+        warn(`[knowledge-archive] post-archive skill invalidation failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    });
     return JSON.stringify({
       success: true,
       id,
@@ -137288,7 +137552,7 @@ init_zod();
 init_config();
 init_knowledge_store();
 init_create_tool();
-import { existsSync as existsSync101 } from "node:fs";
+import { existsSync as existsSync100 } from "node:fs";
 var DEFAULT_LIMIT = 10;
 var MAX_LESSON_LENGTH = 200;
 var VALID_CATEGORIES3 = [
@@ -137364,14 +137628,14 @@ function validateLimit(limit) {
 }
 async function readSwarmKnowledge(directory) {
   const swarmPath = resolveSwarmKnowledgePath(directory);
-  if (!existsSync101(swarmPath)) {
+  if (!existsSync100(swarmPath)) {
     return [];
   }
   return readKnowledge(swarmPath);
 }
 async function readHiveKnowledge() {
   const hivePath = resolveHiveKnowledgePath();
-  if (!existsSync101(hivePath)) {
+  if (!existsSync100(hivePath)) {
     return [];
   }
   return readKnowledge(hivePath);
@@ -137640,7 +137904,7 @@ var knowledge_receipt = createSwarmTool({
     const recordedEventIds = [];
     const emit2 = async (event) => {
       const written = await recordKnowledgeEvent(directory, event);
-      if (written)
+      if (written && written.event_id !== undefined)
         recordedEventIds.push(written.event_id);
     };
     for (const item of applied) {
@@ -137706,8 +137970,12 @@ var knowledge_receipt = createSwarmTool({
 
 // src/tools/knowledge-remove.ts
 init_zod();
+init_knowledge_events();
 init_knowledge_store();
+init_skill_generator();
+init_logger();
 init_create_tool();
+import * as path176 from "node:path";
 var knowledge_remove = createSwarmTool({
   description: "Delete an outdated swarm knowledge entry by ID (swarm tier only — does not affect hive). Promoted entries cannot be deleted. Double-deletion is idempotent — removing a non-existent entry returns a clear message without error.",
   args: {
@@ -137767,6 +138035,44 @@ var knowledge_remove = createSwarmTool({
         message: "entry not found"
       });
     }
+    const allArchivedIds = await getArchivedKnowledgeIds(directory);
+    allArchivedIds.add(id);
+    queueMicrotask(async () => {
+      try {
+        const affectedSkillDirs = await findSkillsBySourceKnowledgeId(directory, id);
+        const staleSkillDirs = await findStaleSkillsBySourceKnowledgeId(directory, allArchivedIds);
+        const allSkillDirs = new Set([
+          ...affectedSkillDirs,
+          ...staleSkillDirs
+        ]);
+        if (allSkillDirs.size === 0)
+          return;
+        const slugSet = new Set;
+        let retiredCount = 0;
+        let staleCount = 0;
+        for (const skillDir of allSkillDirs) {
+          const slug = path176.basename(skillDir);
+          if (slugSet.has(slug))
+            continue;
+          slugSet.add(slug);
+          const result = await retireOrMarkStale(directory, skillDir, allArchivedIds);
+          if (result.action === "retire")
+            retiredCount++;
+          else
+            staleCount++;
+        }
+        const batchEvent = {
+          type: "skill-stale-batch",
+          skillIds: Array.from(slugSet),
+          archivedIds: Array.from(allArchivedIds),
+          retiredCount,
+          staleCount
+        };
+        await recordKnowledgeEvent(directory, batchEvent);
+      } catch (err) {
+        warn(`[knowledge-remove] post-purge skill invalidation failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    });
     return JSON.stringify({
       success: true,
       removed: 1,
@@ -137821,10 +138127,10 @@ var lean_turbo_acquire_locks = createSwarmTool({
 init_zod();
 init_constants();
 import * as fs108 from "node:fs";
-import * as path175 from "node:path";
+import * as path177 from "node:path";
 init_create_tool();
 function readPlanJson2(directory) {
-  const planPath = path175.join(directory, ".swarm", "plan.json");
+  const planPath = path177.join(directory, ".swarm", "plan.json");
   if (!fs108.existsSync(planPath)) {
     return null;
   }
@@ -138192,12 +138498,12 @@ var lint_spec = createSwarmTool({
 // src/tools/mutation-test.ts
 init_zod();
 import * as fs109 from "node:fs";
-import * as path177 from "node:path";
+import * as path179 from "node:path";
 
 // src/mutation/engine.ts
 import { spawnSync as spawnSync13 } from "node:child_process";
 import { unlinkSync as unlinkSync27, writeFileSync as writeFileSync30 } from "node:fs";
-import * as path176 from "node:path";
+import * as path178 from "node:path";
 
 // src/mutation/equivalence.ts
 function isStaticallyEquivalent(originalCode, mutatedCode) {
@@ -138360,7 +138666,7 @@ function validateTestCommand(testCommand) {
     return "testCommand must not be empty";
   }
   const exe = testCommand[0];
-  const base = path176.basename(exe).replace(/\.(exe|cmd|bat)$/i, "");
+  const base = path178.basename(exe).replace(/\.(exe|cmd|bat)$/i, "");
   if (!ALLOWED_TEST_RUNNERS.has(base)) {
     return `testCommand executable '${exe}' is not in the allowed test runner list. Permitted runners: ${[...ALLOWED_TEST_RUNNERS].join(", ")}`;
   }
@@ -138384,7 +138690,7 @@ async function executeMutation(patch, testCommand, testFiles, workingDir) {
   let patchFile;
   try {
     const safeId2 = patch.id.replace(/[^a-zA-Z0-9_-]/g, "_");
-    patchFile = path176.join(workingDir, `.mutation_patch_${safeId2}.diff`);
+    patchFile = path178.join(workingDir, `.mutation_patch_${safeId2}.diff`);
     try {
       writeFileSync30(patchFile, patch.patch);
     } catch (writeErr) {
@@ -138801,7 +139107,7 @@ var mutation_test = createSwarmTool({
       ];
       for (const filePath of uniquePaths) {
         try {
-          const resolvedPath = path177.resolve(cwd, filePath);
+          const resolvedPath = path179.resolve(cwd, filePath);
           sourceFiles.set(filePath, fs109.readFileSync(resolvedPath, "utf-8"));
         } catch {}
       }
@@ -138819,8 +139125,8 @@ var mutation_test = createSwarmTool({
 
 // src/tools/parse-lane-candidates.ts
 init_zod();
-import { existsSync as existsSync103 } from "node:fs";
-import * as path179 from "node:path";
+import { existsSync as existsSync102 } from "node:fs";
+import * as path181 from "node:path";
 
 // src/background/candidate-parser.ts
 init_zod();
@@ -138831,7 +139137,7 @@ init_utils2();
 var import_proper_lockfile10 = __toESM(require_proper_lockfile(), 1);
 import { createHash as createHash24 } from "node:crypto";
 import { appendFileSync as appendFileSync19, mkdirSync as mkdirSync46 } from "node:fs";
-import * as path178 from "node:path";
+import * as path180 from "node:path";
 var BATCH_DIGEST_ALGORITHM = "sha256";
 var SidecarEnvelopeSchema = exports_external.object({
   record_type: exports_external.literal("invocation"),
@@ -138986,7 +139292,7 @@ function computeBatchDigest(batchId) {
   return createHash24(BATCH_DIGEST_ALGORITHM).update(batchId).digest("hex");
 }
 function sidecarRelativePath(batchDigest) {
-  return path178.join("lane-results", batchDigest, "candidates.jsonl");
+  return path180.join("lane-results", batchDigest, "candidates.jsonl");
 }
 function validateRecord(record3, schema, label) {
   const result = schema.safeParse(record3);
@@ -138995,7 +139301,7 @@ function validateRecord(record3, schema, label) {
   }
 }
 function withLockfile(lockDir, write) {
-  const lockPath = path178.join(lockDir, ".lock");
+  const lockPath = path180.join(lockDir, ".lock");
   const lf = import_proper_lockfile10.default;
   const release = lf.lockSync(lockPath, {
     realpath: false
@@ -139014,7 +139320,7 @@ function appendToSidecar(options, batchId, envelope, candidates) {
   for (let i = 0;i < candidates.length; i++) {
     validateRecord(candidates[i], SidecarCandidateSchema, `candidate[${i}]`);
   }
-  mkdirSync46(path178.dirname(absPath), { recursive: true });
+  mkdirSync46(path180.dirname(absPath), { recursive: true });
   const sanitizedEnvelope = sanitizeRecord(structuredClone(envelope));
   const sanitizedCandidates = candidates.map((c) => sanitizeRecord(structuredClone(c)));
   const lines = [JSON.stringify(sanitizedEnvelope)];
@@ -139028,7 +139334,7 @@ function appendToSidecar(options, batchId, envelope, candidates) {
     appendFileSync19(absPath, payload, "utf-8");
   };
   if (options.useLockfile) {
-    withLockfile(path178.dirname(absPath), doWrite);
+    withLockfile(path180.dirname(absPath), doWrite);
   } else {
     doWrite();
   }
@@ -139487,7 +139793,7 @@ function laneOutputRelativePath2(ref) {
   if (parts.length !== 4)
     return "";
   const [, batchDigest, laneDigest, outputDigest] = parts;
-  return path179.join("lane-results", batchDigest, laneDigest, `${outputDigest}.json`);
+  return path181.join("lane-results", batchDigest, laneDigest, `${outputDigest}.json`);
 }
 var parse_lane_candidates = createSwarmTool({
   description: "Parse [CANDIDATE] rows from a dispatch_lanes or collect_lane_results artifact (by output_ref), produce structured records with provenance, optionally persist to a per-batch sidecar JSONL. Pure-parser variant exists as internal module.",
@@ -139522,10 +139828,10 @@ var parse_lane_candidates = createSwarmTool({
       project_root
     } = parsed.data;
     if (project_root !== undefined) {
-      const absRoot = path179.resolve(project_root);
-      const absDir = path179.resolve(directory);
-      const rel = path179.relative(absDir, absRoot);
-      if (rel === ".." || rel.startsWith(`..${path179.sep}`) || path179.isAbsolute(rel)) {
+      const absRoot = path181.resolve(project_root);
+      const absDir = path181.resolve(directory);
+      const rel = path181.relative(absDir, absRoot);
+      if (rel === ".." || rel.startsWith(`..${path181.sep}`) || path181.isAbsolute(rel)) {
         return JSON.stringify({
           success: false,
           failure_class: "invalid_args",
@@ -139545,7 +139851,7 @@ var parse_lane_candidates = createSwarmTool({
     if (!loaded) {
       const relPath = REF_RE2.test(output_ref) ? laneOutputRelativePath2(output_ref) : "";
       const absPath = relPath ? validateSwarmPath(directory, relPath) : "";
-      const fileExists = absPath ? existsSync103(absPath) : false;
+      const fileExists = absPath ? existsSync102(absPath) : false;
       const artifactStatus = fileExists ? "artifact-corrupted" : "ref-not-found";
       const refParts = output_ref.split(":");
       const hasValidRef = REF_RE2.test(output_ref) && refParts.length === 4;
@@ -139618,22 +139924,22 @@ init_schema();
 init_manager2();
 init_task_file();
 import * as fs119 from "node:fs";
-import * as path189 from "node:path";
+import * as path191 from "node:path";
 
 // src/full-auto/phase-approval.ts
 init_utils2();
 init_logger();
 init_state3();
 import * as fs110 from "node:fs";
-import * as path180 from "node:path";
+import * as path182 from "node:path";
 var APPROVAL_TTL_MS = 24 * 60 * 60 * 1000;
 function readEvidenceDir(directory, phase) {
   try {
-    const dirPath = validateSwarmPath(directory, path180.posix.join("evidence", String(phase)));
+    const dirPath = validateSwarmPath(directory, path182.posix.join("evidence", String(phase)));
     if (!fs110.existsSync(dirPath))
       return [];
     const entries = fs110.readdirSync(dirPath);
-    return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path180.join(dirPath, e));
+    return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path182.join(dirPath, e));
   } catch {
     return [];
   }
@@ -139792,7 +140098,13 @@ async function evaluatePhaseCriticalDirectives(params) {
   try {
     const events = await readKnowledgeEvents(params.directory);
     const retrievedThisPhase = events.filter((e) => e.type === "retrieved" && (!params.phaseLabel || e.phase === params.phaseLabel));
-    const phaseStart = retrievedThisPhase.length > 0 ? retrievedThisPhase.map((e) => e.timestamp).reduce((a, b) => a < b ? a : b) : null;
+    const phaseStart = retrievedThisPhase.length > 0 ? retrievedThisPhase.map((e) => e.timestamp).reduce((a, b) => {
+      if (b === undefined)
+        return a;
+      if (a === undefined)
+        return b;
+      return a < b ? a : b;
+    }, undefined) : null;
     const criticalIds = await readCriticalIdsForPhase(params.directory, params.phaseLabel);
     if (criticalIds.length === 0) {
       return {
@@ -139802,7 +140114,13 @@ async function evaluatePhaseCriticalDirectives(params) {
         failedClosed: false
       };
     }
-    const receipts = events.filter(isReceipt).filter((r) => phaseStart === null || r.timestamp >= phaseStart).map((r) => ({
+    const receipts = events.filter(isReceipt).filter((r) => {
+      if (phaseStart === null || phaseStart === undefined)
+        return true;
+      if (r.timestamp === undefined)
+        return false;
+      return r.timestamp >= phaseStart;
+    }).map((r) => ({
       type: r.type,
       knowledge_id: r.knowledge_id,
       timestamp: r.timestamp,
@@ -139888,16 +140206,16 @@ init_plan_schema();
 init_ledger();
 init_manager();
 import * as fs111 from "node:fs";
-import * as path181 from "node:path";
+import * as path183 from "node:path";
 async function writeCheckpoint(directory) {
   try {
     const plan = await loadPlan(directory);
     if (!plan)
       return;
-    const swarmDir = path181.join(directory, ".swarm");
+    const swarmDir = path183.join(directory, ".swarm");
     fs111.mkdirSync(swarmDir, { recursive: true });
-    const jsonPath = path181.join(swarmDir, "SWARM_PLAN.json");
-    const mdPath = path181.join(swarmDir, "SWARM_PLAN.md");
+    const jsonPath = path183.join(swarmDir, "SWARM_PLAN.json");
+    const mdPath = path183.join(swarmDir, "SWARM_PLAN.md");
     fs111.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
     const md = derivePlanMarkdown(plan);
     fs111.writeFileSync(mdPath, md, "utf8");
@@ -140402,7 +140720,7 @@ init_state();
 // src/turbo/lean/phase-ready.ts
 init_file_locks();
 import * as fs112 from "node:fs";
-import * as path182 from "node:path";
+import * as path184 from "node:path";
 init_state4();
 var DEFAULT_CONFIG3 = {
   phase_reviewer: true,
@@ -140411,7 +140729,7 @@ var DEFAULT_CONFIG3 = {
 };
 function defaultReadPlanJson(dir) {
   try {
-    const planPath = path182.join(dir, ".swarm", "plan.json");
+    const planPath = path184.join(dir, ".swarm", "plan.json");
     if (!fs112.existsSync(planPath))
       return null;
     const raw = fs112.readFileSync(planPath, "utf-8");
@@ -140426,7 +140744,7 @@ function defaultReadPlanJson(dir) {
 }
 function readReviewerEvidenceFromFile(directory, phase) {
   try {
-    const evidencePath = path182.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
+    const evidencePath = path184.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
     if (!fs112.existsSync(evidencePath)) {
       return null;
     }
@@ -140446,7 +140764,7 @@ function readReviewerEvidenceFromFile(directory, phase) {
 }
 function readCriticEvidenceFromFile(directory, phase) {
   try {
-    const evidencePath = path182.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
+    const evidencePath = path184.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
     if (!fs112.existsSync(evidencePath)) {
       return null;
     }
@@ -140465,7 +140783,7 @@ function readCriticEvidenceFromFile(directory, phase) {
   }
 }
 function listLaneEvidenceSync(directory, phase) {
-  const evidenceDir = path182.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const evidenceDir = path184.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
   let entries;
   try {
     entries = fs112.readdirSync(evidenceDir);
@@ -140535,7 +140853,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     ...DEFAULT_CONFIG3,
     ...actualConfig
   };
-  const statePath = path182.join(directory, ".swarm", "turbo-state.json");
+  const statePath = path184.join(directory, ".swarm", "turbo-state.json");
   if (!fs112.existsSync(statePath)) {
     return {
       ok: false,
@@ -140723,7 +141041,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     }
   }
   if (mergedConfig.integrated_diff_required) {
-    const evidencePath = path182.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
+    const evidencePath = path184.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
     let hasDiff = false;
     try {
       const content = fs112.readFileSync(evidencePath, "utf-8");
@@ -140889,7 +141207,7 @@ async function runCompletionVerifyGate(ctx) {
 // src/tools/phase-complete/gates/drift-gate.ts
 init_effective_spec();
 import * as fs113 from "node:fs";
-import * as path183 from "node:path";
+import * as path185 from "node:path";
 
 // src/tools/phase-complete/gates/gate-helpers.ts
 init_qa_gate_profile();
@@ -140938,7 +141256,7 @@ async function runDriftGate(ctx) {
   }
   let phaseType;
   try {
-    const planPath = path183.join(dir, ".swarm", "plan.json");
+    const planPath = path185.join(dir, ".swarm", "plan.json");
     if (fs113.existsSync(planPath)) {
       const planRaw = fs113.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
@@ -140957,7 +141275,7 @@ async function runDriftGate(ctx) {
     };
   }
   try {
-    const driftEvidencePath = path183.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
+    const driftEvidencePath = path185.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
     let driftVerdictFound = false;
     let driftVerdictApproved = false;
     try {
@@ -140998,7 +141316,7 @@ async function runDriftGate(ctx) {
         let incompleteTaskCount = 0;
         let planParseable = false;
         try {
-          const planPath = path183.join(dir, ".swarm", "plan.json");
+          const planPath = path185.join(dir, ".swarm", "plan.json");
           if (fs113.existsSync(planPath)) {
             const planRaw = fs113.readFileSync(planPath, "utf-8");
             const plan = JSON.parse(planRaw);
@@ -141077,7 +141395,7 @@ async function runDriftGate(ctx) {
 }
 // src/tools/phase-complete/gates/final-council-gate.ts
 import * as fs114 from "node:fs";
-import * as path184 from "node:path";
+import * as path186 from "node:path";
 async function runFinalCouncilGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   let finalCouncilEnabled = false;
@@ -141100,7 +141418,7 @@ async function runFinalCouncilGate(ctx) {
       if (lastPhaseId !== undefined && phase === lastPhaseId) {
         if (preamble.effectiveGates?.final_council === true) {
           finalCouncilEnabled = true;
-          const fcPath = path184.join(dir, ".swarm", "evidence", "final-council.json");
+          const fcPath = path186.join(dir, ".swarm", "evidence", "final-council.json");
           let fcVerdictFound = false;
           let _fcVerdict;
           try {
@@ -141254,13 +141572,13 @@ async function runFinalCouncilGate(ctx) {
 }
 // src/tools/phase-complete/gates/hallucination-gate.ts
 import * as fs115 from "node:fs";
-import * as path185 from "node:path";
+import * as path187 from "node:path";
 async function runHallucinationGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   try {
     const preamble = await resolveGatePreamble(dir, sessionID);
     if (preamble.resolved && preamble.effectiveGates?.hallucination_guard === true) {
-      const hgPath = path185.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
+      const hgPath = path187.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
       let hgVerdictFound = false;
       let hgVerdictApproved = false;
       try {
@@ -141318,13 +141636,13 @@ async function runHallucinationGate(ctx) {
 }
 // src/tools/phase-complete/gates/mutation-gate.ts
 import * as fs116 from "node:fs";
-import * as path186 from "node:path";
+import * as path188 from "node:path";
 async function runMutationGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   try {
     const preamble = await resolveGatePreamble(dir, sessionID);
     if (preamble.resolved && preamble.effectiveGates?.mutation_test === true) {
-      const mgPath = path186.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
+      const mgPath = path188.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
       let mgVerdictFound = false;
       let mgVerdict;
       try {
@@ -141382,7 +141700,7 @@ async function runMutationGate(ctx) {
 }
 // src/tools/phase-complete/gates/phase-council-gate.ts
 import * as fs117 from "node:fs";
-import * as path187 from "node:path";
+import * as path189 from "node:path";
 async function runPhaseCouncilGate(ctx) {
   const { phase, dir, sessionID, pluginConfig, agentsDispatched, safeWarn } = ctx;
   const gateWarnings = [];
@@ -141391,7 +141709,7 @@ async function runPhaseCouncilGate(ctx) {
     const preamble = await resolveGatePreamble(dir, sessionID);
     if (preamble.resolved && preamble.effectiveGates?.phase_council === true && pluginConfig.council?.enabled === true) {
       councilModeEnabled = true;
-      const pcPath = path187.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
+      const pcPath = path189.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
       let pcVerdictFound = false;
       let _pcVerdict;
       let pcQuorumSize;
@@ -141959,7 +142277,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path189.basename(dir);
+      const projectName = path191.basename(dir);
       const curationResult = await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig, {
         llmDelegate: createCuratorLLMDelegate(dir, "phase", sessionID),
         enrichmentQuota: {
@@ -142536,7 +142854,7 @@ init_utils();
 init_bun_compat();
 init_create_tool();
 import * as fs120 from "node:fs";
-import * as path190 from "node:path";
+import * as path192 from "node:path";
 var MAX_OUTPUT_BYTES7 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -142564,16 +142882,16 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs120.existsSync(path190.join(cwd, "package.json"))) {
+  if (fs120.existsSync(path192.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs120.existsSync(path190.join(cwd, "pyproject.toml")) || fs120.existsSync(path190.join(cwd, "requirements.txt"))) {
+  if (fs120.existsSync(path192.join(cwd, "pyproject.toml")) || fs120.existsSync(path192.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs120.existsSync(path190.join(cwd, "Cargo.toml"))) {
+  if (fs120.existsSync(path192.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs120.existsSync(path190.join(cwd, "go.mod"))) {
+  if (fs120.existsSync(path192.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
@@ -142582,13 +142900,13 @@ function detectEcosystems(directory) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs120.existsSync(path190.join(cwd, "Gemfile")) || fs120.existsSync(path190.join(cwd, "Gemfile.lock"))) {
+  if (fs120.existsSync(path192.join(cwd, "Gemfile")) || fs120.existsSync(path192.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs120.existsSync(path190.join(cwd, "pubspec.yaml"))) {
+  if (fs120.existsSync(path192.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
-  if (fs120.existsSync(path190.join(cwd, "composer.lock"))) {
+  if (fs120.existsSync(path192.join(cwd, "composer.lock"))) {
     ecosystems.push("composer");
   }
   return ecosystems;
@@ -143725,7 +144043,7 @@ var pkg_audit = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs121 from "node:fs";
-import * as path191 from "node:path";
+import * as path193 from "node:path";
 init_utils();
 init_create_tool();
 var MAX_FILE_SIZE = 1024 * 1024;
@@ -143848,7 +144166,7 @@ function isScaffoldFile(filePath) {
   if (SCAFFOLD_PATH_PATTERNS.some((pattern) => pattern.test(normalizedPath))) {
     return true;
   }
-  const filename = path191.basename(filePath);
+  const filename = path193.basename(filePath);
   if (SCAFFOLD_FILENAME_PATTERNS.some((pattern) => pattern.test(filename))) {
     return true;
   }
@@ -143865,7 +144183,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
     if (regex.test(normalizedPath)) {
       return true;
     }
-    const filename = path191.basename(filePath);
+    const filename = path193.basename(filePath);
     const filenameRegex = new RegExp(`^${regexPattern}$`, "i");
     if (filenameRegex.test(filename)) {
       return true;
@@ -143874,7 +144192,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
   return false;
 }
 function isParserSupported(filePath) {
-  const ext = path191.extname(filePath).toLowerCase();
+  const ext = path193.extname(filePath).toLowerCase();
   return SUPPORTED_PARSER_EXTENSIONS.has(ext);
 }
 function isPlanFile(filePath) {
@@ -144121,9 +144439,9 @@ async function placeholderScan(input, directory) {
   let filesScanned = 0;
   const filesWithFindings = new Set;
   for (const filePath of changed_files) {
-    const fullPath = path191.isAbsolute(filePath) ? filePath : path191.resolve(directory, filePath);
-    const resolvedDirectory = path191.resolve(directory);
-    if (!fullPath.startsWith(resolvedDirectory + path191.sep) && fullPath !== resolvedDirectory) {
+    const fullPath = path193.isAbsolute(filePath) ? filePath : path193.resolve(directory, filePath);
+    const resolvedDirectory = path193.resolve(directory);
+    if (!fullPath.startsWith(resolvedDirectory + path193.sep) && fullPath !== resolvedDirectory) {
       continue;
     }
     if (!fs121.existsSync(fullPath)) {
@@ -144132,7 +144450,7 @@ async function placeholderScan(input, directory) {
     if (isAllowedByGlobs(filePath, allow_globs)) {
       continue;
     }
-    const relativeFilePath = path191.relative(directory, fullPath).replace(/\\/g, "/");
+    const relativeFilePath = path193.relative(directory, fullPath).replace(/\\/g, "/");
     if (FILE_ALLOWLIST.some((allowed) => relativeFilePath.endsWith(allowed))) {
       continue;
     }
@@ -144205,7 +144523,7 @@ var placeholder_scan = createSwarmTool({
 
 // src/tools/pre-check-batch.ts
 import * as fs125 from "node:fs";
-import * as path195 from "node:path";
+import * as path197 from "node:path";
 init_zod();
 init_manager2();
 init_utils();
@@ -144346,7 +144664,7 @@ init_zod();
 init_manager2();
 init_detector();
 import * as fs124 from "node:fs";
-import * as path194 from "node:path";
+import * as path196 from "node:path";
 import { extname as extname19 } from "node:path";
 
 // src/sast/rules/c.ts
@@ -145056,7 +145374,7 @@ function executeRulesSync(filePath, content, language) {
 // src/sast/semgrep.ts
 import * as child_process15 from "node:child_process";
 import * as fs122 from "node:fs";
-import * as path192 from "node:path";
+import * as path194 from "node:path";
 var semgrepAvailableCache = null;
 var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
 var DEFAULT_TIMEOUT_MS4 = 30000;
@@ -145343,7 +145661,7 @@ async function runSemgrep(options) {
 }
 function getRulesDirectory(projectRoot) {
   if (projectRoot) {
-    return path192.resolve(projectRoot, DEFAULT_RULES_DIR);
+    return path194.resolve(projectRoot, DEFAULT_RULES_DIR);
   }
   return DEFAULT_RULES_DIR;
 }
@@ -145364,24 +145682,24 @@ init_create_tool();
 init_utils2();
 import * as crypto13 from "node:crypto";
 import * as fs123 from "node:fs";
-import * as path193 from "node:path";
+import * as path195 from "node:path";
 var BASELINE_SCHEMA_VERSION = "1.0.0";
 var MAX_BASELINE_FINDINGS = 2000;
 var MAX_BASELINE_BYTES = 2 * 1048576;
 var LOCK_RETRY_DELAYS_MS = [50, 100, 200, 400, 800];
 function normalizeFindingPath(directory, file3) {
-  const resolved = path193.isAbsolute(file3) ? file3 : path193.resolve(directory, file3);
-  const rel = path193.relative(path193.resolve(directory), resolved);
+  const resolved = path195.isAbsolute(file3) ? file3 : path195.resolve(directory, file3);
+  const rel = path195.relative(path195.resolve(directory), resolved);
   return rel.replace(/\\/g, "/");
 }
 function baselineRelPath(phase) {
-  return path193.join("evidence", String(phase), "sast-baseline.json");
+  return path195.join("evidence", String(phase), "sast-baseline.json");
 }
 function tempRelPath(phase) {
-  return path193.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
+  return path195.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
 }
 function lockRelPath(phase) {
-  return path193.join("evidence", String(phase), "sast-baseline.json.lock");
+  return path195.join("evidence", String(phase), "sast-baseline.json.lock");
 }
 function getLine(lines, idx) {
   if (idx < 0 || idx >= lines.length)
@@ -145502,8 +145820,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       message: e instanceof Error ? e.message : "Path validation failed"
     };
   }
-  fs123.mkdirSync(path193.dirname(baselinePath), { recursive: true });
-  fs123.mkdirSync(path193.dirname(tempPath), { recursive: true });
+  fs123.mkdirSync(path195.dirname(baselinePath), { recursive: true });
+  fs123.mkdirSync(path195.dirname(tempPath), { recursive: true });
   const releaseLock = await acquireLock2(lockPath);
   try {
     let existing = null;
@@ -145776,9 +146094,9 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path194.isAbsolute(filePath) ? filePath : path194.resolve(directory, filePath);
-    const resolvedDirectory = path194.resolve(directory);
-    if (!resolvedPath.startsWith(resolvedDirectory + path194.sep) && resolvedPath !== resolvedDirectory) {
+    const resolvedPath = path196.isAbsolute(filePath) ? filePath : path196.resolve(directory, filePath);
+    const resolvedDirectory = path196.resolve(directory);
+    if (!resolvedPath.startsWith(resolvedDirectory + path196.sep) && resolvedPath !== resolvedDirectory) {
       _filesSkipped++;
       continue;
     }
@@ -146093,18 +146411,18 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path195.win32.resolve(inputPath);
-  } else if (path195.isAbsolute(inputPath)) {
-    resolved = path195.resolve(inputPath);
+    resolved = path197.win32.resolve(inputPath);
+  } else if (path197.isAbsolute(inputPath)) {
+    resolved = path197.resolve(inputPath);
   } else {
-    resolved = path195.resolve(baseDir, inputPath);
+    resolved = path197.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path195.resolve(workspaceDir);
+  const workspaceResolved = path197.resolve(workspaceDir);
   let relative38;
   if (isWinAbs) {
-    relative38 = path195.win32.relative(workspaceResolved, resolved);
+    relative38 = path197.win32.relative(workspaceResolved, resolved);
   } else {
-    relative38 = path195.relative(workspaceResolved, resolved);
+    relative38 = path197.relative(workspaceResolved, resolved);
   }
   if (relative38.startsWith("..")) {
     return "path traversal detected";
@@ -146169,7 +146487,7 @@ async function runLintOnFiles(linter, files, workspaceDir) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path195.resolve(file3);
+    const resolvedPath = path197.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -146326,7 +146644,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path195.resolve(file3);
+      const resolvedPath = path197.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -146344,7 +146662,7 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path195.extname(file3).toLowerCase();
+      const ext = path197.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
@@ -146563,7 +146881,7 @@ function classifySastFindings(findings, changedLineRanges, directory) {
   const preexistingFindings = [];
   for (const finding of findings) {
     const filePath = finding.location.file;
-    const normalised = path195.relative(directory, filePath).replace(/\\/g, "/");
+    const normalised = path197.relative(directory, filePath).replace(/\\/g, "/");
     const changedLines = changedLineRanges.get(normalised);
     if (changedLines?.has(finding.location.line)) {
       newFindings.push(finding);
@@ -146614,7 +146932,7 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path195.resolve(directory, file3));
+    changedFiles.push(path197.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -146815,9 +147133,9 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path195.resolve(typedArgs.directory);
-    const workspaceAnchor = path195.resolve(directory);
-    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path195.sep)) {
+    const resolvedDirectory = path197.resolve(typedArgs.directory);
+    const workspaceAnchor = path197.resolve(directory);
+    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path197.sep)) {
       const subDirError = `directory "${typedArgs.directory}" is a subdirectory of the project root — pre_check_batch requires the project root directory "${workspaceAnchor}"`;
       const subDirResult = {
         gates_passed: false,
@@ -146871,7 +147189,7 @@ var pre_check_batch = createSwarmTool({
 init_zod();
 init_path_security();
 init_create_tool();
-import * as path196 from "node:path";
+import * as path198 from "node:path";
 var VALID_ACTIONS = [
   "build",
   "importers",
@@ -146900,7 +147218,7 @@ function validateFile(p) {
     return "file contains control characters";
   if (containsPathTraversal(p))
     return "file contains path traversal";
-  if (path196.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
+  if (path198.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
     return "file must be a workspace-relative path, not absolute";
   }
   return null;
@@ -146923,8 +147241,8 @@ function ok(action, payload) {
 }
 function toRelativeGraphPath(input, workspaceRoot) {
   const normalized = input.replace(/\\/g, "/");
-  if (path196.isAbsolute(normalized)) {
-    const rel = path196.relative(workspaceRoot, normalized).replace(/\\/g, "/");
+  if (path198.isAbsolute(normalized)) {
+    const rel = path198.relative(workspaceRoot, normalized).replace(/\\/g, "/");
     return normalizeGraphPath(rel);
   }
   return normalizeGraphPath(normalized);
@@ -147120,10 +147438,10 @@ var repo_map = createSwarmTool({
         maxTokens: 4000
       });
       const toRel = (p) => {
-        if (!path196.isAbsolute(p))
+        if (!path198.isAbsolute(p))
           return p.replace(/\\/g, "/");
         try {
-          return path196.relative(directory, p).replace(/\\/g, "/");
+          return path198.relative(directory, p).replace(/\\/g, "/");
         } catch {
           return p;
         }
@@ -147173,7 +147491,7 @@ init_zod();
 init_effective_spec();
 init_create_tool();
 import * as fs126 from "node:fs";
-import * as path197 from "node:path";
+import * as path199 from "node:path";
 var EVIDENCE_DIR4 = ".swarm/evidence";
 var OBLIGATION_KEYWORDS2 = ["MUST", "SHOULD", "SHALL"];
 var MAX_FILE_SIZE_BYTES8 = 1024 * 1024;
@@ -147241,7 +147559,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     return [];
   }
   for (const entry of entries) {
-    const entryPath = path197.join(evidenceDir, entry);
+    const entryPath = path199.join(evidenceDir, entry);
     try {
       const stat14 = fs126.statSync(entryPath);
       if (!stat14.isDirectory()) {
@@ -147257,11 +147575,11 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     if (entryPhase !== String(phase)) {
       continue;
     }
-    const evidenceFilePath = path197.join(entryPath, "evidence.json");
+    const evidenceFilePath = path199.join(entryPath, "evidence.json");
     try {
-      const resolvedPath = path197.resolve(evidenceFilePath);
-      const evidenceDirResolved = path197.resolve(evidenceDir);
-      if (!resolvedPath.startsWith(evidenceDirResolved + path197.sep)) {
+      const resolvedPath = path199.resolve(evidenceFilePath);
+      const evidenceDirResolved = path199.resolve(evidenceDir);
+      if (!resolvedPath.startsWith(evidenceDirResolved + path199.sep)) {
         continue;
       }
       const stat14 = fs126.lstatSync(evidenceFilePath);
@@ -147295,7 +147613,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
             if (Array.isArray(diffEntry.files_changed)) {
               for (const file3 of diffEntry.files_changed) {
                 if (typeof file3 === "string") {
-                  touchedFiles.add(path197.resolve(cwd, file3));
+                  touchedFiles.add(path199.resolve(cwd, file3));
                 }
               }
             }
@@ -147308,8 +147626,8 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
 }
 function searchFileForKeywords(filePath, keywords, cwd) {
   try {
-    const resolvedPath = path197.resolve(filePath);
-    const cwdResolved = path197.resolve(cwd);
+    const resolvedPath = path199.resolve(filePath);
+    const cwdResolved = path199.resolve(cwd);
     if (!resolvedPath.startsWith(cwdResolved)) {
       return false;
     }
@@ -147468,7 +147786,7 @@ var req_coverage = createSwarmTool({
         message: "No FR requirements found in spec.md"
       }, null, 2);
     }
-    const evidenceDir = path197.join(cwd, EVIDENCE_DIR4);
+    const evidenceDir = path199.join(cwd, EVIDENCE_DIR4);
     const touchedFiles = readTouchedFiles(evidenceDir, phase, cwd);
     const analyzedRequirements = [];
     let coveredCount = 0;
@@ -147494,7 +147812,7 @@ var req_coverage = createSwarmTool({
       requirements: analyzedRequirements
     };
     const reportFilename = `req-coverage-phase-${phase}.json`;
-    const reportPath = path197.join(evidenceDir, reportFilename);
+    const reportPath = path199.join(evidenceDir, reportFilename);
     try {
       if (!fs126.existsSync(evidenceDir)) {
         fs126.mkdirSync(evidenceDir, { recursive: true });
@@ -147649,7 +147967,7 @@ init_plan_schema();
 init_qa_gate_profile();
 init_file_locks();
 import * as fs127 from "node:fs";
-import * as path198 from "node:path";
+import * as path200 from "node:path";
 init_ledger();
 init_manager();
 init_effective_spec();
@@ -147731,8 +148049,8 @@ async function executeSavePlan(args2, fallbackDir) {
     };
   }
   if (args2.working_directory && fallbackDir) {
-    const resolvedTarget = path198.resolve(args2.working_directory);
-    const resolvedRoot = path198.resolve(fallbackDir);
+    const resolvedTarget = path200.resolve(args2.working_directory);
+    const resolvedRoot = path200.resolve(fallbackDir);
     let fallbackExists = false;
     try {
       fs127.accessSync(resolvedRoot, fs127.constants.F_OK);
@@ -147741,7 +148059,7 @@ async function executeSavePlan(args2, fallbackDir) {
       fallbackExists = false;
     }
     if (fallbackExists) {
-      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path198.sep);
+      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path200.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -147772,7 +148090,7 @@ async function executeSavePlan(args2, fallbackDir) {
     specHash = spec.hash;
   }
   if (process.env.SWARM_SKIP_GATE_SELECTION !== "1") {
-    const contextPath = path198.join(targetWorkspace, ".swarm", "context.md");
+    const contextPath = path200.join(targetWorkspace, ".swarm", "context.md");
     let contextContent = "";
     try {
       contextContent = await fs127.promises.readFile(contextPath, "utf8");
@@ -148062,7 +148380,7 @@ async function executeSavePlan(args2, fallbackDir) {
       }
       await writeCheckpoint(dir).catch(() => {});
       try {
-        const markerPath = path198.join(dir, ".swarm", ".plan-write-marker");
+        const markerPath = path200.join(dir, ".swarm", ".plan-write-marker");
         const marker = JSON.stringify({
           source: "save_plan",
           timestamp: new Date().toISOString(),
@@ -148085,7 +148403,7 @@ async function executeSavePlan(args2, fallbackDir) {
       return {
         success: true,
         message: "Plan saved successfully",
-        plan_path: path198.join(dir, ".swarm", "plan.json"),
+        plan_path: path200.join(dir, ".swarm", "plan.json"),
         phases_count: plan.phases.length,
         tasks_count: tasksCount,
         ...resolvedProfile !== undefined ? { execution_profile: resolvedProfile } : {},
@@ -148153,7 +148471,7 @@ var save_plan = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs128 from "node:fs";
-import * as path199 from "node:path";
+import * as path201 from "node:path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -149003,7 +149321,7 @@ function findManifestFiles(rootDir) {
     try {
       const entries = fs128.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path199.join(dir, entry.name);
+        const fullPath = path201.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -149012,7 +149330,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path199.relative(rootDir, fullPath));
+              manifestFiles.push(path201.relative(rootDir, fullPath));
               break;
             }
           }
@@ -149030,11 +149348,11 @@ function findManifestFilesInDirs(directories, workingDir) {
     try {
       const entries = fs128.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path199.join(dir, entry.name);
+        const fullPath = path201.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path199.relative(workingDir, fullPath));
+              found.push(path201.relative(workingDir, fullPath));
               break;
             }
           }
@@ -149047,11 +149365,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path199.dirname(file3);
+    let currentDir = path201.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path199.sep) {
-        dirs.add(path199.join(workingDir, currentDir));
-        const parent = path199.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path201.sep) {
+        dirs.add(path201.join(workingDir, currentDir));
+        const parent = path201.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -149135,7 +149453,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path199.isAbsolute(relativeOutputDir) ? relativeOutputDir : path199.join(workingDir, relativeOutputDir);
+    const outputDir = path201.isAbsolute(relativeOutputDir) ? relativeOutputDir : path201.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -149158,7 +149476,7 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path199.isAbsolute(manifestFile) ? manifestFile : path199.join(workingDir, manifestFile);
+        const fullPath = path201.isAbsolute(manifestFile) ? manifestFile : path201.join(workingDir, manifestFile);
         if (!fs128.existsSync(fullPath)) {
           continue;
         }
@@ -149175,7 +149493,7 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path199.join(outputDir, filename);
+    const outputPath = path201.join(outputDir, filename);
     fs128.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
@@ -149220,7 +149538,7 @@ var sbom_generate = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs129 from "node:fs";
-import * as path200 from "node:path";
+import * as path202 from "node:path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -149252,12 +149570,12 @@ function normalizePath5(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path200.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path200.sep) ? cwd : cwd + path200.sep;
+    const resolvedPath = path202.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path202.sep) ? cwd : cwd + path202.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path200.extname(resolvedPath).toLowerCase();
+    const ext = path202.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
@@ -149271,7 +149589,7 @@ function discoverSpecFile(cwd, specFileArg) {
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path200.resolve(cwd, candidate);
+    const candidatePath = path202.resolve(cwd, candidate);
     if (fs129.existsSync(candidatePath)) {
       const stats2 = fs129.statSync(candidatePath);
       if (stats2.size <= MAX_SPEC_SIZE) {
@@ -149283,7 +149601,7 @@ function discoverSpecFile(cwd, specFileArg) {
 }
 function parseSpec(specFile) {
   const content = fs129.readFileSync(specFile, "utf-8");
-  const ext = path200.extname(specFile).toLowerCase();
+  const ext = path202.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -149359,7 +149677,7 @@ function extractRoutes2(cwd) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path200.join(dir, entry.name);
+      const fullPath = path202.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -149369,7 +149687,7 @@ function extractRoutes2(cwd) {
         }
         walkDir2(fullPath);
       } else if (entry.isFile()) {
-        const ext = path200.extname(entry.name).toLowerCase();
+        const ext = path202.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -149538,7 +149856,7 @@ init_bun_compat();
 init_path_security();
 init_create_tool();
 import * as fs130 from "node:fs";
-import * as path201 from "node:path";
+import * as path203 from "node:path";
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_LINES = 200;
 var REGEX_TIMEOUT_MS = 5000;
@@ -149574,11 +149892,11 @@ function containsWindowsAttacks4(str) {
 }
 function isPathInWorkspace3(filePath, workspace) {
   try {
-    const resolvedPath = path201.resolve(workspace, filePath);
+    const resolvedPath = path203.resolve(workspace, filePath);
     const realWorkspace = fs130.realpathSync(workspace);
     const realResolvedPath = fs130.realpathSync(resolvedPath);
-    const relativePath = path201.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path201.isAbsolute(relativePath)) {
+    const relativePath = path203.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path203.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -149591,11 +149909,11 @@ function validatePathForRead2(filePath, workspace) {
 }
 function findRgInEnvPath() {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path201.delimiter)) {
+  for (const dir of searchPath.split(path203.delimiter)) {
     if (!dir)
       continue;
     const isWindows = process.platform === "win32";
-    const candidate = path201.join(dir, isWindows ? "rg.exe" : "rg");
+    const candidate = path203.join(dir, isWindows ? "rg.exe" : "rg");
     if (fs130.existsSync(candidate))
       return candidate;
   }
@@ -149725,8 +150043,8 @@ function collectFiles(dir, workspace, includeGlobs, excludeGlobs) {
   try {
     const entries = fs130.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path201.join(dir, entry.name);
-      const relativePath = path201.relative(workspace, fullPath);
+      const fullPath = path203.join(dir, entry.name);
+      const relativePath = path203.relative(workspace, fullPath);
       if (!validatePathForRead2(fullPath, workspace)) {
         continue;
       }
@@ -149767,7 +150085,7 @@ async function fallbackSearch(opts) {
   const matches = [];
   let total = 0;
   for (const file3 of files) {
-    const fullPath = path201.join(opts.workspace, file3);
+    const fullPath = path203.join(opts.workspace, file3);
     if (!validatePathForRead2(fullPath, opts.workspace)) {
       continue;
     }
@@ -150199,7 +150517,7 @@ init_config();
 init_schema();
 init_create_tool();
 import { mkdir as mkdir34, rename as rename14, writeFile as writeFile23 } from "node:fs/promises";
-import * as path202 from "node:path";
+import * as path204 from "node:path";
 var MAX_SPEC_BYTES2 = 256 * 1024;
 var spec_write = createSwarmTool({
   description: "Write the canonical project spec to .swarm/spec.md. Atomic write, size-bounded (256 KiB), heading-required. Honors spec_writer.allow_spec_write.",
@@ -150240,8 +150558,8 @@ var spec_write = createSwarmTool({
         reason: 'spec must contain at least one top-level "# Heading"'
       }, null, 2);
     }
-    const target = path202.join(directory, ".swarm", "spec.md");
-    await mkdir34(path202.dirname(target), { recursive: true });
+    const target = path204.join(directory, ".swarm", "spec.md");
+    await mkdir34(path204.dirname(target), { recursive: true });
     const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
     let finalContent = content;
     if (mode === "append") {
@@ -150266,6 +150584,120 @@ ${content}
   }
 });
 
+// src/tools/stale-reconciliation.ts
+init_zod();
+init_knowledge_store();
+init_skill_generator();
+init_create_tool();
+import { existsSync as existsSync115 } from "node:fs";
+import { readdir as readdir12, readFile as readFile33 } from "node:fs/promises";
+import { join as join163 } from "node:path";
+var run_stale_reconciliation = createSwarmTool({
+  description: "Reconcile skills against the knowledge store. clear=false: mark skills stale when source knowledge is archived or deleted. clear=true: clear stale.marker on affected active skills (proposal files under .swarm/skills/proposals are scanned but not modified — they are drafts, not yet active skills).",
+  args: {
+    clear: exports_external.boolean().optional().default(false).describe("If true, clear stale markers for affected skills. If false (default), mark affected skills stale.")
+  },
+  execute: async (args2, directory) => {
+    if (typeof directory !== "string" || !directory) {
+      return JSON.stringify({ found: 0, skills: [] }, null, 2);
+    }
+    const archivedIds = await _internals116.getArchivedKnowledgeIds(directory);
+    const archivedSet = new Set(archivedIds);
+    const allKnownIds = new Set;
+    const swarmPath = _internals116.resolveSwarmKnowledgePath(directory);
+    const hivePath = _internals116.resolveHiveKnowledgePath();
+    try {
+      const swarmEntries = await _internals116.readKnowledge(swarmPath);
+      for (const e of swarmEntries)
+        allKnownIds.add(e.id);
+    } catch {}
+    try {
+      const hiveEntries = await _internals116.readKnowledge(hivePath);
+      for (const e of hiveEntries)
+        allKnownIds.add(e.id);
+    } catch {}
+    const skillEntries = [];
+    for (const dir of [
+      join163(directory, ".opencode", "skills", "generated"),
+      join163(directory, ".swarm", "skills", "proposals")
+    ]) {
+      if (!_internals116.existsSync(dir))
+        continue;
+      const entries = await _internals116.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          skillEntries.push({
+            slug: entry.name,
+            path: join163(dir, entry.name),
+            isProposal: false
+          });
+        } else if (entry.name.endsWith(".md")) {
+          const slug = entry.name.replace(/\.md$/, "");
+          skillEntries.push({
+            slug,
+            path: join163(dir, entry.name),
+            isProposal: true
+          });
+        }
+      }
+    }
+    const results = [];
+    for (const { slug, path: path205, isProposal } of skillEntries) {
+      const skillMdPath = isProposal ? path205 : join163(path205, "SKILL.md");
+      if (!_internals116.existsSync(skillMdPath))
+        continue;
+      const content = await _internals116.readFile(skillMdPath, "utf-8");
+      const fm = _internals116.parseDraftFrontmatter(content);
+      const sourceIds = fm?.sourceKnowledgeIds ?? [];
+      if (sourceIds.length === 0)
+        continue;
+      const affected = sourceIds.filter((id) => archivedSet.has(id) || !allKnownIds.has(id));
+      if (affected.length === 0)
+        continue;
+      if (args2.clear) {
+        if (!isProposal) {
+          const markerPath = join163(path205, "stale.marker");
+          if (_internals116.existsSync(markerPath)) {
+            try {
+              await _internals116.clearSkillStale(path205);
+              results.push({
+                slug,
+                reason: affected.join(", "),
+                action: "cleared"
+              });
+            } catch {}
+          }
+        }
+      } else {
+        if (!isProposal) {
+          try {
+            await _internals116.retireOrMarkStale(directory, path205, archivedSet);
+            results.push({
+              slug,
+              reason: affected.join(", "),
+              action: "marked_stale"
+            });
+          } catch {}
+        }
+      }
+    }
+    return JSON.stringify({ found: results.length, skills: results }, null, 2);
+  }
+});
+var _internals116 = {
+  run_stale_reconciliation,
+  clearSkillStale,
+  retireOrMarkStale,
+  parseDraftFrontmatter,
+  getArchivedKnowledgeIds,
+  readKnowledge,
+  resolveSwarmKnowledgePath,
+  resolveHiveKnowledgePath,
+  readdir: readdir12,
+  readFile: readFile33,
+  existsSync: existsSync115
+};
+
 // src/tools/submit-phase-council-verdicts.ts
 init_zod();
 init_loader();
@@ -150277,7 +150709,7 @@ import {
   unlinkSync as unlinkSync29,
   writeFileSync as writeFileSync36
 } from "node:fs";
-import path203 from "node:path";
+import path205 from "node:path";
 init_create_tool();
 init_resolve_working_directory();
 var VerdictSchema2 = exports_external.object({
@@ -150444,7 +150876,7 @@ var submit_phase_council_verdicts = createSwarmTool({
   }
 });
 function getPhaseMutationGapFinding(phaseNumber, workingDir) {
-  const mutationGatePath = path203.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
+  const mutationGatePath = path205.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
   try {
     const raw = readFileSync90(mutationGatePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -150506,9 +150938,9 @@ function getPhaseMutationGapFinding(phaseNumber, workingDir) {
   }
 }
 function writePhaseCouncilEvidence(workingDir, synthesis, provenance) {
-  const evidenceDir = path203.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
+  const evidenceDir = path205.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
   mkdirSync51(evidenceDir, { recursive: true });
-  const evidenceFile = path203.join(evidenceDir, "phase-council.json");
+  const evidenceFile = path205.join(evidenceDir, "phase-council.json");
   const evidenceBundle = {
     entries: [
       {
@@ -150571,7 +151003,7 @@ init_zod();
 init_path_security();
 init_create_tool();
 import * as fs131 from "node:fs";
-import * as path204 from "node:path";
+import * as path206 from "node:path";
 var BINARY_EXTENSIONS2 = new Set([
   ".png",
   ".jpg",
@@ -150607,14 +151039,14 @@ function containsWindowsAttacks5(str) {
 }
 function isPathInWorkspace4(filePath, workspace) {
   try {
-    const resolvedPath = path204.resolve(workspace, filePath);
+    const resolvedPath = path206.resolve(workspace, filePath);
     if (!fs131.existsSync(resolvedPath)) {
       return true;
     }
     const realWorkspace = fs131.realpathSync(workspace);
     const realResolvedPath = fs131.realpathSync(resolvedPath);
-    const relativePath = path204.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path204.isAbsolute(relativePath)) {
+    const relativePath = path206.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path206.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -150729,7 +151161,7 @@ function arraysEqual2(a, b) {
   return true;
 }
 function isBinaryFile4(filePath) {
-  const ext = path204.extname(filePath).toLowerCase();
+  const ext = path206.extname(filePath).toLowerCase();
   return BINARY_EXTENSIONS2.has(ext);
 }
 function splitDiffLines(content) {
@@ -150934,7 +151366,7 @@ var suggestPatch = createSwarmTool({
         });
         continue;
       }
-      const fullPath = path204.resolve(directory, change.file);
+      const fullPath = path206.resolve(directory, change.file);
       if (!fs131.existsSync(fullPath)) {
         errors5.push({
           success: false,
@@ -151029,7 +151461,7 @@ var suggestPatch = createSwarmTool({
         const unifiedParts = [];
         for (const [file3, entries] of fileGroups) {
           entries.sort((a, b) => a.contextMatch.startLineIndex - b.contextMatch.startLineIndex);
-          const entryFullPath = path204.resolve(directory, file3);
+          const entryFullPath = path206.resolve(directory, file3);
           let entryContent;
           try {
             entryContent = fs131.readFileSync(entryFullPath, "utf-8");
@@ -151230,7 +151662,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 } = _internals116.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals117.loadPluginConfigWithMeta(directory);
     if (config3.memory?.enabled !== true) {
       return JSON.stringify({
         success: false,
@@ -151246,7 +151678,7 @@ var swarm_memory_propose = createSwarmTool({
       });
     }
     const agent = getContextAgent3(ctx);
-    const gateway = _internals116.createMemoryGateway({
+    const gateway = _internals117.createMemoryGateway({
       directory,
       sessionID: ctx?.sessionID,
       agentRole: agent,
@@ -151271,7 +151703,7 @@ var swarm_memory_propose = createSwarmTool({
     }
   }
 });
-var _internals116 = {
+var _internals117 = {
   loadPluginConfigWithMeta,
   createMemoryGateway
 };
@@ -151309,7 +151741,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 } = _internals117.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals118.loadPluginConfigWithMeta(directory);
     if (config3.memory?.enabled !== true) {
       return JSON.stringify({
         success: false,
@@ -151325,7 +151757,7 @@ var swarm_memory_recall = createSwarmTool({
       });
     }
     const agent = getContextAgent4(ctx);
-    const gateway = _internals117.createMemoryGateway({
+    const gateway = _internals118.createMemoryGateway({
       directory,
       sessionID: ctx?.sessionID,
       agentRole: agent,
@@ -151358,7 +151790,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 _internals117 = {
+var _internals118 = {
   loadPluginConfigWithMeta,
   createMemoryGateway
 };
@@ -151371,7 +151803,7 @@ function getContextAgent4(ctx) {
 
 // src/tools/syntax-check.ts
 import * as fs132 from "node:fs";
-import * as path205 from "node:path";
+import * as path207 from "node:path";
 init_zod();
 init_manager2();
 init_detector();
@@ -151443,7 +151875,7 @@ async function syntaxCheck(input, directory, config3) {
   if (languages?.length) {
     const lowerLangs = languages.map((l) => l.toLowerCase());
     filesToCheck = filesToCheck.filter((file3) => {
-      const ext = path205.extname(file3.path).toLowerCase();
+      const ext = path207.extname(file3.path).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       const fileProfile = getProfileForFile(file3.path);
       const langId = fileProfile?.id || langDef?.id;
@@ -151453,7 +151885,7 @@ async function syntaxCheck(input, directory, config3) {
   const { loadGrammar: loadGrammar2 } = await Promise.resolve().then(() => (init_runtime(), exports_runtime));
   async function checkOneFile(fileInfo) {
     const { path: filePath } = fileInfo;
-    const fullPath = path205.isAbsolute(filePath) ? filePath : path205.join(directory, filePath);
+    const fullPath = path207.isAbsolute(filePath) ? filePath : path207.join(directory, filePath);
     const result = {
       path: filePath,
       language: "",
@@ -151500,7 +151932,7 @@ async function syntaxCheck(input, directory, config3) {
         result.skipped_reason = "binary_file";
         return { result, counted: false, failed: false, skipped: true };
       }
-      const ext = path205.extname(filePath).toLowerCase();
+      const ext = path207.extname(filePath).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       result.language = profile?.id || langDef?.id || "unknown";
       const errors5 = extractSyntaxErrors(parser, content);
@@ -151612,7 +152044,7 @@ init_utils();
 init_create_tool();
 init_path_security();
 import * as fs133 from "node:fs";
-import * as path206 from "node:path";
+import * as path208 from "node:path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES10 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS4 = new Set([
@@ -151678,9 +152110,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path206.resolve(paths);
-    const normalizedCwd = path206.resolve(cwd);
-    const normalizedResolved = path206.resolve(resolvedPath);
+    const resolvedPath = path208.resolve(paths);
+    const normalizedCwd = path208.resolve(cwd);
+    const normalizedResolved = path208.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -151696,7 +152128,7 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path206.extname(filePath).toLowerCase();
+  const ext = path208.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS4.has(ext);
 }
 function findSourceFiles3(dir, files = []) {
@@ -151711,7 +152143,7 @@ function findSourceFiles3(dir, files = []) {
     if (SKIP_DIRECTORIES6.has(entry)) {
       continue;
     }
-    const fullPath = path206.join(dir, entry);
+    const fullPath = path208.join(dir, entry);
     let stat14;
     try {
       stat14 = fs133.statSync(fullPath);
@@ -151823,7 +152255,7 @@ var todo_extract = createSwarmTool({
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path206.extname(scanPath)}`,
+          error: `unsupported file extension: ${path208.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -151873,18 +152305,18 @@ init_schema();
 init_qa_gate_profile();
 init_gate_evidence();
 import * as fs137 from "node:fs";
-import * as path210 from "node:path";
+import * as path212 from "node:path";
 
 // src/hooks/diff-scope.ts
 init_bun_compat();
 import * as fs135 from "node:fs";
-import * as path208 from "node:path";
+import * as path210 from "node:path";
 
 // src/utils/gitignore-warning.ts
 init_bun_compat();
 import * as fs134 from "node:fs";
-import * as path207 from "node:path";
-var _internals118 = { bunSpawn };
+import * as path209 from "node:path";
+var _internals119 = { bunSpawn };
 var _swarmGitExcludedChecked = false;
 function fileCoversSwarm(content) {
   for (const rawLine of content.split(`
@@ -151917,7 +152349,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
       checkIgnoreExitCode
     ] = await Promise.all([
       (async () => {
-        const proc = _internals118.bunSpawn(["git", "-C", directory, "rev-parse", "--show-toplevel"], GIT_SPAWN_OPTIONS);
+        const proc = _internals119.bunSpawn(["git", "-C", directory, "rev-parse", "--show-toplevel"], GIT_SPAWN_OPTIONS);
         try {
           return await Promise.all([proc.exited, proc.stdout.text()]);
         } finally {
@@ -151927,7 +152359,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       })(),
       (async () => {
-        const proc = _internals118.bunSpawn(["git", "-C", directory, "rev-parse", "--git-path", "info/exclude"], GIT_SPAWN_OPTIONS);
+        const proc = _internals119.bunSpawn(["git", "-C", directory, "rev-parse", "--git-path", "info/exclude"], GIT_SPAWN_OPTIONS);
         try {
           return await Promise.all([proc.exited, proc.stdout.text()]);
         } finally {
@@ -151937,7 +152369,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       })(),
       (async () => {
-        const proc = _internals118.bunSpawn(["git", "-C", directory, "check-ignore", "-q", ".swarm/.gitkeep"], GIT_SPAWN_OPTIONS);
+        const proc = _internals119.bunSpawn(["git", "-C", directory, "check-ignore", "-q", ".swarm/.gitkeep"], GIT_SPAWN_OPTIONS);
         try {
           return await proc.exited;
         } finally {
@@ -151957,10 +152389,10 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
     const excludeRelPath = excludePathRaw.trim();
     if (!excludeRelPath)
       return;
-    const excludePath = path207.isAbsolute(excludeRelPath) ? excludeRelPath : path207.join(directory, excludeRelPath);
+    const excludePath = path209.isAbsolute(excludeRelPath) ? excludeRelPath : path209.join(directory, excludeRelPath);
     if (checkIgnoreExitCode !== 0) {
       try {
-        fs134.mkdirSync(path207.dirname(excludePath), { recursive: true });
+        fs134.mkdirSync(path209.dirname(excludePath), { recursive: true });
         let existing = "";
         try {
           existing = fs134.readFileSync(excludePath, "utf8");
@@ -151976,7 +152408,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       } catch {}
     }
-    const trackedProc = _internals118.bunSpawn(["git", "-C", directory, "ls-files", "--", ".swarm"], GIT_SPAWN_OPTIONS);
+    const trackedProc = _internals119.bunSpawn(["git", "-C", directory, "ls-files", "--", ".swarm"], GIT_SPAWN_OPTIONS);
     let trackedExitCode;
     let trackedOutput;
     try {
@@ -152001,10 +152433,10 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
 }
 
 // src/hooks/diff-scope.ts
-var _internals119 = { bunSpawn };
+var _internals120 = { bunSpawn };
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path208.join(directory, ".swarm", "plan.json");
+    const planPath = path210.join(directory, ".swarm", "plan.json");
     if (!fs135.existsSync(planPath))
       return null;
     const raw = fs135.readFileSync(planPath, "utf-8");
@@ -152036,7 +152468,7 @@ var GIT_DIFF_SPAWN_OPTIONS = {
 };
 async function getChangedFiles2(directory) {
   try {
-    const proc = _internals119.bunSpawn(["git", "diff", "--name-only", "HEAD~1"], {
+    const proc = _internals120.bunSpawn(["git", "diff", "--name-only", "HEAD~1"], {
       cwd: directory,
       ...GIT_DIFF_SPAWN_OPTIONS
     });
@@ -152053,7 +152485,7 @@ async function getChangedFiles2(directory) {
       return stdout.trim().split(`
 `).map((f) => f.trim()).filter((f) => f.length > 0);
     }
-    const proc2 = _internals119.bunSpawn(["git", "diff", "--name-only", "HEAD"], {
+    const proc2 = _internals120.bunSpawn(["git", "diff", "--name-only", "HEAD"], {
       cwd: directory,
       ...GIT_DIFF_SPAWN_OPTIONS
     });
@@ -152110,8 +152542,8 @@ init_telemetry();
 // src/turbo/lean/task-completion.ts
 init_file_locks();
 import * as fs136 from "node:fs";
-import * as path209 from "node:path";
-var _internals120 = {
+import * as path211 from "node:path";
+var _internals121 = {
   listActiveLocks,
   verifyLeanTurboTaskCompletion
 };
@@ -152129,7 +152561,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path209.basename(file3);
+    const fileName = path211.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -152141,7 +152573,7 @@ function matchesTier3Pattern(files) {
 function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   let persisted = null;
   try {
-    const statePath = path209.join(directory, ".swarm", "turbo-state.json");
+    const statePath = path211.join(directory, ".swarm", "turbo-state.json");
     if (!fs136.existsSync(statePath)) {
       return {
         ok: false,
@@ -152225,11 +152657,11 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
     };
   }
   const phase = runState.phase ?? 0;
-  const evidencePath = path209.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
-  const expectedDir = path209.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
-  const resolvedPath = path209.resolve(evidencePath);
-  const resolvedDir = path209.resolve(expectedDir);
-  if (!resolvedPath.startsWith(resolvedDir + path209.sep) && resolvedPath !== resolvedDir) {
+  const evidencePath = path211.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
+  const expectedDir = path211.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const resolvedPath = path211.resolve(evidencePath);
+  const resolvedDir = path211.resolve(expectedDir);
+  if (!resolvedPath.startsWith(resolvedDir + path211.sep) && resolvedPath !== resolvedDir) {
     return {
       ok: false,
       reason: `Lane ID causes path traversal: ${lane.laneId}`,
@@ -152253,7 +152685,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
       }
     };
   }
-  const activeLocks = _internals120.listActiveLocks(directory);
+  const activeLocks = _internals121.listActiveLocks(directory);
   const laneLocks = activeLocks.filter((lock) => lock.laneId === lane.laneId);
   if (laneLocks.length > 0) {
     return {
@@ -152269,7 +152701,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   }
   let filesTouched = [];
   try {
-    const planPath = path209.join(directory, ".swarm", "plan.json");
+    const planPath = path211.join(directory, ".swarm", "plan.json");
     const planRaw = fs136.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(planRaw);
     for (const planPhase of plan.phases ?? []) {
@@ -152320,7 +152752,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
 init_task_id();
 init_create_tool();
 init_resolve_working_directory();
-var _internals121 = {
+var _internals122 = {
   tryAcquireLock,
   updateTaskStatus,
   resolveWorkingDirectory
@@ -152358,7 +152790,7 @@ var TIER_3_PATTERNS2 = [
 ];
 function matchesTier3Pattern2(files) {
   for (const file3 of files) {
-    const fileName = path210.basename(file3);
+    const fileName = path212.basename(file3);
     for (const pattern of TIER_3_PATTERNS2) {
       if (pattern.test(fileName)) {
         return true;
@@ -152397,7 +152829,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     if (!skipStandardTurboBypass && hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path210.join(resolvedDir2, ".swarm", "plan.json");
+        const planPath = path212.join(resolvedDir2, ".swarm", "plan.json");
         const planRaw = fs137.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -152417,7 +152849,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     let resolvedDir;
     if (fallbackDir) {
-      const resolveResult = _internals121.resolveWorkingDirectory(workingDirectory, fallbackDir);
+      const resolveResult = _internals122.resolveWorkingDirectory(workingDirectory, fallbackDir);
       if (resolveResult.success) {
         resolvedDir = resolveResult.directory;
       } else {
@@ -152475,7 +152907,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     if (resolvedDir) {
       try {
-        const planPath = path210.join(resolvedDir, ".swarm", "plan.json");
+        const planPath = path212.join(resolvedDir, ".swarm", "plan.json");
         const planRaw = fs137.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -152686,7 +153118,7 @@ function checkCouncilGate(workingDirectory, taskId) {
     return { blocked: false, reason: "", active: false };
   }
   try {
-    const planPath = path210.join(workingDirectory, ".swarm", "plan.json");
+    const planPath = path212.join(workingDirectory, ".swarm", "plan.json");
     const planRaw = fs137.readFileSync(planPath, "utf-8");
     const planObj = JSON.parse(planRaw);
     if (planObj.swarm && planObj.title) {
@@ -152764,7 +153196,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     }
   }
   let directory;
-  const resolveResult = _internals121.resolveWorkingDirectory(args2.working_directory, fallbackDir);
+  const resolveResult = _internals122.resolveWorkingDirectory(args2.working_directory, fallbackDir);
   if (!resolveResult.success) {
     return {
       success: false,
@@ -152773,7 +153205,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   directory = resolveResult.directory;
-  const planPath = path210.join(directory, ".swarm", "plan.json");
+  const planPath = path212.join(directory, ".swarm", "plan.json");
   if (!fs137.existsSync(planPath)) {
     return {
       success: false,
@@ -152782,9 +153214,9 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   if (fallbackDir && directory !== fallbackDir) {
-    const canonicalDir = fs137.realpathSync(path210.resolve(directory));
-    const canonicalRoot = fs137.realpathSync(path210.resolve(fallbackDir));
-    if (canonicalDir.startsWith(canonicalRoot + path210.sep)) {
+    const canonicalDir = fs137.realpathSync(path212.resolve(directory));
+    const canonicalRoot = fs137.realpathSync(path212.resolve(fallbackDir));
+    if (canonicalDir.startsWith(canonicalRoot + path212.sep)) {
       return {
         success: false,
         message: `Invalid working_directory: "${directory}" is a subdirectory of ` + `the project root "${fallbackDir}". Pass the project root path or ` + `omit working_directory entirely.`,
@@ -152796,8 +153228,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
   }
   if (args2.status === "in_progress") {
     try {
-      const evidencePath = path210.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
-      fs137.mkdirSync(path210.dirname(evidencePath), { recursive: true });
+      const evidencePath = path212.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
+      fs137.mkdirSync(path212.dirname(evidencePath), { recursive: true });
       const fd = fs137.openSync(evidencePath, "wx");
       let writeOk = false;
       try {
@@ -152821,7 +153253,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     recoverTaskStateFromDelegations(args2.task_id, directory);
     let phaseRequiresReviewer = true;
     try {
-      const planPath2 = path210.join(directory, ".swarm", "plan.json");
+      const planPath2 = path212.join(directory, ".swarm", "plan.json");
       const planRaw = fs137.readFileSync(planPath2, "utf-8");
       const plan = JSON.parse(planRaw);
       const taskPhase = plan.phases.find((p) => p.tasks.some((t) => t.id === args2.task_id));
@@ -152857,7 +153289,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
   }
   let lockResult;
   try {
-    lockResult = await _internals121.tryAcquireLock(directory, planFilePath, agentName, lockTaskId);
+    lockResult = await _internals122.tryAcquireLock(directory, planFilePath, agentName, lockTaskId);
   } catch (error93) {
     return {
       success: false,
@@ -152876,7 +153308,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   try {
-    const updatedPlan = await _internals121.updateTaskStatus(directory, args2.task_id, args2.status);
+    const updatedPlan = await _internals122.updateTaskStatus(directory, args2.task_id, args2.status);
     if (args2.status === "completed") {
       for (const [_sessionId, session] of swarmState.agentSessions) {
         if (!(session.taskWorkflowStates instanceof Map)) {
@@ -152940,7 +153372,7 @@ init_utils2();
 init_redaction();
 import { createHash as createHash26 } from "node:crypto";
 import { appendFile as appendFile18, mkdir as mkdir35 } from "node:fs/promises";
-import * as path211 from "node:path";
+import * as path213 from "node:path";
 var EVIDENCE_CACHE_FILE = "evidence-cache/documents.jsonl";
 var MAX_EVIDENCE_TEXT_LENGTH = 4000;
 async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
@@ -152948,7 +153380,7 @@ async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
   const capturedAt = now().toISOString();
   const records = inputs.map((input) => createEvidenceDocumentRecord(input, capturedAt)).filter((record3) => record3 !== null);
   if (records.length > 0) {
-    await mkdir35(path211.dirname(filePath), { recursive: true });
+    await mkdir35(path213.dirname(filePath), { recursive: true });
     await appendFile18(filePath, `${records.map((record3) => JSON.stringify(record3)).join(`
 `)}
 `, "utf-8");
@@ -153531,7 +153963,7 @@ var web_fetch = createSwarmTool({
       };
       return JSON.stringify(fail, null, 2);
     }
-    const config3 = _internals122.loadPluginConfig(dirResult.directory);
+    const config3 = _internals123.loadPluginConfig(dirResult.directory);
     const generalConfig = config3.council?.general;
     if (!generalConfig || generalConfig.enabled !== true) {
       const fail = {
@@ -153541,7 +153973,7 @@ var web_fetch = createSwarmTool({
       };
       return JSON.stringify(fail, null, 2);
     }
-    const validated = await validateFetchUrl(parsed.data.url, _internals122.dnsLookup);
+    const validated = await validateFetchUrl(parsed.data.url, _internals123.dnsLookup);
     if (!validated.ok) {
       const fail = {
         success: false,
@@ -153552,7 +153984,7 @@ var web_fetch = createSwarmTool({
     }
     const maxBytes = parsed.data.max_bytes ?? DEFAULT_MAX_BYTES;
     const timeoutMs = parsed.data.timeout_ms ?? DEFAULT_TIMEOUT_MS5;
-    const result = await boundedFetch({ url: validated.url, address: validated.address }, maxBytes, timeoutMs, _internals122);
+    const result = await boundedFetch({ url: validated.url, address: validated.address }, maxBytes, timeoutMs, _internals123);
     if (!result.ok) {
       const fail = {
         success: false,
@@ -153587,7 +154019,7 @@ var web_fetch = createSwarmTool({
 });
 async function captureFetchEvidence(directory, url3, title, text) {
   try {
-    const written = await _internals122.writeEvidenceDocuments(directory, [
+    const written = await _internals123.writeEvidenceDocuments(directory, [
       {
         sourceType: "crawl",
         url: url3,
@@ -153608,7 +154040,7 @@ async function captureFetchEvidence(directory, url3, title, text) {
     };
   }
 }
-var _internals122 = {
+var _internals123 = {
   httpRequest: performHttpRequest,
   dnsLookup: lookup,
   loadPluginConfig,
@@ -153922,7 +154354,7 @@ var web_search = createSwarmTool({
 });
 async function captureSearchEvidence(directory, query, results) {
   try {
-    const written = await _internals123.writeEvidenceDocuments(directory, results.map((result) => ({
+    const written = await _internals124.writeEvidenceDocuments(directory, results.map((result) => ({
       sourceType: "web_search",
       query,
       title: result.title,
@@ -153950,7 +154382,7 @@ async function captureSearchEvidence(directory, query, results) {
     };
   }
 }
-var _internals123 = {
+var _internals124 = {
   writeEvidenceDocuments
 };
 
@@ -153965,7 +154397,7 @@ init_schema3();
 init_store();
 init_create_tool();
 init_resolve_working_directory();
-import * as path212 from "node:path";
+import * as path214 from "node:path";
 var FindingSchema2 = exports_external.object({
   severity: exports_external.enum(["low", "medium", "high", "critical"]),
   category: exports_external.string().min(1),
@@ -154041,7 +154473,7 @@ 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 result = await curateAndStoreSwarm(lessons, path212.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, {
+        const result = await curateAndStoreSwarm(lessons, path214.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, {
           skipAutoPromotion: true,
           llmDelegate: createCuratorLLMDelegate(dirResult.directory, "phase"),
           enrichmentQuota: {
@@ -154088,7 +154520,7 @@ init_ledger();
 init_manager();
 init_create_tool();
 import fs138 from "node:fs";
-import path213 from "node:path";
+import path215 from "node:path";
 function normalizeVerdict(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -154142,7 +154574,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "drift-verifier.json";
-  const relativePath = path213.join("evidence", String(phase), filename);
+  const relativePath = path215.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -154153,10 +154585,10 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path213.dirname(validatedPath);
+  const evidenceDir = path215.dirname(validatedPath);
   try {
     await fs138.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path213.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path215.join(evidenceDir, `.${filename}.tmp`);
     await fs138.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs138.promises.rename(tempPath, validatedPath);
     let snapshotInfo;
@@ -154257,7 +154689,7 @@ var write_drift_evidence = createSwarmTool({
 init_zod();
 init_loader();
 import fs139 from "node:fs";
-import path214 from "node:path";
+import path216 from "node:path";
 init_utils2();
 init_manager();
 init_create_tool();
@@ -154371,7 +154803,7 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
     timestamp: synthesis.timestamp
   };
   const filename = "final-council.json";
-  const relativePath = path214.join("evidence", filename);
+  const relativePath = path216.join("evidence", filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -154385,10 +154817,10 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
   const evidenceContent = {
     entries: [evidenceEntry]
   };
-  const evidenceDir = path214.dirname(validatedPath);
+  const evidenceDir = path216.dirname(validatedPath);
   try {
     await fs139.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path214.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path216.join(evidenceDir, `.${filename}.tmp`);
     await fs139.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs139.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -154448,7 +154880,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs140 from "node:fs";
-import path215 from "node:path";
+import path217 from "node:path";
 function normalizeVerdict2(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -154496,7 +154928,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "hallucination-guard.json";
-  const relativePath = path215.join("evidence", String(phase), filename);
+  const relativePath = path217.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -154507,10 +154939,10 @@ async function executeWriteHallucinationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path215.dirname(validatedPath);
+  const evidenceDir = path217.dirname(validatedPath);
   try {
     await fs140.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path215.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path217.join(evidenceDir, `.${filename}.tmp`);
     await fs140.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs140.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -154560,7 +154992,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs141 from "node:fs";
-import path216 from "node:path";
+import path218 from "node:path";
 function normalizeVerdict3(verdict) {
   switch (verdict) {
     case "PASS":
@@ -154634,7 +155066,7 @@ async function executeWriteMutationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "mutation-gate.json";
-  const relativePath = path216.join("evidence", String(phase), filename);
+  const relativePath = path218.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -154645,10 +155077,10 @@ async function executeWriteMutationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path216.dirname(validatedPath);
+  const evidenceDir = path218.dirname(validatedPath);
   try {
     await fs141.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path216.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path218.join(evidenceDir, `.${filename}.tmp`);
     await fs141.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs141.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -154771,6 +155203,7 @@ var TOOL_MANIFEST = defineHandlers({
   skill_list: () => skill_list,
   skill_apply: () => skill_apply,
   skill_inspect: () => skill_inspect,
+  run_stale_reconciliation: () => run_stale_reconciliation,
   skill_regenerate: () => skill_regenerate,
   skill_retire: () => skill_retire,
   skill_improve: () => skill_improve,
@@ -154863,7 +155296,7 @@ ${footerLines.join(`
 init_warning_buffer();
 var _heartbeatTimers = new Map;
 var SWARM_COMMAND_SYSTEM_RULE_TAG = "[opencode-swarm:swarm-command-rule]";
-var PACKAGE_ROOT2 = path218.resolve(path218.dirname(fileURLToPath5(import.meta.url)), "..");
+var PACKAGE_ROOT2 = path220.resolve(path220.dirname(fileURLToPath5(import.meta.url)), "..");
 var SYNC_BUNDLED_SKILLS_TIMEOUT_MS = 2000;
 function createSwarmCommandSystemRuleHook(agentDefinitions, registeredAgents) {
   return async (input, output) => {
@@ -155185,7 +155618,7 @@ async function initializeOpenCodeSwarm(ctx) {
     const { PreflightTriggerManager: PTM } = await Promise.resolve().then(() => (init_trigger(), exports_trigger));
     preflightTriggerManager = new PTM(automationConfig);
     const { AutomationStatusArtifact: ASA } = await Promise.resolve().then(() => (init_status_artifact(), exports_status_artifact));
-    const swarmDir = path218.resolve(ctx.directory, ".swarm");
+    const swarmDir = path220.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -155857,7 +156290,7 @@ ${promptRaw}`;
                   const meta3 = readSkillMetadata(s.skillPath, ctx.directory);
                   let desc = meta3.description || "";
                   if (!desc || desc === "No description provided") {
-                    desc = path218.basename(path218.dirname(s.skillPath));
+                    desc = path220.basename(path220.dirname(s.skillPath));
                   }
                   desc = desc.replace(/,/g, ";");
                   return `file:${s.skillPath} (-- ${desc})`;
@@ -155867,7 +156300,7 @@ ${promptRaw}`;
 
 ${promptRaw}`;
                 argsRecord.prompt = newPrompt;
-                const skillNames = topSkills.map((s) => `${path218.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
+                const skillNames = topSkills.map((s) => `${path220.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
                 console.warn(`[skill-propagation-gate] Injected skills: ${skillNames}`);
                 for (const skill of topSkills) {
                   try {