opencode-swarm 7.30.0 → 7.31.0

package/dist/index.js

@@ -48,7 +48,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.30.0",
+    version: "7.31.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",
@@ -54966,6 +54966,9 @@ function resolveSwarmKnowledgePath(directory) {
 function resolveSwarmRejectedPath(directory) {
   return path16.join(directory, ".swarm", "knowledge-rejected.jsonl");
 }
+function resolveSwarmRetractionsPath(directory) {
+  return path16.join(directory, ".swarm", "knowledge-retractions.jsonl");
+}
 function resolveHiveKnowledgePath() {
   const platform = process.platform;
   const home = process.env.HOME || os3.homedir();
@@ -55064,6 +55067,12 @@ function normalizeEntry(raw) {
 async function readRejectedLessons(directory) {
   return readKnowledge(resolveSwarmRejectedPath(directory));
 }
+async function readRetractionRecords(directory) {
+  return readKnowledge(resolveSwarmRetractionsPath(directory));
+}
+async function appendRetractionRecord(directory, record3) {
+  await appendKnowledge(resolveSwarmRetractionsPath(directory), record3);
+}
 async function appendKnowledge(filePath, entry) {
   await mkdir3(path16.dirname(filePath), { recursive: true });
   await appendFile3(filePath, `${JSON.stringify(entry)}
@@ -57221,337 +57230,6 @@ var init_hive_promoter = __esm(() => {
   init_utils2();
 });
 
-// src/hooks/knowledge-reader.ts
-import { existsSync as existsSync12 } from "node:fs";
-import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile6 } from "node:fs/promises";
-import * as path21 from "node:path";
-function inferCategoriesFromPhase(phaseDescription) {
-  const lower = phaseDescription.toLowerCase();
-  const patterns = [
-    {
-      pattern: /\b(?:test|qa|quality|verification|validation)\b/,
-      categories: ["testing", "debugging"]
-    },
-    {
-      pattern: /\b(?:implement|build|develop|coding|code)\b/,
-      categories: ["tooling", "architecture", "debugging"]
-    },
-    {
-      pattern: /\b(?:integrat|deploy|ci|cd|release|publish)\b/,
-      categories: ["integration", "tooling", "performance"]
-    },
-    {
-      pattern: /\b(?:plan|design|architect|spec|requirement)\b/,
-      categories: ["architecture", "process"]
-    },
-    {
-      pattern: /\b(?:review|refactor|cleanup|polish|optimi)\b/,
-      categories: ["performance", "architecture", "process"]
-    },
-    {
-      pattern: /\b(?:secur|audit|harden|compliance)\b/,
-      categories: ["security", "testing"]
-    },
-    {
-      pattern: /\b(?:setup|config|scaffold|init|bootstrap)\b/,
-      categories: ["tooling", "other"]
-    },
-    {
-      pattern: /\b(?:doc|readme|changelog)\b/,
-      categories: ["process", "tooling"]
-    }
-  ];
-  for (const { pattern, categories } of patterns) {
-    if (pattern.test(lower)) {
-      return categories;
-    }
-  }
-  return ["process", "tooling"];
-}
-async function recordLessonsShown(directory, lessonIds, currentPhase) {
-  const shownFile = path21.join(directory, ".swarm", ".knowledge-shown.json");
-  try {
-    let shownData = {};
-    if (existsSync12(shownFile)) {
-      const content = await readFile7(shownFile, "utf-8");
-      shownData = JSON.parse(content);
-    }
-    const phaseMatch = /^Phase\s+(\d+)/i.exec(currentPhase);
-    const canonicalKey = phaseMatch ? `Phase ${phaseMatch[1]}` : currentPhase;
-    shownData[canonicalKey] = lessonIds;
-    await mkdir6(path21.dirname(shownFile), { recursive: true });
-    await writeFile6(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
-  } catch {
-    warn("[swarm] Knowledge: failed to record shown lessons");
-  }
-}
-async function readMergedKnowledge(directory, config3, context) {
-  const swarmPath = resolveSwarmKnowledgePath(directory);
-  const swarmEntries = await readKnowledge(swarmPath);
-  let hiveEntries = [];
-  if (config3.hive_enabled !== false) {
-    const hivePath = resolveHiveKnowledgePath();
-    hiveEntries = await readKnowledge(hivePath);
-  }
-  const seenLessons = new Set;
-  const merged = [];
-  for (const entry of hiveEntries) {
-    const normalized = normalize2(entry.lesson);
-    seenLessons.add(normalized);
-    merged.push({
-      ...entry,
-      relevanceScore: { category: 0, confidence: 0, keywords: 0 },
-      finalScore: 0
-    });
-  }
-  for (const entry of swarmEntries) {
-    const normalized = normalize2(entry.lesson);
-    if (seenLessons.has(normalized)) {
-      continue;
-    }
-    const swarmBigrams = wordBigrams(normalized);
-    const isHiveNearDup = hiveEntries.some((hiveEntry) => jaccardBigram(swarmBigrams, wordBigrams(normalize2(hiveEntry.lesson))) >= JACCARD_THRESHOLD);
-    if (isHiveNearDup)
-      continue;
-    const isSwarmNearDup = merged.some((m) => m.tier === "swarm" && jaccardBigram(swarmBigrams, wordBigrams(normalize2(m.lesson))) >= JACCARD_THRESHOLD);
-    if (isSwarmNearDup)
-      continue;
-    seenLessons.add(normalized);
-    merged.push({
-      ...entry,
-      relevanceScore: { category: 0, confidence: 0, keywords: 0 },
-      finalScore: 0
-    });
-  }
-  const scopeFilter = config3.scope_filter ?? ["global"];
-  const filtered = merged.filter((entry) => scopeFilter.some((pattern) => (entry.scope ?? "global") === pattern) && entry.status !== "archived");
-  const ranked = filtered.map((entry) => {
-    let categoryScore = 0;
-    if (context?.currentPhase) {
-      const phaseCategories = inferCategoriesFromPhase(context.currentPhase);
-      if (phaseCategories.includes(entry.category)) {
-        categoryScore = 1;
-      } else if (entry.category === "process") {
-        categoryScore = 0.5;
-      }
-    } else {
-      categoryScore = 0.5;
-    }
-    const confidenceScore = entry.confidence;
-    let keywordsScore = 0;
-    if (context?.techStack && entry.tags.length > 0) {
-      const matchingTags = entry.tags.filter((t) => context.techStack.some((s) => t.toLowerCase().includes(s.toLowerCase()) || s.toLowerCase().includes(t.toLowerCase()))).length;
-      keywordsScore = Math.min(matchingTags / Math.max(entry.tags.length, 1), 1);
-    } else if (entry.tags.length === 0) {
-      keywordsScore = 0.5;
-    }
-    const tierBoost = entry.tier === "hive" ? HIVE_TIER_BOOST : 0;
-    const isSameProjectSource = context?.projectName && entry.tier === "hive" && "source_project" in entry && entry.source_project === context.projectName;
-    const sameProjectPenalty = isSameProjectSource ? SAME_PROJECT_PENALTY : 0;
-    const finalScore = categoryScore * 0.4 + confidenceScore * 0.35 + keywordsScore * 0.25 + tierBoost + sameProjectPenalty;
-    const relevanceScore = {
-      category: categoryScore,
-      confidence: confidenceScore,
-      keywords: keywordsScore
-    };
-    return {
-      ...entry,
-      relevanceScore,
-      finalScore: Math.min(Math.max(finalScore, 0), 1)
-    };
-  });
-  ranked.sort((a, b) => {
-    const scoreDiff = b.finalScore - a.finalScore;
-    if (Math.abs(scoreDiff) > 0.001)
-      return scoreDiff;
-    const dateA = new Date(a.created_at).getTime();
-    const dateB = new Date(b.created_at).getTime();
-    return dateB - dateA;
-  });
-  const maxInject = config3.max_inject_count ?? 5;
-  const topN = ranked.slice(0, maxInject);
-  if (topN.length > 0 && context?.currentPhase) {
-    recordLessonsShown(directory, topN.map((e) => e.id), context.currentPhase).catch((err2) => {
-      warn("[knowledge-reader] recordLessonsShown unexpected rejection:", err2);
-    });
-  }
-  return topN;
-}
-async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
-  const shownFile = path21.join(directory, ".swarm", ".knowledge-shown.json");
-  try {
-    if (!existsSync12(shownFile)) {
-      return;
-    }
-    const content = await readFile7(shownFile, "utf-8");
-    const shownData = JSON.parse(content);
-    const shownIds = shownData[phaseInfo];
-    if (!shownIds || shownIds.length === 0) {
-      return;
-    }
-    const swarmPath = resolveSwarmKnowledgePath(directory);
-    const entries = await readKnowledge(swarmPath);
-    let updated = false;
-    const foundInSwarm = new Set;
-    for (const entry of entries) {
-      if (shownIds.includes(entry.id)) {
-        const ro = entry.retrieval_outcomes;
-        if (phaseSucceeded) {
-          ro.succeeded_after_shown_count = (ro.succeeded_after_shown_count ?? 0) + 1;
-        } else {
-          ro.failed_after_shown_count = (ro.failed_after_shown_count ?? 0) + 1;
-        }
-        updated = true;
-        foundInSwarm.add(entry.id);
-      }
-    }
-    if (updated) {
-      await rewriteKnowledge(swarmPath, entries);
-    }
-    const remainingIds = shownIds.filter((id) => !foundInSwarm.has(id));
-    if (remainingIds.length === 0) {
-      delete shownData[phaseInfo];
-      await writeFile6(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
-      return;
-    }
-    const hivePath = resolveHiveKnowledgePath();
-    const hiveEntries = await readKnowledge(hivePath);
-    let hiveUpdated = false;
-    for (const entry of hiveEntries) {
-      if (remainingIds.includes(entry.id)) {
-        const ro = entry.retrieval_outcomes;
-        if (phaseSucceeded) {
-          ro.succeeded_after_shown_count = (ro.succeeded_after_shown_count ?? 0) + 1;
-        } else {
-          ro.failed_after_shown_count = (ro.failed_after_shown_count ?? 0) + 1;
-        }
-        hiveUpdated = true;
-      }
-    }
-    if (hiveUpdated) {
-      await rewriteKnowledge(hivePath, hiveEntries);
-    }
-    delete shownData[phaseInfo];
-    await writeFile6(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
-  } catch {
-    warn("[swarm] Knowledge: failed to update retrieval outcomes");
-  }
-}
-function lc(s) {
-  return (s ?? "").toLowerCase();
-}
-function anyMatch(haystack, needles) {
-  if (needles.length === 0)
-    return false;
-  const hay = haystack.map(lc);
-  return needles.some((n) => hay.some((h) => h.includes(lc(n))));
-}
-function tokenizeContext(ctx) {
-  const parts2 = [];
-  if (ctx.taskTitle)
-    parts2.push(ctx.taskTitle);
-  if (ctx.taskDescription)
-    parts2.push(ctx.taskDescription);
-  if (ctx.lastUserMessage)
-    parts2.push(ctx.lastUserMessage);
-  if (ctx.currentAction)
-    parts2.push(ctx.currentAction);
-  if (ctx.currentTool)
-    parts2.push(ctx.currentTool);
-  if (ctx.targetAgent)
-    parts2.push(ctx.targetAgent);
-  if (ctx.declaredScope)
-    parts2.push(ctx.declaredScope);
-  if (ctx.recentReviewerFailures)
-    parts2.push(...ctx.recentReviewerFailures);
-  if (ctx.recentTestFailures)
-    parts2.push(...ctx.recentTestFailures);
-  if (ctx.recentToolErrors)
-    parts2.push(...ctx.recentToolErrors);
-  if (ctx.planConstraints)
-    parts2.push(...ctx.planConstraints);
-  if (ctx.filePaths)
-    parts2.push(...ctx.filePaths);
-  return parts2.map(lc);
-}
-function scoreDirectiveAgainstContext(entry, ctx) {
-  const haystack = tokenizeContext(ctx);
-  const triggerHit = entry.triggers && entry.triggers.length > 0 ? anyMatch(haystack, entry.triggers) : false;
-  const actionHit = entry.applies_to_tools && entry.applies_to_tools.length > 0 ? entry.applies_to_tools.map(lc).some((t) => t === lc(ctx.currentTool) || t === lc(ctx.currentAction)) : false;
-  const agentHit = entry.applies_to_agents && entry.applies_to_agents.length > 0 ? entry.applies_to_agents.map(lc).some((a) => a === lc(ctx.targetAgent)) : false;
-  let score = 0;
-  if (triggerHit)
-    score += 0.5;
-  if (actionHit)
-    score += 0.35;
-  if (agentHit)
-    score += 0.25;
-  if (entry.directive_priority === "critical")
-    score += 0.4;
-  else if (entry.directive_priority === "high")
-    score += 0.2;
-  else if (entry.directive_priority === "medium")
-    score += 0.1;
-  return { triggerHit, actionHit, agentHit, score: Math.min(1, score) };
-}
-async function readContextualKnowledge(directory, config3, ctx) {
-  const projected = {
-    projectName: ctx.projectName ?? "unknown",
-    currentPhase: ctx.currentPhase ?? "Phase 0",
-    techStack: ctx.techStack,
-    recentErrors: [
-      ...ctx.recentReviewerFailures ?? [],
-      ...ctx.recentTestFailures ?? [],
-      ...ctx.recentToolErrors ?? []
-    ]
-  };
-  const wideCfg = {
-    ...config3,
-    max_inject_count: Math.max(20, config3.max_inject_count ?? 5)
-  };
-  const candidates = await readMergedKnowledge(directory, wideCfg, projected) ?? [];
-  const minConf = typeof config3.directive_min_confidence === "number" ? config3.directive_min_confidence : DIRECTIVE_BOOST_MIN_CONFIDENCE;
-  const rescored = candidates.map((entry) => {
-    const ds = scoreDirectiveAgainstContext(entry, ctx);
-    const confBoost = entry.confidence >= minConf && (ds.actionHit || ds.agentHit) ? 0.25 : 0;
-    const generatedSkillBoost = entry.generated_skill_path && entry.status !== "archived" ? 0.05 : 0;
-    const finalScore = Math.min(1, entry.finalScore + ds.score + confBoost + generatedSkillBoost);
-    return {
-      ...entry,
-      finalScore,
-      __directive: ds
-    };
-  });
-  rescored.sort((a, b) => b.finalScore - a.finalScore);
-  const max = config3.max_inject_count ?? 5;
-  const top = [];
-  const seen = new Set;
-  for (const e of rescored) {
-    if (top.length >= max)
-      break;
-    const ds = e.__directive;
-    const isCritical = e.directive_priority === "critical" && (ds.triggerHit || ds.actionHit || ds.agentHit);
-    if (isCritical && !seen.has(e.id)) {
-      top.push(e);
-      seen.add(e.id);
-    }
-  }
-  for (const e of rescored) {
-    if (top.length >= max)
-      break;
-    if (!seen.has(e.id)) {
-      top.push(e);
-      seen.add(e.id);
-    }
-  }
-  return top.map(({ __directive: _d, ...rest }) => rest);
-}
-var JACCARD_THRESHOLD = 0.6, HIVE_TIER_BOOST = 0.05, SAME_PROJECT_PENALTY = -0.05, DIRECTIVE_BOOST_MIN_CONFIDENCE = 0.75;
-var init_knowledge_reader = __esm(() => {
-  init_logger();
-  init_knowledge_store();
-});
-
 // src/hooks/knowledge-curator.ts
 function pruneSeenRetroSections() {
   const cutoff = Date.now() - 86400000;
@@ -57668,17 +57346,39 @@ function extractRetractionsAndLessons(allLessons) {
 async function processRetractions(retractions, directory) {
   if (retractions.length === 0)
     return;
-  const knowledgePath = resolveSwarmKnowledgePath(directory);
-  const entries = await readKnowledge(knowledgePath) ?? [];
+  const swarmEntries = await readKnowledge(resolveSwarmKnowledgePath(directory)) ?? [];
+  const hiveEntries = await readKnowledge(resolveHiveKnowledgePath()) ?? [];
+  const existingRetractions = await readRetractionRecords(directory);
+  const existingSuppressedLessons = new Set(existingRetractions.map((record3) => record3.normalized_lesson).filter((value) => typeof value === "string" && value.length > 0));
   for (const retractionText of retractions) {
     const normalizedRetraction = normalize2(retractionText);
-    for (const entry of entries) {
+    const matchedSwarmIds = [];
+    const matchedHiveIds = [];
+    for (const entry of swarmEntries) {
       const normalizedLesson = normalize2(entry.lesson);
       if (normalizedLesson === normalizedRetraction) {
+        matchedSwarmIds.push(entry.id);
         await quarantineEntry(directory, entry.id, `Retracted by architect: ${retractionText}`, "architect");
         console.info(`[knowledge-curator] Quarantined entry ${entry.id}: "${entry.lesson}"`);
       }
     }
+    for (const entry of hiveEntries) {
+      if (normalize2(entry.lesson) === normalizedRetraction) {
+        matchedHiveIds.push(entry.id);
+      }
+    }
+    if (!existingSuppressedLessons.has(normalizedRetraction)) {
+      await appendRetractionRecord(directory, {
+        id: crypto.randomUUID(),
+        retracted_lesson: retractionText,
+        normalized_lesson: normalizedRetraction,
+        recorded_at: new Date().toISOString(),
+        reported_by: "architect",
+        matched_swarm_ids: matchedSwarmIds,
+        matched_hive_ids: matchedHiveIds
+      });
+      existingSuppressedLessons.add(normalizedRetraction);
+    }
   }
 }
 async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, config3) {
@@ -57845,7 +57545,6 @@ function createKnowledgeCuratorHook(directory, config3) {
       const projectName2 = evidenceData.project_name ?? "unknown";
       const phaseNumber2 = typeof evidenceData.phase_number === "number" ? evidenceData.phase_number : 1;
       await _internals15.curateAndStoreSwarm(lessons, projectName2, { phase_number: phaseNumber2 }, directory, config3);
-      await updateRetrievalOutcome(directory, `Phase ${phaseNumber2}`, true);
       return;
     }
     const planContent = await readSwarmFileAsync(directory, "plan.md");
@@ -57868,13 +57567,11 @@ function createKnowledgeCuratorHook(directory, config3) {
     const phaseMatch = /^Phase:\s*(\d+)/m.exec(planContent);
     const phaseNumber = phaseMatch ? parseInt(phaseMatch[1], 10) : 1;
     await _internals15.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config3);
-    await updateRetrievalOutcome(directory, `Phase ${phaseNumber}`, true);
   };
   return safeHook(handler);
 }
 var seenRetroSections, _internals15;
 var init_knowledge_curator = __esm(() => {
-  init_knowledge_reader();
   init_knowledge_store();
   init_knowledge_validator();
   init_utils2();
@@ -57997,9 +57694,9 @@ var init_skill_improver_llm_factory = __esm(() => {
 });
 
 // src/services/skill-improver-quota.ts
-import { existsSync as existsSync13 } from "node:fs";
-import { mkdir as mkdir7, readFile as readFile8, rename as rename4, writeFile as writeFile7 } from "node:fs/promises";
-import * as path22 from "node:path";
+import { existsSync as existsSync12 } from "node:fs";
+import { mkdir as mkdir6, readFile as readFile7, rename as rename4, writeFile as writeFile6 } from "node:fs/promises";
+import * as path21 from "node:path";
 async function acquireLock(dir) {
   const acquire = import_proper_lockfile5.default.lock(dir, LOCK_RETRY_OPTS);
   let timer;
@@ -58017,7 +57714,7 @@ async function acquireLock(dir) {
   }
 }
 function resolveQuotaPath(directory) {
-  return path22.join(directory, ".swarm", "skill-improver-quota.json");
+  return path21.join(directory, ".swarm", "skill-improver-quota.json");
 }
 function todayKey(window2, now = new Date) {
   if (window2 === "utc") {
@@ -58029,10 +57726,10 @@ function todayKey(window2, now = new Date) {
   return `${yr}-${m}-${d}`;
 }
 async function readState(filePath) {
-  if (!existsSync13(filePath))
+  if (!existsSync12(filePath))
     return null;
   try {
-    const raw = await readFile8(filePath, "utf-8");
+    const raw = await readFile7(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.date !== "string" || typeof parsed.calls_used !== "number" || typeof parsed.max_calls !== "number" || parsed.window !== "utc" && parsed.window !== "local") {
       return null;
@@ -58043,9 +57740,9 @@ async function readState(filePath) {
   }
 }
 async function writeState(filePath, state) {
-  await mkdir7(path22.dirname(filePath), { recursive: true });
+  await mkdir6(path21.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}`;
-  await writeFile7(tmp, JSON.stringify(state, null, 2), "utf-8");
+  await writeFile6(tmp, JSON.stringify(state, null, 2), "utf-8");
   await rename4(tmp, filePath);
 }
 async function getQuotaState(directory, opts) {
@@ -58066,10 +57763,10 @@ async function getQuotaState(directory, opts) {
 }
 async function reserveQuota(directory, opts) {
   const filePath = resolveQuotaPath(directory);
-  await mkdir7(path22.dirname(filePath), { recursive: true });
+  await mkdir6(path21.dirname(filePath), { recursive: true });
   let release = null;
   try {
-    release = await acquireLock(path22.dirname(filePath));
+    release = await acquireLock(path21.dirname(filePath));
     const state = await getQuotaState(directory, opts);
     if (state.calls_used + opts.nCalls > opts.maxCalls) {
       return {
@@ -58096,10 +57793,10 @@ async function reserveQuota(directory, opts) {
 }
 async function releaseQuota(directory, opts) {
   const filePath = resolveQuotaPath(directory);
-  await mkdir7(path22.dirname(filePath), { recursive: true });
+  await mkdir6(path21.dirname(filePath), { recursive: true });
   let release = null;
   try {
-    release = await acquireLock(path22.dirname(filePath));
+    release = await acquireLock(path21.dirname(filePath));
     const state = await getQuotaState(directory, opts);
     const next = {
       ...state,
@@ -58131,22 +57828,22 @@ var init_skill_improver_quota = __esm(() => {
 });
 
 // src/services/skill-improver.ts
-import { existsSync as existsSync14 } from "node:fs";
-import { mkdir as mkdir8, rename as rename5, writeFile as writeFile8 } from "node:fs/promises";
-import * as path23 from "node:path";
+import { existsSync as existsSync13 } from "node:fs";
+import { mkdir as mkdir7, rename as rename5, writeFile as writeFile7 } from "node:fs/promises";
+import * as path22 from "node:path";
 function timestampSlug(d) {
   return d.toISOString().replace(/[:.]/g, "-");
 }
 async function atomicWrite4(p, content) {
-  await mkdir8(path23.dirname(p), { recursive: true });
+  await mkdir7(path22.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile8(tmp, content, "utf-8");
+  await writeFile7(tmp, content, "utf-8");
   await rename5(tmp, p);
 }
 async function gatherInventory(directory) {
   const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
   const hivePath = resolveHiveKnowledgePath();
-  const hive = existsSync14(hivePath) ? await readKnowledge(hivePath) : [];
+  const hive = existsSync13(hivePath) ? await readKnowledge(hivePath) : [];
   const archived = [...swarm, ...hive].filter((e) => e.status === "archived").length;
   const skills = await listSkills(directory);
   const matureCandidates = swarm.concat(hive).filter((e) => e.status !== "archived" && e.confidence >= 0.85 && !e.generated_skill_slug && (e.confirmed_by ?? []).length >= 2);
@@ -58419,8 +58116,8 @@ async function runSkillImprover(req) {
     }
     throw err2;
   }
-  const proposalDir = path23.join(req.directory, ".swarm", "skill-improver", "proposals");
-  const proposalFile = path23.join(proposalDir, `${timestampSlug(now)}.md`);
+  const proposalDir = path22.join(req.directory, ".swarm", "skill-improver", "proposals");
+  const proposalFile = path22.join(proposalDir, `${timestampSlug(now)}.md`);
   const finalBody = source === "llm" ? buildLLMProposalFrame({
     body: body2,
     targets,
@@ -58816,7 +58513,7 @@ var init_write_retro = __esm(() => {
 
 // src/commands/close.ts
 import { promises as fs13 } from "node:fs";
-import path24 from "node:path";
+import path23 from "node:path";
 async function runAbortableSkillReview(req, timeoutMs) {
   const controller = new AbortController;
   let timeout;
@@ -58872,10 +58569,10 @@ function guaranteeAllPlansComplete(planData) {
 }
 async function handleCloseCommand(directory, args2, options = {}) {
   const planPath = validateSwarmPath(directory, "plan.json");
-  const swarmDir = path24.join(directory, ".swarm");
+  const swarmDir = path23.join(directory, ".swarm");
   let planExists = false;
   let planData = {
-    title: path24.basename(directory) || "Ad-hoc session",
+    title: path23.basename(directory) || "Ad-hoc session",
     phases: []
   };
   try {
@@ -58984,7 +58681,7 @@ async function handleCloseCommand(directory, args2, options = {}) {
       warnings.push(`Session retrospective write threw: ${retroError instanceof Error ? retroError.message : String(retroError)}`);
     }
   }
-  const lessonsFilePath = path24.join(swarmDir, "close-lessons.md");
+  const lessonsFilePath = path23.join(swarmDir, "close-lessons.md");
   let explicitLessons = [];
   try {
     const lessonsText = await fs13.readFile(lessonsFilePath, "utf-8");
@@ -58993,11 +58690,11 @@ async function handleCloseCommand(directory, args2, options = {}) {
   } catch {}
   const retroLessons = [];
   try {
-    const evidenceDir = path24.join(swarmDir, "evidence");
+    const evidenceDir = path23.join(swarmDir, "evidence");
     const evidenceEntries = await fs13.readdir(evidenceDir);
     const retroDirs = evidenceEntries.filter((e) => e.startsWith("retro-")).sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
     for (const retroDir of retroDirs) {
-      const evidencePath = path24.join(evidenceDir, retroDir, "evidence.json");
+      const evidencePath = path23.join(evidenceDir, retroDir, "evidence.json");
       try {
         const content = await fs13.readFile(evidencePath, "utf-8");
         const parsed = JSON.parse(content);
@@ -59122,7 +58819,7 @@ async function handleCloseCommand(directory, args2, options = {}) {
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
   const suffix = Math.random().toString(36).slice(2, 8);
-  const archiveDir = path24.join(swarmDir, "archive", `swarm-${timestamp}-${suffix}`);
+  const archiveDir = path23.join(swarmDir, "archive", `swarm-${timestamp}-${suffix}`);
   let archiveResult = "";
   let archivedFileCount = 0;
   const archivedActiveStateFiles = new Set;
@@ -59130,8 +58827,8 @@ async function handleCloseCommand(directory, args2, options = {}) {
   try {
     await fs13.mkdir(archiveDir, { recursive: true });
     for (const artifact of ARCHIVE_ARTIFACTS) {
-      const srcPath = path24.join(swarmDir, artifact);
-      const destPath = path24.join(archiveDir, artifact);
+      const srcPath = path23.join(swarmDir, artifact);
+      const destPath = path23.join(archiveDir, artifact);
       try {
         await fs13.copyFile(srcPath, destPath);
         archivedFileCount++;
@@ -59141,22 +58838,22 @@ async function handleCloseCommand(directory, args2, options = {}) {
       } catch {}
     }
     for (const dirName of ACTIVE_STATE_DIRS_TO_CLEAN) {
-      const srcDir = path24.join(swarmDir, dirName);
-      const destDir = path24.join(archiveDir, dirName);
+      const srcDir = path23.join(swarmDir, dirName);
+      const destDir = path23.join(archiveDir, dirName);
       try {
         const entries = await fs13.readdir(srcDir);
         if (entries.length > 0) {
           await fs13.mkdir(destDir, { recursive: true });
           for (const entry of entries) {
-            const srcEntry = path24.join(srcDir, entry);
-            const destEntry = path24.join(destDir, entry);
+            const srcEntry = path23.join(srcDir, entry);
+            const destEntry = path23.join(destDir, entry);
             try {
               const stat3 = await fs13.stat(srcEntry);
               if (stat3.isDirectory()) {
                 await fs13.mkdir(destEntry, { recursive: true });
                 const subEntries = await fs13.readdir(srcEntry);
                 for (const sub of subEntries) {
-                  await fs13.copyFile(path24.join(srcEntry, sub), path24.join(destEntry, sub)).catch(() => {});
+                  await fs13.copyFile(path23.join(srcEntry, sub), path23.join(destEntry, sub)).catch(() => {});
                 }
               } else {
                 await fs13.copyFile(srcEntry, destEntry);
@@ -59188,7 +58885,7 @@ async function handleCloseCommand(directory, args2, options = {}) {
         warnings.push(`Preserved ${artifact} because it was not successfully archived.`);
         continue;
       }
-      const filePath = path24.join(swarmDir, artifact);
+      const filePath = path23.join(swarmDir, artifact);
       try {
         await fs13.unlink(filePath);
         cleanedFiles.push(artifact);
@@ -59201,7 +58898,7 @@ async function handleCloseCommand(directory, args2, options = {}) {
     if (!archivedActiveStateDirs.has(dirName)) {
       continue;
     }
-    const dirPath = path24.join(swarmDir, dirName);
+    const dirPath = path23.join(swarmDir, dirName);
     try {
       await fs13.rm(dirPath, { recursive: true, force: true });
       cleanedFiles.push(`${dirName}/`);
@@ -59212,23 +58909,23 @@ async function handleCloseCommand(directory, args2, options = {}) {
     const configBackups = swarmFiles.filter((f) => f.startsWith("config-backup-") && f.endsWith(".json"));
     for (const backup of configBackups) {
       try {
-        await fs13.unlink(path24.join(swarmDir, backup));
+        await fs13.unlink(path23.join(swarmDir, backup));
         configBackupsRemoved++;
       } catch {}
     }
     const ledgerSiblings = swarmFiles.filter((f) => (f.startsWith("plan-ledger.archived-") || f.startsWith("plan-ledger.backup-")) && f.endsWith(".jsonl"));
     for (const sibling of ledgerSiblings) {
       try {
-        await fs13.unlink(path24.join(swarmDir, sibling));
+        await fs13.unlink(path23.join(swarmDir, sibling));
       } catch {}
     }
   } catch {}
   let swarmPlanFilesRemoved = 0;
   const candidates = [
-    path24.join(directory, ".swarm", "SWARM_PLAN.json"),
-    path24.join(directory, ".swarm", "SWARM_PLAN.md"),
-    path24.join(directory, "SWARM_PLAN.json"),
-    path24.join(directory, "SWARM_PLAN.md")
+    path23.join(directory, ".swarm", "SWARM_PLAN.json"),
+    path23.join(directory, ".swarm", "SWARM_PLAN.md"),
+    path23.join(directory, "SWARM_PLAN.json"),
+    path23.join(directory, "SWARM_PLAN.md")
   ];
   for (const candidate of candidates) {
     try {
@@ -59236,12 +58933,12 @@ async function handleCloseCommand(directory, args2, options = {}) {
       swarmPlanFilesRemoved++;
     } catch (err2) {
       if (err2?.code !== "ENOENT") {
-        warnings.push(`Failed to remove ${path24.basename(candidate)}: ${err2 instanceof Error ? err2.message : String(err2)}`);
+        warnings.push(`Failed to remove ${path23.basename(candidate)}: ${err2 instanceof Error ? err2.message : String(err2)}`);
       }
     }
   }
   clearAllScopes(directory);
-  const contextPath = path24.join(swarmDir, "context.md");
+  const contextPath = path23.join(swarmDir, "context.md");
   const contextContent = [
     "# Context",
     "",
@@ -59460,14 +59157,14 @@ var init_close = __esm(() => {
 
 // src/commands/config.ts
 import * as os4 from "node:os";
-import * as path25 from "node:path";
+import * as path24 from "node:path";
 function getUserConfigDir2() {
-  return process.env.XDG_CONFIG_HOME || path25.join(os4.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path24.join(os4.homedir(), ".config");
 }
 async function handleConfigCommand(directory, _args) {
   const config3 = loadPluginConfig(directory);
-  const userConfigPath = path25.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path25.join(directory, ".opencode", "opencode-swarm.json");
+  const userConfigPath = path24.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path24.join(directory, ".opencode", "opencode-swarm.json");
   const lines = [
     "## Swarm Configuration",
     "",
@@ -59604,8 +59301,8 @@ __export(exports_co_change_analyzer, {
 });
 import * as child_process3 from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { readdir as readdir2, readFile as readFile9, stat as stat3 } from "node:fs/promises";
-import * as path26 from "node:path";
+import { readdir as readdir2, readFile as readFile8, stat as stat3 } from "node:fs/promises";
+import * as path25 from "node:path";
 import { promisify } from "node:util";
 function getExecFileAsync() {
   return promisify(child_process3.execFile);
@@ -59707,7 +59404,7 @@ async function scanSourceFiles(dir) {
   try {
     const entries = await readdir2(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path26.join(dir, entry.name);
+      const fullPath = path25.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (skipDirs.has(entry.name)) {
           continue;
@@ -59715,7 +59412,7 @@ async function scanSourceFiles(dir) {
         const subFiles = await scanSourceFiles(fullPath);
         results.push(...subFiles);
       } else if (entry.isFile()) {
-        const ext = path26.extname(entry.name);
+        const ext = path25.extname(entry.name);
         if ([".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(ext)) {
           results.push(fullPath);
         }
@@ -59729,7 +59426,7 @@ async function getStaticEdges(directory) {
   const sourceFiles = await scanSourceFiles(directory);
   for (const sourceFile of sourceFiles) {
     try {
-      const content = await readFile9(sourceFile, "utf-8");
+      const content = await readFile8(sourceFile, "utf-8");
       const importRegex = /(?:import|require)\s*(?:\(?\s*['"`]|.*?from\s+['"`])([^'"`]+)['"`]/g;
       for (let match = importRegex.exec(content);match !== null; match = importRegex.exec(content)) {
         const importPath = match[1].trim();
@@ -59737,8 +59434,8 @@ async function getStaticEdges(directory) {
           continue;
         }
         try {
-          const sourceDir = path26.dirname(sourceFile);
-          const resolvedPath = path26.resolve(sourceDir, importPath);
+          const sourceDir = path25.dirname(sourceFile);
+          const resolvedPath = path25.resolve(sourceDir, importPath);
           const extensions = [
             "",
             ".ts",
@@ -59763,8 +59460,8 @@ async function getStaticEdges(directory) {
           if (!targetFile) {
             continue;
           }
-          const relSource = path26.relative(directory, sourceFile).replace(/\\/g, "/");
-          const relTarget = path26.relative(directory, targetFile).replace(/\\/g, "/");
+          const relSource = path25.relative(directory, sourceFile).replace(/\\/g, "/");
+          const relTarget = path25.relative(directory, targetFile).replace(/\\/g, "/");
           const [key] = relSource < relTarget ? [`${relSource}::${relTarget}`, relSource, relTarget] : [`${relTarget}::${relSource}`, relTarget, relSource];
           edges.add(key);
         } catch {}
@@ -59776,7 +59473,7 @@ async function getStaticEdges(directory) {
 function isTestImplementationPair(fileA, fileB) {
   const testPatterns = [".test.ts", ".test.js", ".spec.ts", ".spec.js"];
   const getBaseName = (filePath) => {
-    const base = path26.basename(filePath);
+    const base = path25.basename(filePath);
     for (const pattern of testPatterns) {
       if (base.endsWith(pattern)) {
         return base.slice(0, -pattern.length);
@@ -59786,16 +59483,16 @@ function isTestImplementationPair(fileA, fileB) {
   };
   const baseA = getBaseName(fileA);
   const baseB = getBaseName(fileB);
-  return baseA === baseB && baseA !== path26.basename(fileA) && baseA !== path26.basename(fileB);
+  return baseA === baseB && baseA !== path25.basename(fileA) && baseA !== path25.basename(fileB);
 }
 function hasSharedPrefix(fileA, fileB) {
-  const dirA = path26.dirname(fileA);
-  const dirB = path26.dirname(fileB);
+  const dirA = path25.dirname(fileA);
+  const dirB = path25.dirname(fileB);
   if (dirA !== dirB) {
     return false;
   }
-  const baseA = path26.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
-  const baseB = path26.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseA = path25.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseB = path25.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
   if (baseA.startsWith(baseB) || baseB.startsWith(baseA)) {
     return true;
   }
@@ -59849,8 +59546,8 @@ function darkMatterToKnowledgeEntries(pairs, projectName) {
   const entries = [];
   const now = new Date().toISOString();
   for (const pair of pairs.slice(0, 10)) {
-    const baseA = path26.basename(pair.fileA);
-    const baseB = path26.basename(pair.fileB);
+    const baseA = path25.basename(pair.fileA);
+    const baseB = path25.basename(pair.fileB);
     let lesson = `Files ${pair.fileA} and ${pair.fileB} co-change with NPMI=${pair.npmi.toFixed(3)} but have no import relationship. This hidden coupling suggests a shared architectural concern — changes to one likely require changes to the other.`;
     if (lesson.length > 280) {
       lesson = `Files ${baseA} and ${baseB} co-change with NPMI=${pair.npmi.toFixed(3)} but have no import relationship. This hidden coupling suggests a shared architectural concern — changes to one likely require changes to the other.`;
@@ -59952,7 +59649,7 @@ var init_co_change_analyzer = __esm(() => {
 });
 
 // src/commands/dark-matter.ts
-import path27 from "node:path";
+import path26 from "node:path";
 async function handleDarkMatterCommand(directory, args2) {
   const options = {};
   for (let i2 = 0;i2 < args2.length; i2++) {
@@ -59984,7 +59681,7 @@ Ensure this is a git repository with commit history.`;
   const output = formatDarkMatterOutput(pairs);
   if (pairs.length > 0) {
     try {
-      const projectName = path27.basename(path27.resolve(directory));
+      const projectName = path26.basename(path26.resolve(directory));
       const entries = darkMatterToKnowledgeEntries(pairs, projectName);
       if (entries.length > 0) {
         const knowledgePath = resolveSwarmKnowledgePath(directory);
@@ -60121,49 +59818,49 @@ var init_deep_dive = __esm(() => {
 
 // src/config/cache-paths.ts
 import * as os5 from "node:os";
-import * as path28 from "node:path";
+import * as path27 from "node:path";
 function getPluginConfigDir() {
-  return path28.join(process.env.XDG_CONFIG_HOME || path28.join(os5.homedir(), ".config"), "opencode");
+  return path27.join(process.env.XDG_CONFIG_HOME || path27.join(os5.homedir(), ".config"), "opencode");
 }
 function getPluginCachePaths() {
-  const cacheBase = process.env.XDG_CACHE_HOME || path28.join(os5.homedir(), ".cache");
+  const cacheBase = process.env.XDG_CACHE_HOME || path27.join(os5.homedir(), ".cache");
   const configDir = getPluginConfigDir();
   const paths = [
-    path28.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
-    path28.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
-    path28.join(configDir, "node_modules", "opencode-swarm")
+    path27.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
+    path27.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
+    path27.join(configDir, "node_modules", "opencode-swarm")
   ];
   if (process.platform === "darwin") {
-    const libCaches = path28.join(os5.homedir(), "Library", "Caches");
-    paths.push(path28.join(libCaches, "opencode", "node_modules", "opencode-swarm"), path28.join(libCaches, "opencode", "packages", "opencode-swarm@latest"));
+    const libCaches = path27.join(os5.homedir(), "Library", "Caches");
+    paths.push(path27.join(libCaches, "opencode", "node_modules", "opencode-swarm"), path27.join(libCaches, "opencode", "packages", "opencode-swarm@latest"));
   }
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || path28.join(os5.homedir(), "AppData", "Local");
-    const appData = process.env.APPDATA || path28.join(os5.homedir(), "AppData", "Roaming");
-    paths.push(path28.join(localAppData, "opencode", "node_modules", "opencode-swarm"), path28.join(localAppData, "opencode", "packages", "opencode-swarm@latest"), path28.join(appData, "opencode", "node_modules", "opencode-swarm"));
+    const localAppData = process.env.LOCALAPPDATA || path27.join(os5.homedir(), "AppData", "Local");
+    const appData = process.env.APPDATA || path27.join(os5.homedir(), "AppData", "Roaming");
+    paths.push(path27.join(localAppData, "opencode", "node_modules", "opencode-swarm"), path27.join(localAppData, "opencode", "packages", "opencode-swarm@latest"), path27.join(appData, "opencode", "node_modules", "opencode-swarm"));
   }
   return paths;
 }
 var init_cache_paths = () => {};
 
 // src/services/version-check.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join26 } from "node:path";
+import { join as join25 } from "node:path";
 function cacheDir() {
   const xdg = process.env.XDG_CACHE_HOME;
-  const base = xdg && xdg.length > 0 ? xdg : join26(homedir5(), ".cache");
-  return join26(base, "opencode-swarm");
+  const base = xdg && xdg.length > 0 ? xdg : join25(homedir5(), ".cache");
+  return join25(base, "opencode-swarm");
 }
 function cacheFile() {
-  return join26(cacheDir(), "version-check.json");
+  return join25(cacheDir(), "version-check.json");
 }
 function readVersionCache() {
   try {
-    const path29 = cacheFile();
-    if (!existsSync15(path29))
+    const path28 = cacheFile();
+    if (!existsSync14(path28))
       return null;
-    const raw = readFileSync7(path29, "utf-8");
+    const raw = readFileSync7(path28, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.checkedAt !== "number")
       return null;
@@ -60260,8 +59957,8 @@ var init_version_check = __esm(() => {
 
 // src/services/diagnose-service.ts
 import * as child_process4 from "node:child_process";
-import { existsSync as existsSync16, readdirSync as readdirSync4, readFileSync as readFileSync8, statSync as statSync7 } from "node:fs";
-import path29 from "node:path";
+import { existsSync as existsSync15, readdirSync as readdirSync4, readFileSync as readFileSync8, statSync as statSync7 } from "node:fs";
+import path28 from "node:path";
 import { fileURLToPath } from "node:url";
 function validateTaskDag(plan) {
   const allTaskIds = new Set;
@@ -60494,7 +60191,7 @@ async function checkConfigBackups(directory) {
 }
 async function checkGitRepository(directory) {
   try {
-    if (!existsSync16(directory) || !statSync7(directory).isDirectory()) {
+    if (!existsSync15(directory) || !statSync7(directory).isDirectory()) {
       return {
         name: "Git Repository",
         status: "❌",
@@ -60558,8 +60255,8 @@ async function checkSpecStaleness(directory, plan) {
   };
 }
 async function checkConfigParseability(directory) {
-  const configPath = path29.join(directory, ".opencode/opencode-swarm.json");
-  if (!existsSync16(configPath)) {
+  const configPath = path28.join(directory, ".opencode/opencode-swarm.json");
+  if (!existsSync15(configPath)) {
     return {
       name: "Config Parseability",
       status: "✅",
@@ -60587,7 +60284,7 @@ function resolveGrammarDir(thisDir) {
   const normalized = thisDir.replace(/\\/g, "/");
   const isSource = normalized.endsWith("/src/services");
   const isCliBundle = normalized.endsWith("/cli");
-  return isSource || isCliBundle ? path29.join(thisDir, "..", "lang", "grammars") : path29.join(thisDir, "lang", "grammars");
+  return isSource || isCliBundle ? path28.join(thisDir, "..", "lang", "grammars") : path28.join(thisDir, "lang", "grammars");
 }
 async function checkGrammarWasmFiles() {
   const grammarFiles = [
@@ -60611,14 +60308,14 @@ async function checkGrammarWasmFiles() {
     "tree-sitter-ini.wasm",
     "tree-sitter-regex.wasm"
   ];
-  const thisDir = path29.dirname(fileURLToPath(import.meta.url));
+  const thisDir = path28.dirname(fileURLToPath(import.meta.url));
   const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync16(path29.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync15(path28.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file3 of grammarFiles) {
-    if (!existsSync16(path29.join(grammarDir, file3))) {
+    if (!existsSync15(path28.join(grammarDir, file3))) {
       missing.push(file3);
     }
   }
@@ -60636,8 +60333,8 @@ async function checkGrammarWasmFiles() {
   };
 }
 async function checkCheckpointManifest(directory) {
-  const manifestPath = path29.join(directory, ".swarm/checkpoints.json");
-  if (!existsSync16(manifestPath)) {
+  const manifestPath = path28.join(directory, ".swarm/checkpoints.json");
+  if (!existsSync15(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
       status: "✅",
@@ -60688,8 +60385,8 @@ async function checkCheckpointManifest(directory) {
   }
 }
 async function checkEventStreamIntegrity(directory) {
-  const eventsPath = path29.join(directory, ".swarm/events.jsonl");
-  if (!existsSync16(eventsPath)) {
+  const eventsPath = path28.join(directory, ".swarm/events.jsonl");
+  if (!existsSync15(eventsPath)) {
     return {
       name: "Event Stream",
       status: "✅",
@@ -60729,8 +60426,8 @@ async function checkEventStreamIntegrity(directory) {
   }
 }
 async function checkSteeringDirectives(directory) {
-  const eventsPath = path29.join(directory, ".swarm/events.jsonl");
-  if (!existsSync16(eventsPath)) {
+  const eventsPath = path28.join(directory, ".swarm/events.jsonl");
+  if (!existsSync15(eventsPath)) {
     return {
       name: "Steering Directives",
       status: "✅",
@@ -60785,8 +60482,8 @@ async function checkCurator(directory) {
         detail: "Disabled (enable via curator.enabled)"
       };
     }
-    const summaryPath = path29.join(directory, ".swarm/curator-summary.json");
-    if (!existsSync16(summaryPath)) {
+    const summaryPath = path28.join(directory, ".swarm/curator-summary.json");
+    if (!existsSync15(summaryPath)) {
       return {
         name: "Curator",
         status: "✅",
@@ -60951,8 +60648,8 @@ async function getDiagnoseData(directory) {
   checks5.push(await checkSteeringDirectives(directory));
   checks5.push(await checkCurator(directory));
   try {
-    const evidenceDir = path29.join(directory, ".swarm", "evidence");
-    const snapshotFiles = existsSync16(evidenceDir) ? readdirSync4(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
+    const evidenceDir = path28.join(directory, ".swarm", "evidence");
+    const snapshotFiles = existsSync15(evidenceDir) ? readdirSync4(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
       checks5.push({
@@ -60985,11 +60682,11 @@ async function getDiagnoseData(directory) {
   const cacheRows = [];
   for (const cachePath of cachePaths) {
     try {
-      if (!existsSync16(cachePath)) {
+      if (!existsSync15(cachePath)) {
         cacheRows.push(`⬜ ${cachePath} — absent`);
         continue;
       }
-      const pkgJsonPath = path29.join(cachePath, "package.json");
+      const pkgJsonPath = path28.join(cachePath, "package.json");
       try {
         const raw = readFileSync8(pkgJsonPath, "utf-8");
         const parsed = JSON.parse(raw);
@@ -61079,13 +60776,13 @@ __export(exports_config_doctor, {
 import * as crypto3 from "node:crypto";
 import * as fs14 from "node:fs";
 import * as os6 from "node:os";
-import * as path30 from "node:path";
+import * as path29 from "node:path";
 function getUserConfigDir3() {
-  return process.env.XDG_CONFIG_HOME || path30.join(os6.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path29.join(os6.homedir(), ".config");
 }
 function getConfigPaths(directory) {
-  const userConfigPath = path30.join(getUserConfigDir3(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path30.join(directory, ".opencode", "opencode-swarm.json");
+  const userConfigPath = path29.join(getUserConfigDir3(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path29.join(directory, ".opencode", "opencode-swarm.json");
   return { userConfigPath, projectConfigPath };
 }
 function computeHash(content) {
@@ -61110,9 +60807,9 @@ function isValidConfigPath(configPath, directory) {
   const normalizedUser = userConfigPath.replace(/\\/g, "/");
   const normalizedProject = projectConfigPath.replace(/\\/g, "/");
   try {
-    const resolvedConfig = path30.resolve(configPath);
-    const resolvedUser = path30.resolve(normalizedUser);
-    const resolvedProject = path30.resolve(normalizedProject);
+    const resolvedConfig = path29.resolve(configPath);
+    const resolvedUser = path29.resolve(normalizedUser);
+    const resolvedProject = path29.resolve(normalizedProject);
     return resolvedConfig === resolvedUser || resolvedConfig === resolvedProject;
   } catch {
     return false;
@@ -61152,12 +60849,12 @@ function createConfigBackup(directory) {
   };
 }
 function writeBackupArtifact(directory, backup) {
-  const swarmDir = path30.join(directory, ".swarm");
+  const swarmDir = path29.join(directory, ".swarm");
   if (!fs14.existsSync(swarmDir)) {
     fs14.mkdirSync(swarmDir, { recursive: true });
   }
   const backupFilename = `config-backup-${backup.createdAt}.json`;
-  const backupPath = path30.join(swarmDir, backupFilename);
+  const backupPath = path29.join(swarmDir, backupFilename);
   const artifact = {
     createdAt: backup.createdAt,
     configPath: backup.configPath,
@@ -61187,7 +60884,7 @@ function restoreFromBackup(backupPath, directory) {
       return null;
     }
     const targetPath = artifact.configPath;
-    const targetDir = path30.dirname(targetPath);
+    const targetDir = path29.dirname(targetPath);
     if (!fs14.existsSync(targetDir)) {
       fs14.mkdirSync(targetDir, { recursive: true });
     }
@@ -61218,9 +60915,9 @@ function readConfigFromFile(directory) {
     return null;
   }
 }
-function validateConfigKey(path31, value, _config) {
+function validateConfigKey(path30, value, _config) {
   const findings = [];
-  switch (path31) {
+  switch (path30) {
     case "agents": {
       if (value !== undefined) {
         findings.push({
@@ -61457,27 +61154,27 @@ function validateConfigKey(path31, value, _config) {
   }
   return findings;
 }
-function walkConfigAndValidate(obj, path31, config3, findings) {
+function walkConfigAndValidate(obj, path30, config3, findings) {
   if (obj === null || obj === undefined) {
     return;
   }
-  if (path31 && typeof obj === "object" && !Array.isArray(obj)) {
-    const keyFindings = validateConfigKey(path31, obj, config3);
+  if (path30 && typeof obj === "object" && !Array.isArray(obj)) {
+    const keyFindings = validateConfigKey(path30, obj, config3);
     findings.push(...keyFindings);
   }
   if (typeof obj !== "object") {
-    const keyFindings = validateConfigKey(path31, obj, config3);
+    const keyFindings = validateConfigKey(path30, obj, config3);
     findings.push(...keyFindings);
     return;
   }
   if (Array.isArray(obj)) {
     obj.forEach((item, index) => {
-      walkConfigAndValidate(item, `${path31}[${index}]`, config3, findings);
+      walkConfigAndValidate(item, `${path30}[${index}]`, config3, findings);
     });
     return;
   }
   for (const [key, value] of Object.entries(obj)) {
-    const newPath = path31 ? `${path31}.${key}` : key;
+    const newPath = path30 ? `${path30}.${key}` : key;
     walkConfigAndValidate(value, newPath, config3, findings);
   }
 }
@@ -61597,7 +61294,7 @@ function applySafeAutoFixes(directory, result) {
     }
   }
   if (appliedFixes.length > 0) {
-    const configDir = path30.dirname(configPath);
+    const configDir = path29.dirname(configPath);
     if (!fs14.existsSync(configDir)) {
       fs14.mkdirSync(configDir, { recursive: true });
     }
@@ -61607,12 +61304,12 @@ function applySafeAutoFixes(directory, result) {
   return { appliedFixes, updatedConfigPath };
 }
 function writeDoctorArtifact(directory, result) {
-  const swarmDir = path30.join(directory, ".swarm");
+  const swarmDir = path29.join(directory, ".swarm");
   if (!fs14.existsSync(swarmDir)) {
     fs14.mkdirSync(swarmDir, { recursive: true });
   }
   const artifactFilename = "config-doctor.json";
-  const artifactPath = path30.join(swarmDir, artifactFilename);
+  const artifactPath = path29.join(swarmDir, artifactFilename);
   const guiOutput = {
     timestamp: result.timestamp,
     summary: result.summary,
@@ -61708,17 +61405,17 @@ function detectStraySwarmDirs(projectRoot) {
       if (!entry.isDirectory())
         continue;
       const name2 = entry.name;
-      const fullPath = path30.join(dir, name2);
+      const fullPath = path29.join(dir, name2);
       if (SKIP_DIRS.has(name2))
         continue;
-      const gitPath = path30.join(fullPath, ".git");
+      const gitPath = path29.join(fullPath, ".git");
       try {
         const gitStat = fs14.statSync(gitPath);
         if (gitStat.isFile() || gitStat.isDirectory())
           continue;
       } catch {}
       if (name2 === ".swarm") {
-        const parentDir = path30.dirname(fullPath);
+        const parentDir = path29.dirname(fullPath);
         if (parentDir === projectRoot)
           continue;
         let contents = [];
@@ -61728,7 +61425,7 @@ function detectStraySwarmDirs(projectRoot) {
           contents = ["<unreadable>"];
         }
         findings.push({
-          path: path30.relative(projectRoot, fullPath).replace(/\\/g, "/"),
+          path: path29.relative(projectRoot, fullPath).replace(/\\/g, "/"),
           absolutePath: fullPath,
           contents: contents.slice(0, MAX_CONTENTS_ENTRIES),
           totalEntries: contents.length
@@ -61746,21 +61443,21 @@ function removeStraySwarmDir(projectRoot, strayPath) {
   let canonicalStray;
   try {
     canonicalRoot = fs14.realpathSync(projectRoot);
-    canonicalStray = fs14.realpathSync(path30.isAbsolute(strayPath) ? strayPath : path30.resolve(projectRoot, strayPath));
+    canonicalStray = fs14.realpathSync(path29.isAbsolute(strayPath) ? strayPath : path29.resolve(projectRoot, strayPath));
   } catch (err2) {
     return {
       success: false,
       message: `Failed to resolve paths: ${err2 instanceof Error ? err2.message : String(err2)}`
     };
   }
-  const rootSwarm = path30.join(canonicalRoot, ".swarm");
+  const rootSwarm = path29.join(canonicalRoot, ".swarm");
   if (canonicalStray === rootSwarm || canonicalStray === canonicalRoot) {
     return {
       success: false,
       message: "Refusing to remove root .swarm/ directory"
     };
   }
-  if (!canonicalStray.startsWith(canonicalRoot + path30.sep)) {
+  if (!canonicalStray.startsWith(canonicalRoot + path29.sep)) {
     return {
       success: false,
       message: "Path is outside project root — refusing to remove"
@@ -62849,7 +62546,7 @@ var init_profiles = __esm(() => {
 
 // src/lang/detector.ts
 import { access as access3, readdir as readdir3 } from "node:fs/promises";
-import { extname as extname2, join as join28 } from "node:path";
+import { extname as extname2, join as join27 } from "node:path";
 function getProfileForFile(filePath) {
   const ext = extname2(filePath);
   if (!ext)
@@ -62871,7 +62568,7 @@ async function detectProjectLanguages(projectDir) {
         if (detectFile.includes("*") || detectFile.includes("?"))
           continue;
         try {
-          await access3(join28(dir, detectFile));
+          await access3(join27(dir, detectFile));
           detected.add(profile.id);
           break;
         } catch {}
@@ -62892,7 +62589,7 @@ async function detectProjectLanguages(projectDir) {
     const topEntries = await readdir3(projectDir, { withFileTypes: true });
     for (const entry of topEntries) {
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-        await scanDir(join28(projectDir, entry.name));
+        await scanDir(join27(projectDir, entry.name));
       }
     }
   } catch {}
@@ -62911,7 +62608,7 @@ var init_detector = __esm(() => {
 
 // src/build/discovery.ts
 import * as fs15 from "node:fs";
-import * as path31 from "node:path";
+import * as path30 from "node:path";
 function isCommandAvailable(command) {
   if (toolchainCache.has(command)) {
     return toolchainCache.get(command);
@@ -62946,11 +62643,11 @@ function findBuildFiles(workingDir, patterns) {
         const regex = simpleGlobToRegex(pattern);
         const matches = files.filter((f) => regex.test(f));
         if (matches.length > 0) {
-          return path31.join(dir, matches[0]);
+          return path30.join(dir, matches[0]);
         }
       } catch {}
     } else {
-      const filePath = path31.join(workingDir, pattern);
+      const filePath = path30.join(workingDir, pattern);
       if (fs15.existsSync(filePath)) {
         return filePath;
       }
@@ -62959,7 +62656,7 @@ function findBuildFiles(workingDir, patterns) {
   return null;
 }
 function getRepoDefinedScripts(workingDir, scripts) {
-  const packageJsonPath = path31.join(workingDir, "package.json");
+  const packageJsonPath = path30.join(workingDir, "package.json");
   if (!fs15.existsSync(packageJsonPath)) {
     return [];
   }
@@ -63000,7 +62697,7 @@ function findAllBuildFiles(workingDir) {
         const regex = simpleGlobToRegex(pattern);
         findFilesRecursive(workingDir, regex, allBuildFiles);
       } else {
-        const filePath = path31.join(workingDir, pattern);
+        const filePath = path30.join(workingDir, pattern);
         if (fs15.existsSync(filePath)) {
           allBuildFiles.add(filePath);
         }
@@ -63013,7 +62710,7 @@ function findFilesRecursive(dir, regex, results) {
   try {
     const entries = fs15.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path31.join(dir, entry.name);
+      const fullPath = path30.join(dir, entry.name);
       if (entry.isDirectory() && !["node_modules", ".git", "dist", "build", "target"].includes(entry.name)) {
         findFilesRecursive(fullPath, regex, results);
       } else if (entry.isFile() && regex.test(entry.name)) {
@@ -63036,7 +62733,7 @@ async function discoverBuildCommandsFromProfiles(workingDir) {
     let foundCommand = false;
     for (const cmd of sortedCommands) {
       if (cmd.detectFile) {
-        const detectFilePath = path31.join(workingDir, cmd.detectFile);
+        const detectFilePath = path30.join(workingDir, cmd.detectFile);
         if (!fs15.existsSync(detectFilePath)) {
           continue;
         }
@@ -63282,7 +62979,7 @@ __export(exports_tool_doctor, {
   getBinaryReadinessAdvisory: () => getBinaryReadinessAdvisory
 });
 import * as fs16 from "node:fs";
-import * as path32 from "node:path";
+import * as path31 from "node:path";
 function extractRegisteredToolKeys(indexPath) {
   const registeredKeys = new Set;
   try {
@@ -63349,8 +63046,8 @@ function getBinaryReadinessAdvisory() {
 }
 function runToolDoctor(_directory, pluginRoot) {
   const findings = [];
-  const resolvedPluginRoot = pluginRoot ?? path32.resolve(import.meta.dir, "..", "..");
-  const indexPath = path32.join(resolvedPluginRoot, "src", "index.ts");
+  const resolvedPluginRoot = pluginRoot ?? path31.resolve(import.meta.dir, "..", "..");
+  const indexPath = path31.join(resolvedPluginRoot, "src", "index.ts");
   if (!fs16.existsSync(indexPath)) {
     return {
       findings: [
@@ -64096,12 +63793,12 @@ var init_export = __esm(() => {
 
 // src/full-auto/state.ts
 import * as fs17 from "node:fs";
-import * as path33 from "node:path";
+import * as path32 from "node:path";
 function nowISO() {
   return new Date().toISOString();
 }
 function ensureSwarmDir(directory) {
-  const swarmDir = path33.resolve(directory, ".swarm");
+  const swarmDir = path32.resolve(directory, ".swarm");
   if (!fs17.existsSync(swarmDir)) {
     fs17.mkdirSync(swarmDir, { recursive: true });
   }
@@ -64916,7 +64613,7 @@ var init_handoff_service = __esm(() => {
 
 // src/session/snapshot-writer.ts
 import { closeSync as closeSync3, fsyncSync as fsyncSync2, mkdirSync as mkdirSync13, openSync as openSync3, renameSync as renameSync9 } from "node:fs";
-import * as path34 from "node:path";
+import * as path33 from "node:path";
 function serializeAgentSession(s) {
   const gateLog = {};
   const rawGateLog = s.gateLog ?? new Map;
@@ -65013,7 +64710,7 @@ async function writeSnapshot(directory, state) {
     }
     const content = JSON.stringify(snapshot, null, 2);
     const resolvedPath = validateSwarmPath(directory, "session/state.json");
-    const dir = path34.dirname(resolvedPath);
+    const dir = path33.dirname(resolvedPath);
     mkdirSync13(dir, { recursive: true });
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await bunWrite(tempPath, content);
@@ -65470,9 +65167,9 @@ var init_issue = __esm(() => {
 
 // src/hooks/knowledge-migrator.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { existsSync as existsSync21, readFileSync as readFileSync13 } from "node:fs";
-import { mkdir as mkdir9, readFile as readFile10, writeFile as writeFile9 } from "node:fs/promises";
-import * as path35 from "node:path";
+import { existsSync as existsSync20, readFileSync as readFileSync13 } from "node:fs";
+import { mkdir as mkdir8, readFile as readFile9, writeFile as writeFile8 } from "node:fs/promises";
+import * as path34 from "node:path";
 async function migrateKnowledgeToExternal(_directory, _config) {
   return {
     migrated: false,
@@ -65483,10 +65180,10 @@ async function migrateKnowledgeToExternal(_directory, _config) {
   };
 }
 async function migrateContextToKnowledge(directory, config3) {
-  const sentinelPath = path35.join(directory, ".swarm", ".knowledge-migrated");
-  const contextPath = path35.join(directory, ".swarm", "context.md");
+  const sentinelPath = path34.join(directory, ".swarm", ".knowledge-migrated");
+  const contextPath = path34.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
-  if (existsSync21(sentinelPath)) {
+  if (existsSync20(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -65495,7 +65192,7 @@ async function migrateContextToKnowledge(directory, config3) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync21(contextPath)) {
+  if (!existsSync20(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -65504,7 +65201,7 @@ async function migrateContextToKnowledge(directory, config3) {
       skippedReason: "no-context-file"
     };
   }
-  const contextContent = await readFile10(contextPath, "utf-8");
+  const contextContent = await readFile9(contextPath, "utf-8");
   if (contextContent.trim().length === 0) {
     return {
       migrated: false,
@@ -65680,8 +65377,8 @@ function truncateLesson(text) {
   return `${text.slice(0, 277)}...`;
 }
 function inferProjectName(directory) {
-  const packageJsonPath = path35.join(directory, "package.json");
-  if (existsSync21(packageJsonPath)) {
+  const packageJsonPath = path34.join(directory, "package.json");
+  if (existsSync20(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync13(packageJsonPath, "utf-8"));
       if (pkg.name && typeof pkg.name === "string") {
@@ -65689,7 +65386,7 @@ function inferProjectName(directory) {
       }
     } catch {}
   }
-  return path35.basename(directory);
+  return path34.basename(directory);
 }
 async function writeSentinel(sentinelPath, migrated, dropped) {
   const sentinel = {
@@ -65701,8 +65398,8 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await mkdir9(path35.dirname(sentinelPath), { recursive: true });
-  await writeFile9(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
+  await mkdir8(path34.dirname(sentinelPath), { recursive: true });
+  await writeFile8(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 var _internals23;
 var init_knowledge_migrator = __esm(() => {
@@ -65723,7 +65420,7 @@ var init_knowledge_migrator = __esm(() => {
 });
 
 // src/commands/knowledge.ts
-import { join as join32 } from "node:path";
+import { join as join31 } from "node:path";
 function resolveEntryByPrefix(entries, inputId) {
   const exact = entries.find((e) => e.id === inputId);
   if (exact)
@@ -65774,7 +65471,7 @@ async function handleKnowledgeRestoreCommand(directory, args2) {
     return "Invalid entry ID. IDs must be 1-64 characters: letters, digits, hyphens, underscores only.";
   }
   try {
-    const quarantinePath = join32(directory, ".swarm", "knowledge-quarantined.jsonl");
+    const quarantinePath = join31(directory, ".swarm", "knowledge-quarantined.jsonl");
     const entries = await readKnowledge(quarantinePath);
     const resolved = resolveEntryByPrefix(entries, inputId);
     if ("error" in resolved) {
@@ -66198,7 +65895,7 @@ var init_pr_review = __esm(() => {
 
 // src/utils/path-security.ts
 import * as fs18 from "node:fs";
-import * as path36 from "node:path";
+import * as path35 from "node:path";
 function containsPathTraversal(str) {
   if (/\.\.[/\\]/.test(str))
     return true;
@@ -66249,17 +65946,17 @@ function validateSymlinkBoundary(targetPath, rootPath) {
   try {
     realTarget = fs18.realpathSync(targetPath);
   } catch {
-    realTarget = path36.normalize(targetPath);
+    realTarget = path35.normalize(targetPath);
   }
   let realRoot;
   try {
     realRoot = fs18.realpathSync(rootPath);
   } catch {
-    realRoot = path36.normalize(rootPath);
+    realRoot = path35.normalize(rootPath);
   }
-  const normalizedTarget = path36.normalize(realTarget);
-  const normalizedRoot = path36.normalize(realRoot);
-  if (!normalizedTarget.startsWith(normalizedRoot + path36.sep) && normalizedTarget !== normalizedRoot) {
+  const normalizedTarget = path35.normalize(realTarget);
+  const normalizedRoot = path35.normalize(realRoot);
+  if (!normalizedTarget.startsWith(normalizedRoot + path35.sep) && normalizedTarget !== normalizedRoot) {
     throw new Error(`Symlink resolution escaped boundary: ${realTarget} is not within ${realRoot}`);
   }
 }
@@ -66267,7 +65964,7 @@ var init_path_security = () => {};
 
 // src/tools/lint.ts
 import * as fs19 from "node:fs";
-import * as path37 from "node:path";
+import * as path36 from "node:path";
 function validateArgs(args2) {
   if (typeof args2 !== "object" || args2 === null)
     return false;
@@ -66278,9 +65975,9 @@ function validateArgs(args2) {
 }
 function getLinterCommand(linter, mode, projectDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path37.join(projectDir, "node_modules", ".bin");
-  const biomeBin = isWindows ? path37.join(binDir, "biome.EXE") : path37.join(binDir, "biome");
-  const eslintBin = isWindows ? path37.join(binDir, "eslint.cmd") : path37.join(binDir, "eslint");
+  const binDir = path36.join(projectDir, "node_modules", ".bin");
+  const biomeBin = isWindows ? path36.join(binDir, "biome.EXE") : path36.join(binDir, "biome");
+  const eslintBin = isWindows ? path36.join(binDir, "eslint.cmd") : path36.join(binDir, "eslint");
   switch (linter) {
     case "biome":
       if (mode === "fix") {
@@ -66296,7 +65993,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs19.existsSync(path37.join(cwd, gradlewName)) ? path37.join(cwd, gradlewName) : null;
+  const gradlew = fs19.existsSync(path36.join(cwd, gradlewName)) ? path36.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -66330,10 +66027,10 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs19.existsSync(path37.join(cwd, "ruff.toml")))
+  if (fs19.existsSync(path36.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
-    const pyproject = path37.join(cwd, "pyproject.toml");
+    const pyproject = path36.join(cwd, "pyproject.toml");
     if (fs19.existsSync(pyproject)) {
       const content = fs19.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
@@ -66343,19 +66040,19 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs19.existsSync(path37.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs19.existsSync(path36.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs19.existsSync(path37.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs19.existsSync(path36.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function detectCheckstyle(cwd) {
-  const hasMaven = fs19.existsSync(path37.join(cwd, "pom.xml"));
-  const hasGradle = fs19.existsSync(path37.join(cwd, "build.gradle")) || fs19.existsSync(path37.join(cwd, "build.gradle.kts"));
-  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs19.existsSync(path37.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
+  const hasMaven = fs19.existsSync(path36.join(cwd, "pom.xml"));
+  const hasGradle = fs19.existsSync(path36.join(cwd, "build.gradle")) || fs19.existsSync(path36.join(cwd, "build.gradle.kts"));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs19.existsSync(path36.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradle) && hasBinary;
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs19.existsSync(path37.join(cwd, "build.gradle.kts")) || fs19.existsSync(path37.join(cwd, "build.gradle")) || (() => {
+  const hasKotlin = fs19.existsSync(path36.join(cwd, "build.gradle.kts")) || fs19.existsSync(path36.join(cwd, "build.gradle")) || (() => {
     try {
       return fs19.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
     } catch {
@@ -66374,11 +66071,11 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs19.existsSync(path37.join(cwd, "CMakeLists.txt"))) {
+  if (fs19.existsSync(path36.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
-    const dirsToCheck = [cwd, path37.join(cwd, "src")];
+    const dirsToCheck = [cwd, path36.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
         return fs19.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
@@ -66392,13 +66089,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs19.existsSync(path37.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs19.existsSync(path36.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs19.existsSync(path37.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs19.existsSync(path36.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  return (fs19.existsSync(path37.join(cwd, "Gemfile")) || fs19.existsSync(path37.join(cwd, "gems.rb")) || fs19.existsSync(path37.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
+  return (fs19.existsSync(path36.join(cwd, "Gemfile")) || fs19.existsSync(path36.join(cwd, "gems.rb")) || fs19.existsSync(path36.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -66426,10 +66123,10 @@ function detectAdditionalLinter(cwd) {
 function resolveLinterBinPath(linter, projectDir) {
   const isWindows = process.platform === "win32";
   const binName = linter === "biome" ? isWindows ? "biome.EXE" : "biome" : isWindows ? "eslint.cmd" : "eslint";
-  const localBin = path37.join(projectDir, "node_modules", ".bin", binName);
+  const localBin = path36.join(projectDir, "node_modules", ".bin", binName);
   if (fs19.existsSync(localBin))
     return localBin;
-  const ancestor = findBinInAncestors(path37.dirname(projectDir), binName);
+  const ancestor = findBinInAncestors(path36.dirname(projectDir), binName);
   if (ancestor)
     return ancestor;
   const fromPath = findBinInEnvPath(binName);
@@ -66440,10 +66137,10 @@ function resolveLinterBinPath(linter, projectDir) {
 function findBinInAncestors(startDir, binName) {
   let dir = startDir;
   while (true) {
-    const candidate = path37.join(dir, "node_modules", ".bin", binName);
+    const candidate = path36.join(dir, "node_modules", ".bin", binName);
     if (fs19.existsSync(candidate))
       return candidate;
-    const parent = path37.dirname(dir);
+    const parent = path36.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -66452,10 +66149,10 @@ function findBinInAncestors(startDir, binName) {
 }
 function findBinInEnvPath(binName) {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path37.delimiter)) {
+  for (const dir of searchPath.split(path36.delimiter)) {
     if (!dir)
       continue;
-    const candidate = path37.join(dir, binName);
+    const candidate = path36.join(dir, binName);
     if (fs19.existsSync(candidate))
       return candidate;
   }
@@ -66468,13 +66165,13 @@ async function detectAvailableLinter(directory) {
     return null;
   const projectDir = directory;
   const isWindows = process.platform === "win32";
-  const biomeBin = isWindows ? path37.join(projectDir, "node_modules", ".bin", "biome.EXE") : path37.join(projectDir, "node_modules", ".bin", "biome");
-  const eslintBin = isWindows ? path37.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path37.join(projectDir, "node_modules", ".bin", "eslint");
+  const biomeBin = isWindows ? path36.join(projectDir, "node_modules", ".bin", "biome.EXE") : path36.join(projectDir, "node_modules", ".bin", "biome");
+  const eslintBin = isWindows ? path36.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path36.join(projectDir, "node_modules", ".bin", "eslint");
   const localResult = await _detectAvailableLinter(projectDir, biomeBin, eslintBin);
   if (localResult)
     return localResult;
-  const biomeAncestor = findBinInAncestors(path37.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
-  const eslintAncestor = findBinInAncestors(path37.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
+  const biomeAncestor = findBinInAncestors(path36.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
+  const eslintAncestor = findBinInAncestors(path36.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
   if (biomeAncestor || eslintAncestor) {
     return _detectAvailableLinter(projectDir, biomeAncestor ?? biomeBin, eslintAncestor ?? eslintBin);
   }
@@ -66697,7 +66394,7 @@ For Rust: rustup component add clippy`
 
 // src/tools/secretscan.ts
 import * as fs20 from "node:fs";
-import * as path38 from "node:path";
+import * as path37 from "node:path";
 function calculateShannonEntropy(str) {
   if (str.length === 0)
     return 0;
@@ -66745,7 +66442,7 @@ function isGlobOrPathPattern(pattern) {
   return pattern.includes("/") || pattern.includes("\\") || /[*?[\]{}]/.test(pattern);
 }
 function loadSecretScanIgnore(scanDir) {
-  const ignorePath = path38.join(scanDir, ".secretscanignore");
+  const ignorePath = path37.join(scanDir, ".secretscanignore");
   try {
     if (!fs20.existsSync(ignorePath))
       return [];
@@ -66768,7 +66465,7 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   if (exactNames.has(entry))
     return true;
   for (const pattern of globPatterns) {
-    if (path38.matchesGlob(relPath, pattern))
+    if (path37.matchesGlob(relPath, pattern))
       return true;
   }
   return false;
@@ -66789,7 +66486,7 @@ function validateDirectoryInput(dir) {
   return null;
 }
 function isBinaryFile(filePath, buffer) {
-  const ext = path38.extname(filePath).toLowerCase();
+  const ext = path37.extname(filePath).toLowerCase();
   if (DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
     return true;
   }
@@ -66925,9 +66622,9 @@ function isSymlinkLoop(realPath, visited) {
   return false;
 }
 function isPathWithinScope(realPath, scanDir) {
-  const resolvedScanDir = path38.resolve(scanDir);
-  const resolvedRealPath = path38.resolve(realPath);
-  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path38.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
+  const resolvedScanDir = path37.resolve(scanDir);
+  const resolvedRealPath = path37.resolve(realPath);
+  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path37.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
 }
 function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, stats = {
   skippedDirs: 0,
@@ -66953,8 +66650,8 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     return a.localeCompare(b);
   });
   for (const entry of entries) {
-    const fullPath = path38.join(dir, entry);
-    const relPath = path38.relative(scanDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path37.join(dir, entry);
+    const relPath = path37.relative(scanDir, fullPath).replace(/\\/g, "/");
     if (isExcluded(entry, relPath, excludeExact, excludeGlobs)) {
       stats.skippedDirs++;
       continue;
@@ -66989,7 +66686,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
       const subFiles = findScannableFiles(fullPath, excludeExact, excludeGlobs, scanDir, visited, stats);
       files.push(...subFiles);
     } else if (lstat.isFile()) {
-      const ext = path38.extname(fullPath).toLowerCase();
+      const ext = path37.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
       } else {
@@ -67249,7 +66946,7 @@ var init_secretscan = __esm(() => {
         }
       }
       try {
-        const _scanDirRaw = path38.resolve(directory);
+        const _scanDirRaw = path37.resolve(directory);
         const scanDir = (() => {
           try {
             return fs20.realpathSync(_scanDirRaw);
@@ -67396,7 +67093,7 @@ var init_secretscan = __esm(() => {
 
 // src/lang/default-backend.ts
 import * as fs21 from "node:fs";
-import * as path39 from "node:path";
+import * as path38 from "node:path";
 function detectFileExists(dir, pattern) {
   if (pattern.includes("*") || pattern.includes("?")) {
     try {
@@ -67408,7 +67105,7 @@ function detectFileExists(dir, pattern) {
     }
   }
   try {
-    fs21.accessSync(path39.join(dir, pattern));
+    fs21.accessSync(path38.join(dir, pattern));
     return true;
   } catch {
     return false;
@@ -67536,8 +67233,8 @@ function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs21.existsSync(path39.join(dir, "gradlew.bat"));
-      const hasGradlew = fs21.existsSync(path39.join(dir, "gradlew"));
+      const hasGradlewBat = fs21.existsSync(path38.join(dir, "gradlew.bat"));
+      const hasGradlew = fs21.existsSync(path38.join(dir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -67554,7 +67251,7 @@ function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs21.existsSync(path39.join(dir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs21.existsSync(path38.join(dir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -67841,17 +67538,17 @@ async function defaultSelectBuildCommand(profile, dir) {
   return null;
 }
 async function defaultTestFilesFor(profile, sourceFile, dir) {
-  const ext = path39.extname(sourceFile);
+  const ext = path38.extname(sourceFile);
   if (!profile.extensions.includes(ext))
     return [];
-  const base = path39.basename(sourceFile, ext);
-  const rel = path39.relative(dir, sourceFile);
-  const relDir = path39.dirname(rel);
+  const base = path38.basename(sourceFile, ext);
+  const rel = path38.relative(dir, sourceFile);
+  const relDir = path38.dirname(rel);
   const stripSrc = relDir.replace(/^src(\/|\\)/, "");
   const candidates = new Set;
   for (const tDir of ["tests", "test", "__tests__", "spec"]) {
     for (const suffix of ["", "_test", ".test", "_spec", ".spec"]) {
-      candidates.add(path39.join(dir, tDir, stripSrc, `${base}${suffix}${ext}`));
+      candidates.add(path38.join(dir, tDir, stripSrc, `${base}${suffix}${ext}`));
     }
   }
   const existing = [];
@@ -67892,7 +67589,7 @@ var init_default_backend = __esm(() => {
 
 // src/lang/backends/go.ts
 import * as fs22 from "node:fs";
-import * as path40 from "node:path";
+import * as path39 from "node:path";
 function extractImports(_sourceFile, source) {
   const out2 = new Set;
   IMPORT_REGEX_SINGLE.lastIndex = 0;
@@ -67918,7 +67615,7 @@ function extractImports(_sourceFile, source) {
 async function selectFramework(dir) {
   let content;
   try {
-    content = fs22.readFileSync(path40.join(dir, "go.mod"), "utf-8");
+    content = fs22.readFileSync(path39.join(dir, "go.mod"), "utf-8");
   } catch {
     return null;
   }
@@ -67939,16 +67636,16 @@ async function selectFramework(dir) {
 async function selectEntryPoints(dir) {
   const points = [];
   try {
-    fs22.accessSync(path40.join(dir, "main.go"));
+    fs22.accessSync(path39.join(dir, "main.go"));
     points.push("main.go");
   } catch {}
   try {
-    const cmdDir = path40.join(dir, "cmd");
+    const cmdDir = path39.join(dir, "cmd");
     const subdirs = fs22.readdirSync(cmdDir, { withFileTypes: true }).filter((d) => d.isDirectory());
     for (const sub of subdirs) {
-      const main = path40.join("cmd", sub.name, "main.go");
+      const main = path39.join("cmd", sub.name, "main.go");
       try {
-        fs22.accessSync(path40.join(dir, main));
+        fs22.accessSync(path39.join(dir, main));
         points.push(main);
       } catch {}
     }
@@ -67979,7 +67676,7 @@ var init_go = __esm(() => {
 
 // src/lang/backends/python.ts
 import * as fs23 from "node:fs";
-import * as path41 from "node:path";
+import * as path40 from "node:path";
 function parseImportTargets(rawTargets) {
   const cleaned = rawTargets.replace(/[()]/g, "").split(`
 `).map((line) => line.replace(/#.*$/, "").replace(/\\\s*$/, "")).join(" ");
@@ -68039,7 +67736,7 @@ async function selectFramework2(dir) {
   ];
   for (const candidate of ["pyproject.toml", "requirements.txt", "setup.py"]) {
     try {
-      const content = fs23.readFileSync(path41.join(dir, candidate), "utf-8");
+      const content = fs23.readFileSync(path40.join(dir, candidate), "utf-8");
       const lower = content.toLowerCase();
       for (const [pkg, name2] of candidates) {
         if (lower.includes(pkg)) {
@@ -68053,7 +67750,7 @@ async function selectFramework2(dir) {
 async function selectEntryPoints2(dir) {
   const points = new Set;
   try {
-    const content = fs23.readFileSync(path41.join(dir, "pyproject.toml"), "utf-8");
+    const content = fs23.readFileSync(path40.join(dir, "pyproject.toml"), "utf-8");
     const scriptsBlock = content.match(/\[project\.scripts\][\s\S]*?(?=\n\[|$)/);
     if (scriptsBlock) {
       for (const line of scriptsBlock[0].split(`
@@ -68068,7 +67765,7 @@ async function selectEntryPoints2(dir) {
   } catch {}
   for (const name2 of ["manage.py", "main.py", "app.py", "__main__.py"]) {
     try {
-      fs23.accessSync(path41.join(dir, name2));
+      fs23.accessSync(path40.join(dir, name2));
       points.add(name2);
     } catch {}
   }
@@ -68097,7 +67794,7 @@ var init_python = __esm(() => {
 
 // src/test-impact/analyzer.ts
 import fs24 from "node:fs";
-import path42 from "node:path";
+import path41 from "node:path";
 function normalizePath(p) {
   return p.replace(/\\/g, "/");
 }
@@ -68118,8 +67815,8 @@ function resolveRelativeImport(fromDir, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const resolved = path42.resolve(fromDir, importPath);
-  if (path42.extname(resolved)) {
+  const resolved = path41.resolve(fromDir, importPath);
+  if (path41.extname(resolved)) {
     if (fs24.existsSync(resolved) && fs24.statSync(resolved).isFile()) {
       return normalizePath(resolved);
     }
@@ -68139,20 +67836,20 @@ function resolvePythonImport(fromDir, module2) {
   const leadingDots = module2.match(/^\.+/)?.[0].length ?? 0;
   let baseDir = fromDir;
   for (let i2 = 1;i2 < leadingDots; i2++) {
-    baseDir = path42.dirname(baseDir);
+    baseDir = path41.dirname(baseDir);
   }
   const rest = module2.slice(leadingDots);
   if (rest.length === 0) {
-    const initPath = path42.join(baseDir, "__init__.py");
+    const initPath = path41.join(baseDir, "__init__.py");
     if (fs24.existsSync(initPath) && fs24.statSync(initPath).isFile()) {
       return normalizePath(initPath);
     }
     return null;
   }
-  const subpath = rest.replace(/\./g, path42.sep);
+  const subpath = rest.replace(/\./g, path41.sep);
   const candidates = [
-    `${path42.join(baseDir, subpath)}.py`,
-    path42.join(baseDir, subpath, "__init__.py")
+    `${path41.join(baseDir, subpath)}.py`,
+    path41.join(baseDir, subpath, "__init__.py")
   ];
   for (const c of candidates) {
     if (fs24.existsSync(c) && fs24.statSync(c).isFile())
@@ -68161,7 +67858,7 @@ function resolvePythonImport(fromDir, module2) {
   return null;
 }
 function findGoModule(fromDir) {
-  const resolved = path42.resolve(fromDir);
+  const resolved = path41.resolve(fromDir);
   let cur = resolved;
   const walked = [];
   for (let i2 = 0;i2 < 16; i2++) {
@@ -68173,7 +67870,7 @@ function findGoModule(fromDir) {
     }
     walked.push(cur);
     try {
-      const goMod = path42.join(cur, "go.mod");
+      const goMod = path41.join(cur, "go.mod");
       const content = fs24.readFileSync(goMod, "utf-8");
       const moduleMatch = content.match(/^\s*module\s+"?([^"\s/]+(?:\/[^"\s]+)*)"?/m);
       if (moduleMatch) {
@@ -68184,10 +67881,10 @@ function findGoModule(fromDir) {
       }
     } catch {}
     try {
-      fs24.accessSync(path42.join(cur, ".git"));
+      fs24.accessSync(path41.join(cur, ".git"));
       break;
     } catch {}
-    const parent = path42.dirname(cur);
+    const parent = path41.dirname(cur);
     if (parent === cur)
       break;
     cur = parent;
@@ -68199,12 +67896,12 @@ function findGoModule(fromDir) {
 function resolveGoImport(fromDir, importPath) {
   let dir = null;
   if (importPath.startsWith(".")) {
-    dir = path42.resolve(fromDir, importPath);
+    dir = path41.resolve(fromDir, importPath);
   } else {
     const mod = findGoModule(fromDir);
     if (mod && (importPath === mod.modulePath || importPath.startsWith(`${mod.modulePath}/`))) {
       const subpath = importPath.slice(mod.modulePath.length);
-      dir = path42.join(mod.moduleRoot, subpath);
+      dir = path41.join(mod.moduleRoot, subpath);
     }
   }
   if (dir === null)
@@ -68212,7 +67909,7 @@ function resolveGoImport(fromDir, importPath) {
   if (!fs24.existsSync(dir) || !fs24.statSync(dir).isDirectory())
     return [];
   try {
-    return fs24.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath(path42.join(dir, f)));
+    return fs24.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath(path41.join(dir, f)));
   } catch {
     return [];
   }
@@ -68251,15 +67948,15 @@ function findTestFilesSync(cwd) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) {
-          walk(path42.join(dir, entry.name), visitedInodes);
+          walk(path41.join(dir, entry.name), visitedInodes);
         }
       } else if (entry.isFile()) {
         const name2 = entry.name;
         const isTsTest = /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(name2) || dir.includes("__tests__") && /\.(ts|tsx|js|jsx)$/.test(name2);
-        const isPyTest = /^test_.+\.py$/.test(name2) || /.+_test\.py$/.test(name2) || dir.includes(`${path42.sep}tests${path42.sep}`) && name2.endsWith(".py");
+        const isPyTest = /^test_.+\.py$/.test(name2) || /.+_test\.py$/.test(name2) || dir.includes(`${path41.sep}tests${path41.sep}`) && name2.endsWith(".py");
         const isGoTest = /.+_test\.go$/.test(name2);
         if (isTsTest || isPyTest || isGoTest) {
-          testFiles.push(normalizePath(path42.join(dir, entry.name)));
+          testFiles.push(normalizePath(path41.join(dir, entry.name)));
         }
       }
     }
@@ -68284,8 +67981,8 @@ function extractImports3(content) {
   ];
 }
 function addImpactEdgesForTestFile(testFile, content, impactMap) {
-  const ext = path42.extname(testFile).toLowerCase();
-  const testDir = path42.dirname(testFile);
+  const ext = path41.extname(testFile).toLowerCase();
+  const testDir = path41.dirname(testFile);
   function addEdge(source) {
     if (!impactMap[source])
       impactMap[source] = [];
@@ -68344,7 +68041,7 @@ async function buildImpactMap(cwd) {
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
-  const cachePath = path42.join(cwd, ".swarm", "cache", "impact-map.json");
+  const cachePath = path41.join(cwd, ".swarm", "cache", "impact-map.json");
   if (fs24.existsSync(cachePath)) {
     try {
       const content = fs24.readFileSync(cachePath, "utf-8");
@@ -68377,12 +68074,12 @@ async function loadImpactMap(cwd, options) {
   return _internals29.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
-  if (!path42.isAbsolute(cwd)) {
+  if (!path41.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
   _internals29.validateProjectRoot(cwd);
-  const cacheDir2 = path42.join(cwd, ".swarm", "cache");
-  const cachePath = path42.join(cacheDir2, "impact-map.json");
+  const cacheDir2 = path41.join(cwd, ".swarm", "cache");
+  const cachePath = path41.join(cacheDir2, "impact-map.json");
   if (!fs24.existsSync(cacheDir2)) {
     fs24.mkdirSync(cacheDir2, { recursive: true });
   }
@@ -68414,7 +68111,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       budgetExceeded = true;
       break;
     }
-    const normalizedChanged = normalizePath(path42.resolve(changedFile));
+    const normalizedChanged = normalizePath(path41.resolve(changedFile));
     const tests = impactMap[normalizedChanged];
     if (tests && tests.length > 0) {
       for (const test of tests) {
@@ -68707,15 +68404,15 @@ var FLAKY_THRESHOLD = 0.3, MIN_RUNS_FOR_QUARANTINE = 5, MAX_HISTORY_RUNS = 20;
 
 // src/test-impact/history-store.ts
 import fs25 from "node:fs";
-import path43 from "node:path";
+import path42 from "node:path";
 function getHistoryPath(workingDir) {
   if (!workingDir) {
     throw new Error("getHistoryPath requires a working directory — project root must be provided by the caller");
   }
-  if (!path43.isAbsolute(workingDir)) {
+  if (!path42.isAbsolute(workingDir)) {
     throw new Error(`getHistoryPath requires an absolute project root path, got: "${workingDir}"`);
   }
-  return path43.join(workingDir, ".swarm", "cache", "test-history.jsonl");
+  return path42.join(workingDir, ".swarm", "cache", "test-history.jsonl");
 }
 function sanitizeErrorMessage(errorMessage) {
   if (errorMessage === undefined) {
@@ -68802,7 +68499,7 @@ function batchAppendTestRuns(records, workingDir) {
     }
   }
   const historyPath = getHistoryPath(workingDir);
-  const historyDir = path43.dirname(historyPath);
+  const historyDir = path42.dirname(historyPath);
   _internals30.validateProjectRoot(workingDir);
   if (!fs25.existsSync(historyDir)) {
     fs25.mkdirSync(historyDir, { recursive: true });
@@ -68898,7 +68595,7 @@ var init_history_store = __esm(() => {
 
 // src/tools/resolve-working-directory.ts
 import * as fs26 from "node:fs";
-import * as path44 from "node:path";
+import * as path43 from "node:path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     return { success: true, directory: fallbackDirectory };
@@ -68918,15 +68615,15 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       };
     }
   }
-  const normalizedDir = path44.normalize(workingDirectory);
-  const pathParts = normalizedDir.split(path44.sep);
+  const normalizedDir = path43.normalize(workingDirectory);
+  const pathParts = normalizedDir.split(path43.sep);
   if (pathParts.includes("..")) {
     return {
       success: false,
       message: "Invalid working_directory: path traversal sequences (..) are not allowed"
     };
   }
-  const resolvedDir = path44.resolve(normalizedDir);
+  const resolvedDir = path43.resolve(normalizedDir);
   let statResult;
   try {
     statResult = fs26.statSync(resolvedDir);
@@ -68942,7 +68639,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       message: `Invalid working_directory: path "${resolvedDir}" is not a directory`
     };
   }
-  const resolvedFallback = path44.resolve(fallbackDirectory);
+  const resolvedFallback = path43.resolve(fallbackDirectory);
   let fallbackExists = false;
   try {
     fs26.statSync(resolvedFallback);
@@ -68952,7 +68649,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   }
   if (workingDirectory != null && workingDirectory !== "") {
     if (fallbackExists) {
-      const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path44.sep);
+      const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path43.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -69007,10 +68704,10 @@ var init_registry_backend = __esm(() => {
 
 // src/lang/backends/typescript.ts
 import * as fs27 from "node:fs";
-import * as path45 from "node:path";
+import * as path44 from "node:path";
 function readPackageJsonRaw(dir) {
   try {
-    const content = fs27.readFileSync(path45.join(dir, "package.json"), "utf-8");
+    const content = fs27.readFileSync(path44.join(dir, "package.json"), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -69230,7 +68927,7 @@ __export(exports_dispatch, {
   _internals: () => _internals32
 });
 import * as fs28 from "node:fs";
-import * as path46 from "node:path";
+import * as path45 from "node:path";
 function safeReaddirSet(dir) {
   try {
     return new Set(fs28.readdirSync(dir));
@@ -69247,14 +68944,14 @@ function manifestHash(dir) {
     if (!entries.has(name2))
       continue;
     try {
-      const stat4 = fs28.statSync(path46.join(dir, name2));
+      const stat4 = fs28.statSync(path45.join(dir, name2));
       parts2.push(`${name2}:${stat4.size}:${stat4.mtimeMs}:${stat4.ino}`);
     } catch {}
   }
   return parts2.join("|");
 }
 function findManifestRoot(start2) {
-  const resolved = path46.resolve(start2);
+  const resolved = path45.resolve(start2);
   const cached3 = manifestRootCache.get(resolved);
   if (cached3 !== undefined)
     return cached3;
@@ -69273,7 +68970,7 @@ function findManifestRoot(start2) {
         return cur;
       }
     }
-    const parent = path46.dirname(cur);
+    const parent = path45.dirname(cur);
     if (parent === cur)
       break;
     cur = parent;
@@ -69383,13 +69080,13 @@ var init_dispatch = __esm(() => {
 
 // src/tools/test-runner.ts
 import * as fs29 from "node:fs";
-import * as path47 from "node:path";
+import * as path46 from "node:path";
 async function estimateFanOut(sourceFiles, cwd) {
   try {
     const impactMap = await loadImpactMap(cwd, { skipRebuild: true });
     const uniqueTestFiles = new Set;
     for (const sourceFile of sourceFiles) {
-      const resolvedPath = path47.resolve(cwd, sourceFile);
+      const resolvedPath = path46.resolve(cwd, sourceFile);
       const normalizedPath = resolvedPath.replace(/\\/g, "/");
       const testFiles = impactMap[normalizedPath];
       if (testFiles) {
@@ -69467,14 +69164,14 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs29.existsSync(path47.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs29.existsSync(path46.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs29.existsSync(path47.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs29.existsSync(path46.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = fs29.existsSync(path47.join(cwd, "build.gradle")) || fs29.existsSync(path47.join(cwd, "build.gradle.kts"));
-  const hasGradlew = fs29.existsSync(path47.join(cwd, "gradlew")) || fs29.existsSync(path47.join(cwd, "gradlew.bat"));
+  const hasBuildFile = fs29.existsSync(path46.join(cwd, "build.gradle")) || fs29.existsSync(path46.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs29.existsSync(path46.join(cwd, "gradlew")) || fs29.existsSync(path46.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
@@ -69487,25 +69184,25 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  const hasSource = fs29.existsSync(path47.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = fs29.existsSync(path47.join(cwd, "CMakeCache.txt")) || fs29.existsSync(path47.join(cwd, "build", "CMakeCache.txt"));
+  const hasSource = fs29.existsSync(path46.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs29.existsSync(path46.join(cwd, "CMakeCache.txt")) || fs29.existsSync(path46.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs29.existsSync(path47.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs29.existsSync(path46.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs29.existsSync(path47.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs29.existsSync(path46.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = fs29.existsSync(path47.join(cwd, ".rspec"));
-  const hasGemfile = fs29.existsSync(path47.join(cwd, "Gemfile"));
-  const hasSpecDir = fs29.existsSync(path47.join(cwd, "spec"));
+  const hasRSpecFile = fs29.existsSync(path46.join(cwd, ".rspec"));
+  const hasGemfile = fs29.existsSync(path46.join(cwd, "Gemfile"));
+  const hasSpecDir = fs29.existsSync(path46.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs29.existsSync(path47.join(cwd, "test")) && (fs29.existsSync(path47.join(cwd, "Gemfile")) || fs29.existsSync(path47.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs29.existsSync(path46.join(cwd, "test")) && (fs29.existsSync(path46.join(cwd, "Gemfile")) || fs29.existsSync(path46.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 async function detectTestFrameworkViaDispatch(cwd) {
   try {
@@ -69567,7 +69264,7 @@ async function parseTestOutputViaDispatch(framework, output, baseDir) {
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path47.join(baseDir, "package.json");
+    const packageJsonPath = path46.join(baseDir, "package.json");
     if (fs29.existsSync(packageJsonPath)) {
       const content = fs29.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
@@ -69588,16 +69285,16 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs29.existsSync(path47.join(baseDir, "bun.lockb")) || fs29.existsSync(path47.join(baseDir, "bun.lock"))) {
+      if (fs29.existsSync(path46.join(baseDir, "bun.lockb")) || fs29.existsSync(path46.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    const pyprojectTomlPath = path47.join(baseDir, "pyproject.toml");
-    const setupCfgPath = path47.join(baseDir, "setup.cfg");
-    const requirementsTxtPath = path47.join(baseDir, "requirements.txt");
+    const pyprojectTomlPath = path46.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path46.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path46.join(baseDir, "requirements.txt");
     if (fs29.existsSync(pyprojectTomlPath)) {
       const content = fs29.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
@@ -69617,7 +69314,7 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const cargoTomlPath = path47.join(baseDir, "Cargo.toml");
+    const cargoTomlPath = path46.join(baseDir, "Cargo.toml");
     if (fs29.existsSync(cargoTomlPath)) {
       const content = fs29.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
@@ -69628,9 +69325,9 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const pesterConfigPath = path47.join(baseDir, "pester.config.ps1");
-    const pesterConfigJsonPath = path47.join(baseDir, "pester.config.ps1.json");
-    const pesterPs1Path = path47.join(baseDir, "tests.ps1");
+    const pesterConfigPath = path46.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path46.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path46.join(baseDir, "tests.ps1");
     if (fs29.existsSync(pesterConfigPath) || fs29.existsSync(pesterConfigJsonPath) || fs29.existsSync(pesterPs1Path)) {
       return "pester";
     }
@@ -69659,12 +69356,12 @@ function isTestDirectoryPath(normalizedPath) {
   return normalizedPath.split("/").some((segment) => TEST_DIRECTORY_NAMES.includes(segment));
 }
 function resolveWorkspacePath(file3, workingDir) {
-  return path47.isAbsolute(file3) ? path47.resolve(file3) : path47.resolve(workingDir, file3);
+  return path46.isAbsolute(file3) ? path46.resolve(file3) : path46.resolve(workingDir, file3);
 }
 function toWorkspaceOutputPath(absolutePath, workingDir, preferRelative) {
   if (!preferRelative)
     return absolutePath;
-  return path47.relative(workingDir, absolutePath);
+  return path46.relative(workingDir, absolutePath);
 }
 function dedupePush(target, value) {
   if (!target.includes(value)) {
@@ -69701,18 +69398,18 @@ function buildLanguageSpecificTestNames(nameWithoutExt, ext) {
   }
 }
 function getRepoLevelCandidateDirectories(workingDir, relativePath, ext) {
-  const relativeDir = path47.dirname(relativePath);
+  const relativeDir = path46.dirname(relativePath);
   const nestedRelativeDir = relativeDir === "." ? "" : relativeDir;
   const directories = TEST_DIRECTORY_NAMES.flatMap((dirName) => {
-    const rootDir = path47.join(workingDir, dirName);
-    return nestedRelativeDir ? [rootDir, path47.join(rootDir, nestedRelativeDir)] : [rootDir];
+    const rootDir = path46.join(workingDir, dirName);
+    return nestedRelativeDir ? [rootDir, path46.join(rootDir, nestedRelativeDir)] : [rootDir];
   });
   const normalizedRelativePath = relativePath.replace(/\\/g, "/");
   if (ext === ".java" && normalizedRelativePath.startsWith("src/main/java/")) {
-    directories.push(path47.join(workingDir, "src/test/java", path47.dirname(normalizedRelativePath.slice("src/main/java/".length))));
+    directories.push(path46.join(workingDir, "src/test/java", path46.dirname(normalizedRelativePath.slice("src/main/java/".length))));
   }
   if ((ext === ".kt" || ext === ".java") && normalizedRelativePath.startsWith("src/main/kotlin/")) {
-    directories.push(path47.join(workingDir, "src/test/kotlin", path47.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
+    directories.push(path46.join(workingDir, "src/test/kotlin", path46.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
   }
   return [...new Set(directories)];
 }
@@ -69740,23 +69437,23 @@ function isLanguageSpecificTestFile(basename8) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename8 = path47.basename(filePath);
+  const basename8 = path46.basename(filePath);
   return hasCompoundTestExtension(basename8) || basename8.includes(".spec.") || basename8.includes(".test.") || isLanguageSpecificTestFile(basename8) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file3 of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file3, workingDir);
-    const relativeFile = path47.relative(workingDir, absoluteFile);
-    const basename8 = path47.basename(absoluteFile);
-    const dirname20 = path47.dirname(absoluteFile);
-    const preferRelativeOutput = !path47.isAbsolute(file3);
+    const relativeFile = path46.relative(workingDir, absoluteFile);
+    const basename8 = path46.basename(absoluteFile);
+    const dirname19 = path46.dirname(absoluteFile);
+    const preferRelativeOutput = !path46.isAbsolute(file3);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file3)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
     const nameWithoutExt = basename8.replace(/\.[^.]+$/, "");
-    const ext = path47.extname(basename8);
+    const ext = path46.extname(basename8);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -69765,7 +69462,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path47.join(dirname20, candidateName));
+    ].map((candidateName) => path46.join(dirname19, candidateName));
     const testDirectoryNames = [
       basename8,
       ...genericTestNames,
@@ -69774,8 +69471,8 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path47.join(dirname20, dirName, candidateName))),
-      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path47.join(candidateDir, candidateName)))
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path46.join(dirname19, dirName, candidateName))),
+      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path46.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
       if (fs29.existsSync(testFile)) {
@@ -69796,7 +69493,7 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
     try {
       const absoluteTestFile = resolveWorkspacePath(testFile, workingDir);
       const content = fs29.readFileSync(absoluteTestFile, "utf-8");
-      const testDir = path47.dirname(absoluteTestFile);
+      const testDir = path46.dirname(absoluteTestFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -69804,8 +69501,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path47.resolve(testDir, importPath);
-          const existingExt = path47.extname(resolvedImport);
+          resolvedImport = path46.resolve(testDir, importPath);
+          const existingExt = path46.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -69825,12 +69522,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         } else {
           continue;
         }
-        const importBasename = path47.basename(resolvedImport, path47.extname(resolvedImport));
-        const importDir = path47.dirname(resolvedImport);
+        const importBasename = path46.basename(resolvedImport, path46.extname(resolvedImport));
+        const importDir = path46.dirname(resolvedImport);
         for (const sourceFile of absoluteSourceFiles) {
-          const sourceDir = path47.dirname(sourceFile);
-          const sourceBasename = path47.basename(sourceFile, path47.extname(sourceFile));
-          const isRelatedDir = importDir === sourceDir || importDir === path47.join(sourceDir, "__tests__") || importDir === path47.join(sourceDir, "tests") || importDir === path47.join(sourceDir, "test") || importDir === path47.join(sourceDir, "spec");
+          const sourceDir = path46.dirname(sourceFile);
+          const sourceBasename = path46.basename(sourceFile, path46.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path46.join(sourceDir, "__tests__") || importDir === path46.join(sourceDir, "tests") || importDir === path46.join(sourceDir, "test") || importDir === path46.join(sourceDir, "spec");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             dedupePush(testFiles, testFile);
             break;
@@ -69843,8 +69540,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path47.resolve(testDir, importPath);
-          const existingExt = path47.extname(resolvedImport);
+          let resolvedImport = path46.resolve(testDir, importPath);
+          const existingExt = path46.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -69861,12 +69558,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               }
             }
           }
-          const importDir = path47.dirname(resolvedImport);
-          const importBasename = path47.basename(resolvedImport, path47.extname(resolvedImport));
+          const importDir = path46.dirname(resolvedImport);
+          const importBasename = path46.basename(resolvedImport, path46.extname(resolvedImport));
           for (const sourceFile of absoluteSourceFiles) {
-            const sourceDir = path47.dirname(sourceFile);
-            const sourceBasename = path47.basename(sourceFile, path47.extname(sourceFile));
-            const isRelatedDir = importDir === sourceDir || importDir === path47.join(sourceDir, "__tests__") || importDir === path47.join(sourceDir, "tests") || importDir === path47.join(sourceDir, "test") || importDir === path47.join(sourceDir, "spec");
+            const sourceDir = path46.dirname(sourceFile);
+            const sourceBasename = path46.basename(sourceFile, path46.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path46.join(sourceDir, "__tests__") || importDir === path46.join(sourceDir, "tests") || importDir === path46.join(sourceDir, "test") || importDir === path46.join(sourceDir, "spec");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               dedupePush(testFiles, testFile);
               break;
@@ -69976,8 +69673,8 @@ function buildTestCommand2(framework, scope, files, coverage, baseDir) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs29.existsSync(path47.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs29.existsSync(path47.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs29.existsSync(path46.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs29.existsSync(path46.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -69994,7 +69691,7 @@ function buildTestCommand2(framework, scope, files, coverage, baseDir) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs29.existsSync(path47.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs29.existsSync(path46.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -70426,11 +70123,11 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd) {
     };
   }
   const startTime = Date.now();
-  const vitestJsonOutputPath = framework === "vitest" ? path47.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
+  const vitestJsonOutputPath = framework === "vitest" ? path46.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
   try {
     if (vitestJsonOutputPath) {
       try {
-        fs29.mkdirSync(path47.dirname(vitestJsonOutputPath), { recursive: true });
+        fs29.mkdirSync(path46.dirname(vitestJsonOutputPath), { recursive: true });
         if (fs29.existsSync(vitestJsonOutputPath)) {
           fs29.unlinkSync(vitestJsonOutputPath);
         }
@@ -70546,10 +70243,10 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd) {
 }
 function normalizeHistoryTestFile(testFile, workingDir) {
   const normalized = testFile.replace(/\\/g, "/");
-  if (!path47.isAbsolute(testFile))
+  if (!path46.isAbsolute(testFile))
     return normalized;
-  const relative10 = path47.relative(workingDir, testFile);
-  if (relative10.startsWith("..") || path47.isAbsolute(relative10)) {
+  const relative10 = path46.relative(workingDir, testFile);
+  if (relative10.startsWith("..") || path46.isAbsolute(relative10)) {
     return normalized;
   }
   return relative10.replace(/\\/g, "/");
@@ -70887,7 +70584,7 @@ var init_test_runner = __esm(() => {
         const sourceFiles = args2.files.filter((file3) => {
           if (directTestFiles.includes(file3))
             return false;
-          const ext = path47.extname(file3).toLowerCase();
+          const ext = path46.extname(file3).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         const invalidFiles = args2.files.filter((file3) => !directTestFiles.includes(file3) && !sourceFiles.includes(file3));
@@ -70933,7 +70630,7 @@ var init_test_runner = __esm(() => {
           if (isConventionTestFilePath(f)) {
             return false;
           }
-          const ext = path47.extname(f).toLowerCase();
+          const ext = path46.extname(f).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         if (sourceFiles.length === 0) {
@@ -70983,7 +70680,7 @@ var init_test_runner = __esm(() => {
           if (isConventionTestFilePath(f)) {
             return false;
           }
-          const ext = path47.extname(f).toLowerCase();
+          const ext = path46.extname(f).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         if (sourceFiles.length === 0) {
@@ -71035,8 +70732,8 @@ var init_test_runner = __esm(() => {
           }
           if (impactResult.impactedTests.length > 0) {
             testFiles = impactResult.impactedTests.map((absPath) => {
-              const relativePath = path47.relative(workingDir, absPath);
-              return path47.isAbsolute(relativePath) ? absPath : relativePath;
+              const relativePath = path46.relative(workingDir, absPath);
+              return path46.isAbsolute(relativePath) ? absPath : relativePath;
             });
           } else {
             graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
@@ -71112,7 +70809,7 @@ var init_test_runner = __esm(() => {
 
 // src/services/preflight-service.ts
 import * as fs30 from "node:fs";
-import * as path48 from "node:path";
+import * as path47 from "node:path";
 function validateDirectoryPath(dir) {
   if (!dir || typeof dir !== "string") {
     throw new Error("Directory path is required");
@@ -71120,8 +70817,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path48.normalize(dir);
-  const absolutePath = path48.isAbsolute(normalized) ? normalized : path48.resolve(normalized);
+  const normalized = path47.normalize(dir);
+  const absolutePath = path47.isAbsolute(normalized) ? normalized : path47.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -71144,7 +70841,7 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path48.join(dir, "package.json");
+    const packagePath = path47.join(dir, "package.json");
     if (fs30.existsSync(packagePath)) {
       const content = fs30.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
@@ -71155,7 +70852,7 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path48.join(dir, "CHANGELOG.md");
+    const changelogPath = path47.join(dir, "CHANGELOG.md");
     if (fs30.existsSync(changelogPath)) {
       const content = fs30.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
@@ -71169,7 +70866,7 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file3 of possibleFiles) {
-    const filePath = path48.join(dir, file3);
+    const filePath = path47.join(dir, file3);
     if (fs30.existsSync(filePath)) {
       try {
         const content = fs30.readFileSync(filePath, "utf-8").trim();
@@ -71496,7 +71193,7 @@ async function runEvidenceCheck(dir) {
 async function runRequirementCoverageCheck(dir, currentPhase) {
   const startTime = Date.now();
   try {
-    const specPath = path48.join(dir, ".swarm", "spec.md");
+    const specPath = path47.join(dir, ".swarm", "spec.md");
     if (!fs30.existsSync(specPath)) {
       return {
         type: "req_coverage",
@@ -72634,7 +72331,7 @@ var init_manager3 = __esm(() => {
 
 // src/commands/reset.ts
 import * as fs31 from "node:fs";
-import * as path49 from "node:path";
+import * as path48 from "node:path";
 async function handleResetCommand(directory, args2) {
   const hasConfirm = args2.includes("--confirm");
   if (!hasConfirm) {
@@ -72674,7 +72371,7 @@ async function handleResetCommand(directory, args2) {
   }
   for (const filename of ["SWARM_PLAN.md", "SWARM_PLAN.json"]) {
     try {
-      const rootPath = path49.join(directory, filename);
+      const rootPath = path48.join(directory, filename);
       if (fs31.existsSync(rootPath)) {
         fs31.unlinkSync(rootPath);
         results.push(`- ✅ Deleted ${filename} (root)`);
@@ -72714,7 +72411,7 @@ var init_reset = __esm(() => {
 
 // src/commands/reset-session.ts
 import * as fs32 from "node:fs";
-import * as path50 from "node:path";
+import * as path49 from "node:path";
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
@@ -72729,13 +72426,13 @@ async function handleResetSessionCommand(directory, _args) {
     results.push("❌ Failed to delete state.json");
   }
   try {
-    const sessionDir = path50.dirname(validateSwarmPath(directory, "session/state.json"));
+    const sessionDir = path49.dirname(validateSwarmPath(directory, "session/state.json"));
     if (fs32.existsSync(sessionDir)) {
       const files = fs32.readdirSync(sessionDir);
       const otherFiles = files.filter((f) => f !== "state.json");
       let deletedCount = 0;
       for (const file3 of otherFiles) {
-        const filePath = path50.join(sessionDir, file3);
+        const filePath = path49.join(sessionDir, file3);
         if (fs32.lstatSync(filePath).isFile()) {
           fs32.unlinkSync(filePath);
           deletedCount++;
@@ -72768,7 +72465,7 @@ var init_reset_session = __esm(() => {
 
 // src/summaries/manager.ts
 import { mkdirSync as mkdirSync15, readdirSync as readdirSync14, renameSync as renameSync11, rmSync as rmSync5, statSync as statSync13 } from "node:fs";
-import * as path51 from "node:path";
+import * as path50 from "node:path";
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
     throw new Error("Invalid summary ID: empty string");
@@ -72802,9 +72499,9 @@ async function storeSummary(directory, id, fullOutput, summaryText, maxStoredByt
   if (serializedSize > maxStoredBytes) {
     throw new Error(`Summary entry size (${serializedSize} bytes) exceeds maximum (${maxStoredBytes} bytes)`);
   }
-  const relativePath = path51.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path50.join("summaries", `${sanitizedId}.json`);
   const summaryPath = validateSwarmPath(directory, relativePath);
-  const summaryDir = path51.dirname(summaryPath);
+  const summaryDir = path50.dirname(summaryPath);
   const entry = {
     id: sanitizedId,
     summaryText,
@@ -72814,7 +72511,7 @@ async function storeSummary(directory, id, fullOutput, summaryText, maxStoredByt
   };
   const entryJson = JSON.stringify(entry);
   mkdirSync15(summaryDir, { recursive: true });
-  const tempPath = path51.join(summaryDir, `${sanitizedId}.json.tmp.${Date.now()}.${process.pid}`);
+  const tempPath = path50.join(summaryDir, `${sanitizedId}.json.tmp.${Date.now()}.${process.pid}`);
   try {
     await bunWrite(tempPath, entryJson);
     renameSync11(tempPath, summaryPath);
@@ -72827,7 +72524,7 @@ async function storeSummary(directory, id, fullOutput, summaryText, maxStoredByt
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path51.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path50.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -72890,7 +72587,7 @@ var init_retrieve = __esm(() => {
 
 // src/commands/rollback.ts
 import * as fs33 from "node:fs";
-import * as path52 from "node:path";
+import * as path51 from "node:path";
 async function handleRollbackCommand(directory, args2) {
   const phaseArg = args2[0];
   if (!phaseArg) {
@@ -72955,8 +72652,8 @@ async function handleRollbackCommand(directory, args2) {
     if (EXCLUDE_FILES.has(file3) || file3.startsWith("plan-ledger.archived-")) {
       continue;
     }
-    const src = path52.join(checkpointDir, file3);
-    const dest = path52.join(swarmDir, file3);
+    const src = path51.join(checkpointDir, file3);
+    const dest = path51.join(swarmDir, file3);
     try {
       fs33.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file3);
@@ -72975,12 +72672,12 @@ async function handleRollbackCommand(directory, args2) {
     ].join(`
 `);
   }
-  const existingLedgerPath = path52.join(swarmDir, "plan-ledger.jsonl");
+  const existingLedgerPath = path51.join(swarmDir, "plan-ledger.jsonl");
   if (fs33.existsSync(existingLedgerPath)) {
     fs33.unlinkSync(existingLedgerPath);
   }
   try {
-    const planJsonPath = path52.join(swarmDir, "plan.json");
+    const planJsonPath = path51.join(swarmDir, "plan.json");
     if (fs33.existsSync(planJsonPath)) {
       const planRaw = fs33.readFileSync(planJsonPath, "utf-8");
       const plan = PlanSchema.parse(JSON.parse(planRaw));
@@ -73071,9 +72768,9 @@ Ensure this is a git repository with commit history.`;
 `);
   try {
     const fs34 = await import("node:fs/promises");
-    const path53 = await import("node:path");
-    const reportPath = path53.join(directory, ".swarm", "simulate-report.md");
-    await fs34.mkdir(path53.dirname(reportPath), { recursive: true });
+    const path52 = await import("node:path");
+    const reportPath = path52.join(directory, ".swarm", "simulate-report.md");
+    await fs34.mkdir(path52.dirname(reportPath), { recursive: true });
     await fs34.writeFile(reportPath, report, "utf-8");
   } catch (err2) {
     const writeErr = err2 instanceof Error ? err2.message : String(err2);
@@ -73097,12 +72794,12 @@ async function handleSpecifyCommand(_directory, args2) {
 
 // src/turbo/lean/state.ts
 import * as fs34 from "node:fs";
-import * as path53 from "node:path";
+import * as path52 from "node:path";
 function nowISO2() {
   return new Date().toISOString();
 }
 function ensureSwarmDir2(directory) {
-  const swarmDir = path53.resolve(directory, ".swarm");
+  const swarmDir = path52.resolve(directory, ".swarm");
   if (!fs34.existsSync(swarmDir)) {
     fs34.mkdirSync(swarmDir, { recursive: true });
   }
@@ -73146,7 +72843,7 @@ function markStateUnreadable2(directory, reason) {
 }
 function readPersisted2(directory) {
   try {
-    const filePath = path53.join(directory, ".swarm", STATE_FILE2);
+    const filePath = path52.join(directory, ".swarm", STATE_FILE2);
     if (!fs34.existsSync(filePath)) {
       const seed = emptyPersisted2();
       try {
@@ -73182,7 +72879,7 @@ function writePersisted2(directory, persisted) {
   let payload;
   try {
     ensureSwarmDir2(directory);
-    filePath = path53.join(directory, ".swarm", STATE_FILE2);
+    filePath = path52.join(directory, ".swarm", STATE_FILE2);
     tmpPath = `${filePath}.tmp.${Date.now()}`;
     persisted.updatedAt = nowISO2();
     payload = `${JSON.stringify(persisted, null, 2)}
@@ -73249,7 +72946,7 @@ var init_state3 = __esm(() => {
 
 // src/services/compaction-service.ts
 import * as fs35 from "node:fs";
-import * as path54 from "node:path";
+import * as path53 from "node:path";
 function makeInitialState() {
   return {
     lastObservationAt: 0,
@@ -73271,7 +72968,7 @@ function getSessionState(sessionId) {
 }
 function appendSnapshot(directory, tier, budgetPct, message) {
   try {
-    const snapshotPath = path54.join(directory, ".swarm", "context-snapshot.md");
+    const snapshotPath = path53.join(directory, ".swarm", "context-snapshot.md");
     const timestamp = new Date().toISOString();
     const entry = `
 ## [${tier.toUpperCase()}] ${timestamp} — ${budgetPct.toFixed(1)}% used
@@ -73524,10 +73221,10 @@ var init_context_budget_service = __esm(() => {
 
 // src/services/status-service.ts
 import * as fsSync3 from "node:fs";
-import * as path55 from "node:path";
+import * as path54 from "node:path";
 function readSpecStalenessSnapshot(directory) {
   try {
-    const p = path55.join(directory, ".swarm", "spec-staleness.json");
+    const p = path54.join(directory, ".swarm", "spec-staleness.json");
     if (!fsSync3.existsSync(p))
       return { stale: false };
     const raw = fsSync3.readFileSync(p, "utf-8");
@@ -74053,7 +73750,7 @@ var init_write_retro2 = __esm(() => {
 
 // src/commands/command-dispatch.ts
 import fs36 from "node:fs";
-import path56 from "node:path";
+import path55 from "node:path";
 function normalizeSwarmCommandInput(command, argumentText) {
   if (command !== "swarm" && !command.startsWith("swarm-")) {
     return { isSwarmCommand: false, tokens: [] };
@@ -74089,9 +73786,9 @@ ${similar.map((cmd) => `  - /swarm ${cmd}`).join(`
 `);
 }
 function maybeMarkFirstRun(directory) {
-  const sentinelPath = path56.join(directory, ".swarm", ".first-run-complete");
+  const sentinelPath = path55.join(directory, ".swarm", ".first-run-complete");
   try {
-    const swarmDir = path56.join(directory, ".swarm");
+    const swarmDir = path55.join(directory, ".swarm");
     fs36.mkdirSync(swarmDir, { recursive: true });
     fs36.writeFileSync(sentinelPath, `first-run-complete: ${new Date().toISOString()}
 `, { flag: "wx" });
@@ -74773,24 +74470,24 @@ function validateAliases() {
       }
       aliasTargets.get(target).push(name2);
       const visited = new Set;
-      const path57 = [];
+      const path56 = [];
       let current = target;
       while (current) {
         const currentEntry = COMMAND_REGISTRY[current];
         if (!currentEntry)
           break;
         if (visited.has(current)) {
-          const cycleStart = path57.indexOf(current);
+          const cycleStart = path56.indexOf(current);
           const fullChain = [
             name2,
-            ...path57.slice(0, cycleStart > 0 ? cycleStart : path57.length),
+            ...path56.slice(0, cycleStart > 0 ? cycleStart : path56.length),
             current
           ].join(" → ");
           errors5.push(`Circular alias detected: ${fullChain}`);
           break;
         }
         visited.add(current);
-        path57.push(current);
+        path56.push(current);
         current = currentEntry.aliasOf || "";
       }
     }
@@ -79468,8 +79165,8 @@ COVERAGE REPORTING:
 `;
 
 // src/agents/index.ts
-import { mkdir as mkdir10, writeFile as writeFile10 } from "node:fs/promises";
-import * as path57 from "node:path";
+import { mkdir as mkdir9, writeFile as writeFile9 } from "node:fs/promises";
+import * as path56 from "node:path";
 function stripSwarmPrefix(agentName, swarmPrefix) {
   if (!swarmPrefix || !agentName)
     return agentName;
@@ -79872,14 +79569,14 @@ function getAgentConfigs(config3, directory, sessionId, projectContext) {
   }));
   if (directory) {
     const sid = sessionId ?? `init-${Date.now()}`;
-    const evidenceDir = path57.join(directory, ".swarm", "evidence");
+    const evidenceDir = path56.join(directory, ".swarm", "evidence");
     const filename = `agent-tools-${sid}.json`;
     const snapshotData = JSON.stringify({
       sessionId: sid,
       generatedAt: new Date().toISOString(),
       agents: agentToolSnapshot
     }, null, 2);
-    mkdir10(evidenceDir, { recursive: true }).then(() => writeFile10(path57.join(evidenceDir, filename), snapshotData)).catch(() => {});
+    mkdir9(evidenceDir, { recursive: true }).then(() => writeFile9(path56.join(evidenceDir, filename), snapshotData)).catch(() => {});
   }
   return result;
 }
@@ -79916,14 +79613,14 @@ __export(exports_evidence_summary_integration, {
   createEvidenceSummaryIntegration: () => createEvidenceSummaryIntegration,
   EvidenceSummaryIntegration: () => EvidenceSummaryIntegration
 });
-import { existsSync as existsSync32, mkdirSync as mkdirSync17, writeFileSync as writeFileSync8 } from "node:fs";
-import * as path58 from "node:path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync17, writeFileSync as writeFileSync8 } from "node:fs";
+import * as path57 from "node:path";
 function persistSummary(projectDir, artifact, filename) {
-  const swarmPath = path58.join(projectDir, ".swarm");
-  if (!existsSync32(swarmPath)) {
+  const swarmPath = path57.join(projectDir, ".swarm");
+  if (!existsSync31(swarmPath)) {
     mkdirSync17(swarmPath, { recursive: true });
   }
-  const artifactPath = path58.join(swarmPath, filename);
+  const artifactPath = path57.join(swarmPath, filename);
   const content = JSON.stringify(artifact, null, 2);
   writeFileSync8(artifactPath, content, "utf-8");
   log("[EvidenceSummaryIntegration] Summary persisted", {
@@ -80042,7 +79739,7 @@ __export(exports_status_artifact, {
   AutomationStatusArtifact: () => AutomationStatusArtifact
 });
 import * as fs38 from "node:fs";
-import * as path60 from "node:path";
+import * as path59 from "node:path";
 function createEmptySnapshot(mode, capabilities) {
   return {
     timestamp: Date.now(),
@@ -80101,7 +79798,7 @@ class AutomationStatusArtifact {
     });
   }
   getFilePath() {
-    return path60.join(this.swarmDir, this.filename);
+    return path59.join(this.swarmDir, this.filename);
   }
   load() {
     const filePath = this.getFilePath();
@@ -80514,12 +80211,12 @@ __export(exports_review_receipt, {
 });
 import * as crypto5 from "node:crypto";
 import * as fs44 from "node:fs";
-import * as path63 from "node:path";
+import * as path62 from "node:path";
 function resolveReceiptsDir(directory) {
-  return path63.join(directory, ".swarm", "review-receipts");
+  return path62.join(directory, ".swarm", "review-receipts");
 }
 function resolveReceiptIndexPath(directory) {
-  return path63.join(resolveReceiptsDir(directory), "index.json");
+  return path62.join(resolveReceiptsDir(directory), "index.json");
 }
 function buildReceiptFilename(id, date9) {
   const dateStr = date9.toISOString().slice(0, 10);
@@ -80558,7 +80255,7 @@ async function readReceiptIndex(directory) {
 }
 async function writeReceiptIndex(directory, index) {
   const indexPath = resolveReceiptIndexPath(directory);
-  const dir = path63.dirname(indexPath);
+  const dir = path62.dirname(indexPath);
   await fs44.promises.mkdir(dir, { recursive: true });
   const tmpPath = `${indexPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
   await fs44.promises.writeFile(tmpPath, JSON.stringify(index, null, 2), "utf-8");
@@ -80569,7 +80266,7 @@ async function persistReviewReceipt(directory, receipt) {
   await fs44.promises.mkdir(receiptsDir, { recursive: true });
   const now = new Date(receipt.reviewed_at);
   const filename = buildReceiptFilename(receipt.id, now);
-  const receiptPath = path63.join(receiptsDir, filename);
+  const receiptPath = path62.join(receiptsDir, filename);
   const tmpPath = `${receiptPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
   await fs44.promises.writeFile(tmpPath, JSON.stringify(receipt, null, 2), "utf-8");
   fs44.renameSync(tmpPath, receiptPath);
@@ -80591,7 +80288,7 @@ async function readReceiptById(directory, receiptId) {
   const entry = index.entries.find((e) => e.id === receiptId);
   if (!entry)
     return null;
-  const receiptPath = path63.join(resolveReceiptsDir(directory), entry.filename);
+  const receiptPath = path62.join(resolveReceiptsDir(directory), entry.filename);
   try {
     const content = await fs44.promises.readFile(receiptPath, "utf-8");
     return JSON.parse(content);
@@ -80604,7 +80301,7 @@ async function readReceiptsByScopeHash(directory, scopeHash) {
   const matching = index.entries.filter((e) => e.scope_hash === scopeHash).sort((a, b) => b.reviewed_at.localeCompare(a.reviewed_at));
   const receipts = [];
   for (const entry of matching) {
-    const receiptPath = path63.join(resolveReceiptsDir(directory), entry.filename);
+    const receiptPath = path62.join(resolveReceiptsDir(directory), entry.filename);
     try {
       const content = await fs44.promises.readFile(receiptPath, "utf-8");
       receipts.push(JSON.parse(content));
@@ -80617,7 +80314,7 @@ async function readAllReceipts(directory) {
   const sorted = [...index.entries].sort((a, b) => b.reviewed_at.localeCompare(a.reviewed_at));
   const receipts = [];
   for (const entry of sorted) {
-    const receiptPath = path63.join(resolveReceiptsDir(directory), entry.filename);
+    const receiptPath = path62.join(resolveReceiptsDir(directory), entry.filename);
     try {
       const content = await fs44.promises.readFile(receiptPath, "utf-8");
       receipts.push(JSON.parse(content));
@@ -82205,11 +81902,11 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         throw toThrow;
       }, "quit_");
       var scriptDirectory = "";
-      function locateFile(path78) {
+      function locateFile(path77) {
         if (Module["locateFile"]) {
-          return Module["locateFile"](path78, scriptDirectory);
+          return Module["locateFile"](path77, scriptDirectory);
         }
-        return scriptDirectory + path78;
+        return scriptDirectory + path77;
       }
       __name(locateFile, "locateFile");
       var readAsync, readBinary;
@@ -83959,12 +83656,12 @@ __export(exports_runtime, {
   clearParserCache: () => clearParserCache,
   _internals: () => _internals37
 });
-import * as path78 from "node:path";
+import * as path77 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 async function initTreeSitter() {
   if (!treeSitterInitPromise) {
     treeSitterInitPromise = (async () => {
-      const thisDir = path78.dirname(fileURLToPath2(import.meta.url));
+      const thisDir = path77.dirname(fileURLToPath2(import.meta.url));
       const isSource = thisDir.replace(/\\/g, "/").endsWith("/src/lang");
       if (isSource) {
         await _internals37.parserInit();
@@ -83972,7 +83669,7 @@ async function initTreeSitter() {
         const grammarsDir = getGrammarsDirAbsolute();
         await _internals37.parserInit({
           locateFile(scriptName) {
-            return path78.join(grammarsDir, scriptName);
+            return path77.join(grammarsDir, scriptName);
           }
         });
       }
@@ -83998,11 +83695,11 @@ function getWasmFileName(languageId) {
   return `tree-sitter-${sanitized}.wasm`;
 }
 function getGrammarsDirAbsolute() {
-  const thisDir = path78.dirname(fileURLToPath2(import.meta.url));
+  const thisDir = path77.dirname(fileURLToPath2(import.meta.url));
   const normalized = thisDir.replace(/\\/g, "/");
   const isSource = normalized.endsWith("/src/lang");
   const isCliBundle = normalized.endsWith("/cli");
-  return isSource ? path78.join(thisDir, "grammars") : isCliBundle ? path78.join(thisDir, "..", "lang", "grammars") : path78.join(thisDir, "lang", "grammars");
+  return isSource ? path77.join(thisDir, "grammars") : isCliBundle ? path77.join(thisDir, "..", "lang", "grammars") : path77.join(thisDir, "lang", "grammars");
 }
 async function loadGrammar(languageId) {
   if (typeof languageId !== "string" || languageId.length > 100) {
@@ -84018,9 +83715,9 @@ async function loadGrammar(languageId) {
   await initTreeSitter();
   const parser = new Parser;
   const wasmFileName = getWasmFileName(normalizedId);
-  const wasmPath = path78.join(getGrammarsDirAbsolute(), wasmFileName);
-  const { existsSync: existsSync42 } = await import("node:fs");
-  if (!existsSync42(wasmPath)) {
+  const wasmPath = path77.join(getGrammarsDirAbsolute(), wasmFileName);
+  const { existsSync: existsSync41 } = await import("node:fs");
+  if (!existsSync41(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/`);
   }
@@ -84053,7 +83750,7 @@ async function isGrammarAvailable(languageId) {
   }
   try {
     const wasmFileName = getWasmFileName(normalizedId);
-    const wasmPath = path78.join(getGrammarsDirAbsolute(), wasmFileName);
+    const wasmPath = path77.join(getGrammarsDirAbsolute(), wasmFileName);
     const { statSync: statSync21 } = await import("node:fs");
     statSync21(wasmPath);
     return true;
@@ -84115,20 +83812,20 @@ __export(exports_doc_scan, {
 import * as crypto7 from "node:crypto";
 import * as fs53 from "node:fs";
 import {
-  mkdir as mkdir13,
+  mkdir as mkdir12,
   readdir as readdir5,
-  readFile as readFile12,
+  readFile as readFile11,
   realpath as realpath2,
   stat as stat6,
-  writeFile as writeFile12
+  writeFile as writeFile11
 } from "node:fs/promises";
-import * as path80 from "node:path";
+import * as path79 from "node:path";
 function normalizeSeparators(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function matchesDocPattern(filePath, patterns) {
   const normalizedPath = normalizeSeparators(filePath);
-  const basename10 = path80.basename(filePath);
+  const basename10 = path79.basename(filePath);
   for (const pattern of patterns) {
     if (!pattern.includes("/") && !pattern.includes("\\")) {
       if (basename10 === pattern) {
@@ -84184,7 +83881,7 @@ function stripMarkdown(text) {
   return text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/^\s*[-*•]\s+/gm, "").replace(/^\s*\d+\.\s+/gm, "").trim();
 }
 async function scanDocIndex(directory) {
-  const manifestPath = path80.join(directory, ".swarm", "doc-manifest.json");
+  const manifestPath = path79.join(directory, ".swarm", "doc-manifest.json");
   const defaultPatterns = DocsConfigSchema.parse({}).doc_patterns;
   const extraPatterns = [
     "ARCHITECTURE.md",
@@ -84195,13 +83892,13 @@ async function scanDocIndex(directory) {
   ];
   const allPatterns = [...defaultPatterns, ...extraPatterns];
   try {
-    const manifestContent = await readFile12(manifestPath, "utf-8");
+    const manifestContent = await readFile11(manifestPath, "utf-8");
     const existingManifest = JSON.parse(manifestContent);
     if (existingManifest.schema_version === 1 && existingManifest.files) {
       let cacheValid = true;
       for (const file3 of existingManifest.files) {
         try {
-          const fullPath = path80.join(directory, file3.path);
+          const fullPath = path79.join(directory, file3.path);
           const stat7 = fs53.statSync(fullPath);
           if (stat7.mtimeMs > file3.mtime) {
             cacheValid = false;
@@ -84236,10 +83933,10 @@ async function scanDocIndex(directory) {
       let isFile = entry.isFile();
       if (entry.isSymbolicLink()) {
         try {
-          const symlinkPath = path80.join(dir, entry.name);
+          const symlinkPath = path79.join(dir, entry.name);
           const resolved = await realpath2(symlinkPath);
-          const rel = path80.relative(resolvedDirectory, resolved);
-          if (rel.startsWith("..") || path80.isAbsolute(rel))
+          const rel = path79.relative(resolvedDirectory, resolved);
+          if (rel.startsWith("..") || path79.isAbsolute(rel))
             continue;
           const targetStat = await stat6(symlinkPath);
           isFile = targetStat.isFile();
@@ -84249,14 +83946,14 @@ async function scanDocIndex(directory) {
       }
       if (isDir) {
         if (!SKIP_DIRECTORIES3.has(entry.name)) {
-          await walkDir(path80.join(dir, entry.name));
+          await walkDir(path79.join(dir, entry.name));
         }
         continue;
       }
       if (!isFile)
         continue;
-      const fullPath = path80.join(dir, entry.name);
-      const relPath = normalizeSeparators(path80.relative(directory, fullPath));
+      const fullPath = path79.join(dir, entry.name);
+      const relPath = normalizeSeparators(path79.relative(directory, fullPath));
       let skipThisFile = false;
       for (const pattern of SKIP_PATTERNS) {
         if (pattern.test(relPath)) {
@@ -84276,11 +83973,11 @@ async function scanDocIndex(directory) {
       }
       let content;
       try {
-        content = await readFile12(fullPath, "utf-8");
+        content = await readFile11(fullPath, "utf-8");
       } catch {
         continue;
       }
-      const { title, summary } = extractTitleAndSummary(content, path80.basename(relPath));
+      const { title, summary } = extractTitleAndSummary(content, path79.basename(relPath));
       discoveredFiles.push({
         path: relPath,
         title,
@@ -84317,8 +84014,8 @@ async function scanDocIndex(directory) {
     files: discoveredFiles
   };
   try {
-    await mkdir13(path80.dirname(manifestPath), { recursive: true });
-    await writeFile12(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    await mkdir12(path79.dirname(manifestPath), { recursive: true });
+    await writeFile11(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   } catch {}
   return { manifest, cached: false };
 }
@@ -84356,10 +84053,10 @@ function extractConstraintsFromContent(content) {
   return constraints;
 }
 async function extractDocConstraints(directory, taskFiles, taskDescription) {
-  const manifestPath = path80.join(directory, ".swarm", "doc-manifest.json");
+  const manifestPath = path79.join(directory, ".swarm", "doc-manifest.json");
   let manifest;
   try {
-    const content = await readFile12(manifestPath, "utf-8");
+    const content = await readFile11(manifestPath, "utf-8");
     manifest = JSON.parse(content);
   } catch {
     const result = await scanDocIndex(directory);
@@ -84382,7 +84079,7 @@ async function extractDocConstraints(directory, taskFiles, taskDescription) {
     }
     let fullContent;
     try {
-      fullContent = await readFile12(path80.join(directory, docFile.path), "utf-8");
+      fullContent = await readFile11(path79.join(directory, docFile.path), "utf-8");
     } catch {
       skippedCount++;
       continue;
@@ -84405,7 +84102,7 @@ async function extractDocConstraints(directory, taskFiles, taskDescription) {
           tier: "swarm",
           lesson: constraint,
           category: "architecture",
-          tags: ["doc-scan", path80.basename(docFile.path)],
+          tags: ["doc-scan", path79.basename(docFile.path)],
           scope: "global",
           confidence: 0.5,
           status: "candidate",
@@ -84484,7 +84181,7 @@ var init_doc_scan = __esm(() => {
         }
       } catch {}
       if (force) {
-        const manifestPath = path80.join(directory, ".swarm", "doc-manifest.json");
+        const manifestPath = path79.join(directory, ".swarm", "doc-manifest.json");
         try {
           fs53.unlinkSync(manifestPath);
         } catch {}
@@ -84536,11 +84233,12 @@ __export(exports_knowledge_recall, {
   knowledge_recall: () => knowledge_recall,
   _internals: () => _internals38
 });
-var knowledge_recall, _internals38;
+var NORMAL_RETRIEVAL_STATUSES, knowledge_recall, _internals38;
 var init_knowledge_recall = __esm(() => {
   init_zod();
   init_knowledge_store();
   init_create_tool();
+  NORMAL_RETRIEVAL_STATUSES = new Set(["established", "promoted"]);
   knowledge_recall = createSwarmTool({
     description: "Search the knowledge base for relevant past decisions, patterns, and lessons learned. Returns ranked results by semantic similarity.",
     args: {
@@ -84592,7 +84290,9 @@ var init_knowledge_recall = __esm(() => {
       if (tier === "all" || tier === "hive") {
         entries = entries.concat(hiveEntries);
       }
-      entries = entries.filter((entry) => entry.status !== "archived");
+      const retractions = await readRetractionRecords(directory);
+      const suppressedLessons = new Set(retractions.map((record3) => record3.normalized_lesson).filter((value) => typeof value === "string" && value.length > 0));
+      entries = entries.filter((entry) => NORMAL_RETRIEVAL_STATUSES.has(entry.status) && !suppressedLessons.has(normalize2(entry.lesson)));
       if (entries.length === 0) {
         const result2 = { results: [], total: 0 };
         return JSON.stringify(result2);
@@ -84680,9 +84380,9 @@ __export(exports_curator_drift, {
   _internals: () => _internals40
 });
 import * as fs60 from "node:fs";
-import * as path86 from "node:path";
+import * as path85 from "node:path";
 async function readPriorDriftReports(directory) {
-  const swarmDir = path86.join(directory, ".swarm");
+  const swarmDir = path85.join(directory, ".swarm");
   const entries = await fs60.promises.readdir(swarmDir).catch(() => null);
   if (entries === null)
     return [];
@@ -84709,7 +84409,7 @@ async function readPriorDriftReports(directory) {
 async function writeDriftReport(directory, report) {
   const filename = `${DRIFT_REPORT_PREFIX}${report.phase}.json`;
   const filePath = validateSwarmPath(directory, filename);
-  const swarmDir = path86.dirname(filePath);
+  const swarmDir = path85.dirname(filePath);
   await fs60.promises.mkdir(swarmDir, { recursive: true });
   try {
     await fs60.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
@@ -84996,7 +84696,7 @@ init_manager3();
 init_manager();
 init_utils();
 import * as fs37 from "node:fs";
-import * as path59 from "node:path";
+import * as path58 from "node:path";
 
 class PlanSyncWorker {
   directory;
@@ -85020,10 +84720,10 @@ class PlanSyncWorker {
     this.onSyncComplete = options.onSyncComplete;
   }
   getSwarmDir() {
-    return path59.resolve(this.directory, ".swarm");
+    return path58.resolve(this.directory, ".swarm");
   }
   getPlanJsonPath() {
-    return path59.join(this.getSwarmDir(), "plan.json");
+    return path58.join(this.getSwarmDir(), "plan.json");
   }
   start() {
     if (this.disposed) {
@@ -85242,8 +84942,8 @@ class PlanSyncWorker {
   checkForUnauthorizedWrite() {
     try {
       const swarmDir = this.getSwarmDir();
-      const planJsonPath = path59.join(swarmDir, "plan.json");
-      const markerPath = path59.join(swarmDir, ".plan-write-marker");
+      const planJsonPath = path58.join(swarmDir, "plan.json");
+      const markerPath = path58.join(swarmDir, ".plan-write-marker");
       const planStats = fs37.statSync(planJsonPath);
       const planMtimeMs = Math.floor(planStats.mtimeMs);
       const markerContent = fs37.readFileSync(markerPath, "utf8");
@@ -85284,13 +84984,13 @@ init_constants();
 // src/config/project-init.ts
 init_constants();
 import * as fs39 from "node:fs";
-import * as path61 from "node:path";
+import * as path60 from "node:path";
 var STARTER_CONTENT = `{}
 `;
 function writeProjectConfigIfNew(directory, quiet = false) {
   try {
-    const opencodeDir = path61.join(directory, ".opencode");
-    const dest = path61.join(opencodeDir, "opencode-swarm.json");
+    const opencodeDir = path60.join(directory, ".opencode");
+    const dest = path60.join(opencodeDir, "opencode-swarm.json");
     try {
       const stat4 = fs39.lstatSync(opencodeDir);
       if (stat4.isSymbolicLink())
@@ -85315,8 +85015,8 @@ function writeProjectConfigIfNew(directory, quiet = false) {
 }
 function writeSwarmConfigExampleIfNew(projectDirectory) {
   try {
-    const swarmDir = path61.join(projectDirectory, ".swarm");
-    const dest = path61.join(swarmDir, "config.example.json");
+    const swarmDir = path60.join(projectDirectory, ".swarm");
+    const dest = path60.join(swarmDir, "config.example.json");
     if (fs39.existsSync(dest))
       return;
     if (!fs39.existsSync(swarmDir)) {
@@ -85353,7 +85053,7 @@ init_state();
 init_logger();
 init_state2();
 import * as fs40 from "node:fs";
-import * as path62 from "node:path";
+import * as path61 from "node:path";
 var oversightSequenceCounter = 0;
 var VALID_VERDICTS = [
   "APPROVED",
@@ -85527,10 +85227,10 @@ async function writeFullAutoOversightEvidence(directory, phase, event) {
   if (phase === undefined)
     return;
   try {
-    const evidenceDir = validateSwarmPath(directory, path62.posix.join("evidence", String(phase)));
+    const evidenceDir = validateSwarmPath(directory, path61.posix.join("evidence", String(phase)));
     fs40.mkdirSync(evidenceDir, { recursive: true });
     const fileName = `full-auto-${event.oversight_sequence}.json`;
-    const filePath = validateSwarmPath(directory, path62.posix.join("evidence", String(phase), fileName));
+    const filePath = validateSwarmPath(directory, path61.posix.join("evidence", String(phase), fileName));
     fs40.writeFileSync(filePath, `${JSON.stringify(event, null, 2)}
 `, "utf-8");
     return filePath;
@@ -85939,11 +85639,11 @@ async function doFlush(directory) {
     const activitySection = renderActivitySection();
     const updated = replaceOrAppendSection(existing, "## Agent Activity", activitySection);
     const flushedCount = swarmState.pendingEvents;
-    const path63 = nodePath2.join(directory, ".swarm", "context.md");
-    const tempPath = `${path63}.tmp`;
+    const path62 = nodePath2.join(directory, ".swarm", "context.md");
+    const tempPath = `${path62}.tmp`;
     try {
       await bunWrite(tempPath, updated);
-      renameSync13(tempPath, path63);
+      renameSync13(tempPath, path62);
     } catch (writeError) {
       try {
         unlinkSync11(tempPath);
@@ -86186,7 +85886,7 @@ init_state();
 init_extractors();
 init_utils2();
 import * as fs41 from "node:fs";
-import { join as join55 } from "node:path";
+import { join as join54 } from "node:path";
 function createCompactionCustomizerHook(config3, directory) {
   const enabled = config3.hooks?.compaction !== false;
   if (!enabled) {
@@ -86231,7 +85931,7 @@ function createCompactionCustomizerHook(config3, directory) {
         }
       }
       try {
-        const summariesDir = join55(directory, ".swarm", "summaries");
+        const summariesDir = join54(directory, ".swarm", "summaries");
         const files = await fs41.promises.readdir(summariesDir);
         if (files.length > 0) {
           const count = files.length;
@@ -87611,7 +87311,7 @@ init_schema();
 init_manager();
 init_curator();
 init_utils2();
-import * as path64 from "node:path";
+import * as path63 from "node:path";
 function createPhaseMonitorHook(directory, preflightManager, curatorRunner, delegateFactory) {
   let lastKnownPhase = null;
   const handler = async (input, _output) => {
@@ -87631,10 +87331,10 @@ function createPhaseMonitorHook(directory, preflightManager, curatorRunner, dele
           const llmDelegate = delegateFactory?.(sessionId);
           const initResult = await runner(directory, curatorConfig, llmDelegate);
           if (initResult.briefing) {
-            const briefingPath = path64.join(directory, ".swarm", "curator-briefing.md");
-            const { mkdir: mkdir11, writeFile: writeFile11 } = await import("node:fs/promises");
-            await mkdir11(path64.dirname(briefingPath), { recursive: true });
-            await writeFile11(briefingPath, initResult.briefing, "utf-8");
+            const briefingPath = path63.join(directory, ".swarm", "curator-briefing.md");
+            const { mkdir: mkdir10, writeFile: writeFile10 } = await import("node:fs/promises");
+            await mkdir10(path63.dirname(briefingPath), { recursive: true });
+            await writeFile10(briefingPath, initResult.briefing, "utf-8");
             const { buildApprovedReceipt: buildApprovedReceipt2, persistReviewReceipt: persistReviewReceipt2 } = await Promise.resolve().then(() => (init_review_receipt(), exports_review_receipt));
             const initReceipt = buildApprovedReceipt2({
               agent: "curator",
@@ -87760,16 +87460,16 @@ ${originalText}`;
 // src/hooks/repo-graph-builder.ts
 init_constants();
 import { realpathSync as realpathSync10 } from "node:fs";
-import * as path71 from "node:path";
+import * as path70 from "node:path";
 
 // src/tools/repo-graph/builder.ts
 init_logger();
 init_path_security();
 import * as fsSync4 from "node:fs";
-import { existsSync as existsSync38, realpathSync as realpathSync8 } from "node:fs";
+import { existsSync as existsSync37, realpathSync as realpathSync8 } from "node:fs";
 import * as fsPromises5 from "node:fs/promises";
 import * as os7 from "node:os";
-import * as path67 from "node:path";
+import * as path66 from "node:path";
 
 // src/utils/timeout.ts
 async function withTimeout(promise3, ms, timeoutError) {
@@ -87801,7 +87501,7 @@ init_zod();
 init_create_tool();
 init_path_security();
 import * as fs45 from "node:fs";
-import * as path65 from "node:path";
+import * as path64 from "node:path";
 var MAX_FILE_SIZE_BYTES2 = 1024 * 1024;
 var WINDOWS_RESERVED_NAMES = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks(str) {
@@ -87818,11 +87518,11 @@ function containsWindowsAttacks(str) {
 }
 function isPathInWorkspace(filePath, workspace) {
   try {
-    const resolvedPath = path65.resolve(workspace, filePath);
+    const resolvedPath = path64.resolve(workspace, filePath);
     const realWorkspace = fs45.realpathSync(workspace);
     const realResolvedPath = fs45.realpathSync(resolvedPath);
-    const relativePath = path65.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path65.isAbsolute(relativePath)) {
+    const relativePath = path64.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path64.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -87834,7 +87534,7 @@ function validatePathForRead(filePath, workspace) {
   return isPathInWorkspace(filePath, workspace);
 }
 function extractTSSymbols(filePath, cwd) {
-  const fullPath = path65.join(cwd, filePath);
+  const fullPath = path64.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
@@ -87986,7 +87686,7 @@ function extractTSSymbols(filePath, cwd) {
   });
 }
 function extractPythonSymbols(filePath, cwd) {
-  const fullPath = path65.join(cwd, filePath);
+  const fullPath = path64.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
@@ -88069,7 +87769,7 @@ var symbols = createSwarmTool({
       }, null, 2);
     }
     const cwd = directory;
-    const ext = path65.extname(file3);
+    const ext = path64.extname(file3);
     if (containsControlChars(file3)) {
       return JSON.stringify({
         file: file3,
@@ -88130,16 +87830,16 @@ var symbols = createSwarmTool({
 });
 
 // src/tools/repo-graph/types.ts
-import * as path66 from "node:path";
+import * as path65 from "node:path";
 var REPO_GRAPH_FILENAME = "repo-graph.json";
 var GRAPH_SCHEMA_VERSION = "1.0.0";
 function normalizeGraphPath(filePath) {
-  return path66.normalize(filePath).replace(/\\/g, "/");
+  return path65.normalize(filePath).replace(/\\/g, "/");
 }
 function createEmptyGraph(workspaceRoot) {
   return {
     schema_version: GRAPH_SCHEMA_VERSION,
-    workspaceRoot: path66.normalize(workspaceRoot),
+    workspaceRoot: path65.normalize(workspaceRoot),
     nodes: {},
     edges: [],
     metadata: {
@@ -88314,8 +88014,8 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
   }
   try {
     if (specifier.startsWith(".")) {
-      const sourceDir = path67.dirname(sourceFile);
-      let resolved = path67.resolve(sourceDir, specifier);
+      const sourceDir = path66.dirname(sourceFile);
+      let resolved = path66.resolve(sourceDir, specifier);
       let realResolved;
       try {
         realResolved = realpathSync8(resolved);
@@ -88326,9 +88026,9 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
       try {
         realRoot = realpathSync8(workspaceRoot);
       } catch {
-        realRoot = path67.normalize(workspaceRoot);
+        realRoot = path66.normalize(workspaceRoot);
       }
-      if (!existsSync38(resolved)) {
+      if (!existsSync37(resolved)) {
         const EXTENSIONS = [
           ".ts",
           ".tsx",
@@ -88342,7 +88042,7 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
         let found = null;
         for (const ext of EXTENSIONS) {
           const candidate = resolved + ext;
-          if (existsSync38(candidate)) {
+          if (existsSync37(candidate)) {
             found = candidate;
             break;
           }
@@ -88358,9 +88058,9 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
           return null;
         }
       }
-      const normalizedResolved = path67.normalize(realResolved);
-      const normalizedRoot = path67.normalize(realRoot);
-      if (!normalizedResolved.startsWith(normalizedRoot + path67.sep) && normalizedResolved !== normalizedRoot) {
+      const normalizedResolved = path66.normalize(realResolved);
+      const normalizedRoot = path66.normalize(realRoot);
+      if (!normalizedResolved.startsWith(normalizedRoot + path66.sep) && normalizedResolved !== normalizedRoot) {
         return null;
       }
       return resolved;
@@ -88375,12 +88075,12 @@ function isRefusedWorkspaceRoot(target) {
   try {
     resolved = realpathSync8(target);
   } catch {
-    resolved = path67.resolve(target);
+    resolved = path66.resolve(target);
   }
   const refused = new Set;
   const add = (p) => {
     if (typeof p === "string" && p.length > 0) {
-      refused.add(path67.resolve(p));
+      refused.add(path66.resolve(p));
     }
   };
   add(os7.homedir());
@@ -88490,7 +88190,7 @@ async function findSourceFilesAsync(dir, stats, options) {
         ctx.stats.skippedDirs++;
         continue;
       }
-      const fullPath = path67.join(current, entry.name);
+      const fullPath = path66.join(current, entry.name);
       if (entry.isSymbolicLink() && !ctx.followSymlinks) {
         ctx.stats.skippedDirs++;
         continue;
@@ -88498,7 +88198,7 @@ async function findSourceFilesAsync(dir, stats, options) {
       if (entry.isDirectory()) {
         queue.push(fullPath);
       } else if (entry.isFile()) {
-        const ext = path67.extname(fullPath).toLowerCase();
+        const ext = path66.extname(fullPath).toLowerCase();
         if (SUPPORTED_EXTENSIONS.includes(ext)) {
           files.push(fullPath);
         }
@@ -88515,11 +88215,11 @@ async function findSourceFilesAsync(dir, stats, options) {
   return files;
 }
 function toModuleName(filePath, workspaceRoot) {
-  const relative12 = path67.relative(workspaceRoot, filePath);
-  return relative12.split(path67.sep).join("/");
+  const relative12 = path66.relative(workspaceRoot, filePath);
+  return relative12.split(path66.sep).join("/");
 }
 function getLanguage(filePath) {
-  const ext = path67.extname(filePath).toLowerCase();
+  const ext = path66.extname(filePath).toLowerCase();
   return EXTENSION_TO_LANGUAGE[ext] ?? "unknown";
 }
 function isBinaryContent(content) {
@@ -88543,15 +88243,15 @@ function scanFile(filePath, absoluteRoot, maxFileSize) {
   if (isBinaryContent(content)) {
     return { node: null, edges: [] };
   }
-  const ext = path67.extname(filePath).toLowerCase();
+  const ext = path66.extname(filePath).toLowerCase();
   let exports = [];
   try {
     if ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
-      const relativePath = path67.relative(absoluteRoot, filePath);
+      const relativePath = path66.relative(absoluteRoot, filePath);
       const symbols2 = extractTSSymbols(relativePath, absoluteRoot);
       exports = symbols2.filter((s) => s.exported).map((s) => s.name);
     } else if (ext === ".py") {
-      const relativePath = path67.relative(absoluteRoot, filePath);
+      const relativePath = path66.relative(absoluteRoot, filePath);
       const symbols2 = extractPythonSymbols(relativePath, absoluteRoot);
       exports = symbols2.filter((s) => s.exported).map((s) => s.name);
     }
@@ -88588,8 +88288,8 @@ async function buildWorkspaceGraphAsync(workspaceRoot, options) {
   const maxFiles = options?.maxFiles ?? DEFAULT_WALK_FILE_CAP;
   const walkBudgetMs = options?.walkBudgetMs ?? DEFAULT_WALK_BUDGET_MS;
   const followSymlinks = options?.followSymlinks ?? false;
-  const absoluteRoot = path67.resolve(workspaceRoot);
-  if (!existsSync38(absoluteRoot)) {
+  const absoluteRoot = path66.resolve(workspaceRoot);
+  if (!existsSync37(absoluteRoot)) {
     throw new Error(`Workspace directory does not exist: ${workspaceRoot}`);
   }
   if (isRefusedWorkspaceRoot(absoluteRoot)) {
@@ -88644,15 +88344,15 @@ async function buildWorkspaceGraphAsync(workspaceRoot, options) {
   return graph;
 }
 // src/tools/repo-graph/cache.ts
-import * as path68 from "node:path";
+import * as path67 from "node:path";
 var graphCache = new Map;
 var dirtyFlags = new Map;
 var mtimeCache = new Map;
 function getCachedGraph(workspace) {
-  return graphCache.get(path68.normalize(workspace));
+  return graphCache.get(path67.normalize(workspace));
 }
 function setCachedGraph(workspace, graph, mtime) {
-  const normalized = path68.normalize(workspace);
+  const normalized = path67.normalize(workspace);
   graphCache.set(normalized, graph);
   dirtyFlags.set(normalized, false);
   if (mtime !== undefined) {
@@ -88660,30 +88360,30 @@ function setCachedGraph(workspace, graph, mtime) {
   }
 }
 function isDirty(workspace) {
-  return dirtyFlags.get(path68.normalize(workspace)) ?? false;
+  return dirtyFlags.get(path67.normalize(workspace)) ?? false;
 }
 function clearCache(workspace) {
-  const normalized = path68.normalize(workspace);
+  const normalized = path67.normalize(workspace);
   graphCache.delete(normalized);
   dirtyFlags.delete(normalized);
   mtimeCache.delete(normalized);
 }
 function getCachedMtime(workspace) {
-  return mtimeCache.get(path68.normalize(workspace));
+  return mtimeCache.get(path67.normalize(workspace));
 }
 // src/tools/repo-graph/incremental.ts
 init_logger();
-import { existsSync as existsSync40 } from "node:fs";
+import { existsSync as existsSync39 } from "node:fs";
 import * as fsPromises7 from "node:fs/promises";
-import * as path70 from "node:path";
+import * as path69 from "node:path";
 
 // src/tools/repo-graph/storage.ts
 init_utils2();
 init_logger();
 init_path_security();
-import { constants as constants4, existsSync as existsSync39, realpathSync as realpathSync9 } from "node:fs";
+import { constants as constants4, existsSync as existsSync38, realpathSync as realpathSync9 } from "node:fs";
 import * as fsPromises6 from "node:fs/promises";
-import * as path69 from "node:path";
+import * as path68 from "node:path";
 var WINDOWS_RENAME_MAX_RETRIES2 = 3;
 var WINDOWS_RENAME_RETRY_DELAY_MS2 = 50;
 function getGraphPath(workspace) {
@@ -88694,12 +88394,12 @@ function getGraphPath(workspace) {
 }
 async function loadGraph(workspace) {
   validateWorkspace(workspace);
-  const normalized = path69.normalize(workspace);
+  const normalized = path68.normalize(workspace);
   const cached3 = getCachedGraph(normalized);
   if (cached3 && !isDirty(normalized)) {
     try {
       const graphPath = getGraphPath(workspace);
-      if (existsSync39(graphPath)) {
+      if (existsSync38(graphPath)) {
         const stats = await fsPromises6.stat(graphPath);
         const cachedMtime = getCachedMtime(normalized);
         if (cachedMtime !== undefined && stats.mtimeMs !== cachedMtime) {
@@ -88716,7 +88416,7 @@ async function loadGraph(workspace) {
   }
   try {
     const graphPath = getGraphPath(workspace);
-    if (!existsSync39(graphPath)) {
+    if (!existsSync38(graphPath)) {
       return null;
     }
     const stats = await fsPromises6.stat(graphPath);
@@ -88788,28 +88488,28 @@ async function saveGraph(workspace, graph, options) {
   if (!Array.isArray(graph.edges)) {
     throw new Error("Graph must have edges array");
   }
-  const normalizedWorkspace = path69.normalize(workspace);
+  const normalizedWorkspace = path68.normalize(workspace);
   let realWorkspace;
   try {
     realWorkspace = realpathSync9(workspace);
   } catch {
     realWorkspace = normalizedWorkspace;
   }
-  const normalizedGraphRoot = path69.normalize(graph.workspaceRoot);
+  const normalizedGraphRoot = path68.normalize(graph.workspaceRoot);
   let realGraphRoot;
   try {
     realGraphRoot = realpathSync9(graph.workspaceRoot);
   } catch {
     realGraphRoot = normalizedGraphRoot;
   }
-  if (path69.normalize(realWorkspace) !== path69.normalize(realGraphRoot)) {
+  if (path68.normalize(realWorkspace) !== path68.normalize(realGraphRoot)) {
     throw new Error(`Graph workspaceRoot mismatch: graph was built for "${graph.workspaceRoot}" but save was called for "${workspace}"`);
   }
   const normalized = normalizedWorkspace;
   const graphPath = getGraphPath(workspace);
   updateGraphMetadata(graph);
   const tempPath = `${graphPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
-  await fsPromises6.mkdir(path69.dirname(tempPath), { recursive: true });
+  await fsPromises6.mkdir(path68.dirname(tempPath), { recursive: true });
   let lastError = null;
   try {
     if (options?.createAtomic) {
@@ -88877,12 +88577,12 @@ async function updateGraphForFiles(workspaceRoot, filePaths, options) {
     return graph2;
   }
   const graph = existingGraph;
-  const absoluteRoot = path70.resolve(workspaceRoot);
+  const absoluteRoot = path69.resolve(workspaceRoot);
   const maxFileSize = 1024 * 1024;
   const updatedPaths = new Set;
   for (const rawFilePath of filePaths) {
     const normalizedPath = normalizeGraphPath(rawFilePath);
-    const fileExists = existsSync40(rawFilePath);
+    const fileExists = existsSync39(rawFilePath);
     if (fileExists) {
       graph.edges = graph.edges.filter((e) => normalizeGraphPath(e.source) !== normalizedPath);
       const result = scanFile(rawFilePath, absoluteRoot, maxFileSize);
@@ -88917,12 +88617,12 @@ async function updateGraphForFiles(workspaceRoot, filePaths, options) {
     await saveGraph(workspaceRoot, rebuiltGraph);
     return rebuiltGraph;
   }
-  const normalizedWorkspace = path70.normalize(workspaceRoot);
+  const normalizedWorkspace = path69.normalize(workspaceRoot);
   const loadedMtime = getCachedMtime(normalizedWorkspace);
   if (loadedMtime !== undefined) {
     try {
       const graphPath = getGraphPath(workspaceRoot);
-      if (existsSync40(graphPath)) {
+      if (existsSync39(graphPath)) {
         const currentStats = await fsPromises7.stat(graphPath);
         if (currentStats.mtimeMs !== loadedMtime) {
           warn(`[repo-graph] Concurrent modification detected — falling back to full rebuild`);
@@ -89015,7 +88715,7 @@ function createRepoGraphBuilderHook(workspaceRoot, deps) {
         return;
       if (!isSupportedSourceFile(filePath))
         return;
-      const absoluteFilePath = path71.isAbsolute(filePath) ? filePath : path71.resolve(workspaceRoot, filePath);
+      const absoluteFilePath = path70.isAbsolute(filePath) ? filePath : path70.resolve(workspaceRoot, filePath);
       let realFilePath;
       try {
         realFilePath = realpathSync10(absoluteFilePath);
@@ -89042,7 +88742,7 @@ function createRepoGraphBuilderHook(workspaceRoot, deps) {
       try {
         await _updateGraphForFiles(workspaceRoot, [absoluteFilePath]);
         consecutiveFailures = 0;
-        log(`[repo-graph] Incremental update for ${path71.basename(filePath)}`);
+        log(`[repo-graph] Incremental update for ${path70.basename(filePath)}`);
       } catch (error93) {
         const message = error93 instanceof Error ? error93.message : String(error93);
         consecutiveFailures++;
@@ -89065,14 +88765,14 @@ init_manager2();
 init_detector();
 init_manager();
 import * as fs54 from "node:fs";
-import * as path81 from "node:path";
+import * as path80 from "node:path";
 
 // src/services/decision-drift-analyzer.ts
 init_utils2();
 init_manager();
 init_utils();
 import * as fs46 from "node:fs";
-import * as path72 from "node:path";
+import * as path71 from "node:path";
 var DEFAULT_DRIFT_CONFIG = {
   staleThresholdPhases: 1,
   detectContradictions: true,
@@ -89226,7 +88926,7 @@ async function analyzeDecisionDrift(directory, config3 = {}) {
         currentPhase = legacyPhase;
       }
     }
-    const contextPath = path72.join(directory, ".swarm", "context.md");
+    const contextPath = path71.join(directory, ".swarm", "context.md");
     let contextContent = "";
     try {
       if (fs46.existsSync(contextPath)) {
@@ -89365,7 +89065,7 @@ init_utils();
 init_constants();
 init_schema();
 import * as fs47 from "node:fs/promises";
-import * as path73 from "node:path";
+import * as path72 from "node:path";
 function safeGet(obj, key) {
   if (!obj || !Object.hasOwn(obj, key))
     return;
@@ -89597,9 +89297,9 @@ async function handleDebuggingSpiral(match, taskId, directory) {
   let eventLogged = false;
   let checkpointCreated = false;
   try {
-    const swarmDir = path73.join(directory, ".swarm");
+    const swarmDir = path72.join(directory, ".swarm");
     await fs47.mkdir(swarmDir, { recursive: true });
-    const eventsPath = path73.join(swarmDir, "events.jsonl");
+    const eventsPath = path72.join(swarmDir, "events.jsonl");
     await fs47.appendFile(eventsPath, `${formatDebuggingSpiralEvent(match, taskId)}
 `);
     eventLogged = true;
@@ -89735,7 +89435,7 @@ import * as fs51 from "node:fs";
 
 // src/graph/graph-builder.ts
 import * as fs49 from "node:fs";
-import * as path76 from "node:path";
+import * as path75 from "node:path";
 
 // node_modules/yocto-queue/index.js
 class Node {
@@ -89896,7 +89596,7 @@ function validateConcurrency(concurrency) {
 // src/graph/import-extractor.ts
 init_path_security();
 import * as fs48 from "node:fs";
-import * as path74 from "node:path";
+import * as path73 from "node:path";
 var SOURCE_EXTENSIONS2 = [
   ".ts",
   ".tsx",
@@ -89941,14 +89641,14 @@ function getLanguageFromExtension(ext) {
   return null;
 }
 function toRelForwardSlash(absPath, root) {
-  return path74.relative(root, absPath).replace(/\\/g, "/");
+  return path73.relative(root, absPath).replace(/\\/g, "/");
 }
 function tryResolveTSJS(rawModule, sourceFileAbs) {
   if (!rawModule.startsWith(".") && !rawModule.startsWith("/")) {
     return null;
   }
-  const sourceDir = path74.dirname(sourceFileAbs);
-  const baseAbs = path74.resolve(sourceDir, rawModule);
+  const sourceDir = path73.dirname(sourceFileAbs);
+  const baseAbs = path73.resolve(sourceDir, rawModule);
   const probe = (basePath) => {
     for (const ext of RESOLVE_EXTENSION_CANDIDATES) {
       const test = basePath + ext;
@@ -89959,7 +89659,7 @@ function tryResolveTSJS(rawModule, sourceFileAbs) {
       } catch {}
     }
     for (const indexFile of RESOLVE_INDEX_CANDIDATES) {
-      const test = path74.join(basePath, indexFile);
+      const test = path73.join(basePath, indexFile);
       try {
         const stat6 = fs48.statSync(test);
         if (stat6.isFile())
@@ -89989,13 +89689,13 @@ function tryResolvePython(rawModule, sourceFileAbs, workspaceRoot) {
   }
   const remainder = rawModule.slice(leadingDots).replace(/\./g, "/");
   const upDirs = "../".repeat(Math.max(0, leadingDots - 1));
-  const sourceDir = path74.dirname(sourceFileAbs);
-  const baseAbs = path74.resolve(sourceDir, upDirs + remainder);
+  const sourceDir = path73.dirname(sourceFileAbs);
+  const baseAbs = path73.resolve(sourceDir, upDirs + remainder);
   const accept = (test) => {
     try {
       const stat6 = fs48.statSync(test);
       if (stat6.isFile()) {
-        const rel = path74.relative(workspaceRoot, test).replace(/\\/g, "/");
+        const rel = path73.relative(workspaceRoot, test).replace(/\\/g, "/");
         if (rel.startsWith(".."))
           return null;
         return test;
@@ -90009,7 +89709,7 @@ function tryResolvePython(rawModule, sourceFileAbs, workspaceRoot) {
       return hit;
   }
   for (const indexFile of PY_INDEX_CANDIDATES) {
-    const hit = accept(path74.join(baseAbs, indexFile));
+    const hit = accept(path73.join(baseAbs, indexFile));
     if (hit)
       return hit;
   }
@@ -90380,7 +90080,7 @@ function parseRustUses(content) {
 }
 function extractImports5(opts) {
   const { absoluteFilePath, workspaceRoot } = opts;
-  const ext = path74.extname(absoluteFilePath).toLowerCase();
+  const ext = path73.extname(absoluteFilePath).toLowerCase();
   const language = getLanguageFromExtension(ext);
   if (!language)
     return [];
@@ -90431,9 +90131,9 @@ function extractImports5(opts) {
 }
 
 // src/graph/symbol-extractor.ts
-import * as path75 from "node:path";
+import * as path74 from "node:path";
 function extractExportedSymbols(relativeFilePath, workspaceRoot) {
-  const ext = path75.extname(relativeFilePath).toLowerCase();
+  const ext = path74.extname(relativeFilePath).toLowerCase();
   const language = getLanguageFromExtension(ext);
   if (!language)
     return [];
@@ -90522,15 +90222,15 @@ function findSourceFiles(workspaceRoot, skipDirs = DEFAULT_SKIP_DIRS) {
       if (entry.isDirectory()) {
         if (skipDirs.has(entry.name))
           continue;
-        stack.push(path76.join(dir, entry.name));
+        stack.push(path75.join(dir, entry.name));
         continue;
       }
       if (!entry.isFile())
         continue;
-      const ext = path76.extname(entry.name).toLowerCase();
+      const ext = path75.extname(entry.name).toLowerCase();
       if (!SOURCE_EXT_SET.has(ext))
         continue;
-      out2.push(path76.join(dir, entry.name));
+      out2.push(path75.join(dir, entry.name));
     }
   }
   return out2;
@@ -90558,7 +90258,7 @@ async function buildRepoGraph(workspaceRoot, options = {}) {
   };
 }
 async function processFile(absoluteFilePath, workspaceRoot) {
-  const ext = path76.extname(absoluteFilePath).toLowerCase();
+  const ext = path75.extname(absoluteFilePath).toLowerCase();
   const language = getLanguageFromExtension(ext);
   if (!language)
     return null;
@@ -90578,7 +90278,7 @@ async function processFile(absoluteFilePath, workspaceRoot) {
   } catch {
     return null;
   }
-  const relPath = path76.relative(workspaceRoot, absoluteFilePath).replace(/\\/g, "/");
+  const relPath = path75.relative(workspaceRoot, absoluteFilePath).replace(/\\/g, "/");
   const imports = extractImports5({
     absoluteFilePath,
     workspaceRoot,
@@ -90820,10 +90520,10 @@ function formatSummary(opts) {
 // src/graph/graph-store.ts
 import * as crypto6 from "node:crypto";
 import * as fs50 from "node:fs";
-import * as path77 from "node:path";
+import * as path76 from "node:path";
 var SWARM_DIR = ".swarm";
 function getGraphPath2(workspaceRoot) {
-  return path77.join(workspaceRoot, SWARM_DIR, REPO_GRAPH_FILENAME2);
+  return path76.join(workspaceRoot, SWARM_DIR, REPO_GRAPH_FILENAME2);
 }
 function loadGraph2(workspaceRoot) {
   const file3 = getGraphPath2(workspaceRoot);
@@ -90845,7 +90545,7 @@ function loadGraph2(workspaceRoot) {
 }
 function saveGraph2(workspaceRoot, graph) {
   const file3 = getGraphPath2(workspaceRoot);
-  const dir = path77.dirname(file3);
+  const dir = path76.dirname(file3);
   try {
     const stat6 = fs50.lstatSync(dir);
     if (stat6.isSymbolicLink()) {
@@ -90951,7 +90651,7 @@ function buildReviewerBlastRadiusBlock(directory, changedFiles) {
 // src/hooks/semantic-diff-injection.ts
 import * as child_process5 from "node:child_process";
 import * as fs52 from "node:fs";
-import * as path79 from "node:path";
+import * as path78 from "node:path";
 
 // src/diff/ast-diff.ts
 init_tree_sitter();
@@ -91698,17 +91398,17 @@ async function buildSemanticDiffBlock(directory, changedFiles, maxFiles = 10) {
     const fileConsumers = {};
     if (graph) {
       for (const f of filesToProcess) {
-        const relativePath = path79.isAbsolute(f) ? path79.relative(directory, f) : f;
+        const relativePath = path78.isAbsolute(f) ? path78.relative(directory, f) : f;
         const normalized = normalizeGraphPath2(relativePath);
         fileConsumers[normalized] = getImporters(graph, normalized).length;
         fileConsumers[f] = fileConsumers[normalized];
       }
     }
     for (const filePath of filesToProcess) {
-      const normalizedPath = path79.normalize(filePath);
-      const resolvedPath = path79.resolve(directory, normalizedPath);
-      const relativeToDir = path79.relative(directory, resolvedPath);
-      if (relativeToDir.startsWith("..") || path79.isAbsolute(relativeToDir)) {
+      const normalizedPath = path78.normalize(filePath);
+      const resolvedPath = path78.resolve(directory, normalizedPath);
+      const relativeToDir = path78.relative(directory, resolvedPath);
+      if (relativeToDir.startsWith("..") || path78.isAbsolute(relativeToDir)) {
         continue;
       }
       try {
@@ -91735,7 +91435,7 @@ async function buildSemanticDiffBlock(directory, changedFiles, maxFiles = 10) {
           stdio: "pipe",
           maxBuffer: 5 * 1024 * 1024
         }) : "";
-        const newContent = fs52.readFileSync(path79.join(directory, filePath), "utf-8");
+        const newContent = fs52.readFileSync(path78.join(directory, filePath), "utf-8");
         const astResult = await computeASTDiff(filePath, oldContent, newContent);
         if (astResult && (astResult.changes.length > 0 || astResult.error !== undefined)) {
           astDiffs.push(astResult);
@@ -91778,7 +91478,7 @@ function buildSpecDriftAdvisory(args2) {
 }
 function readSpecStalenessSnapshot2(directory) {
   try {
-    const p = path81.join(directory, ".swarm", "spec-staleness.json");
+    const p = path80.join(directory, ".swarm", "spec-staleness.json");
     if (!fs54.existsSync(p))
       return null;
     const raw = fs54.readFileSync(p, "utf-8");
@@ -92126,7 +91826,7 @@ function createSystemEnhancerHook(config3, directory) {
               await fs54.promises.writeFile(darkMatterPath, darkMatterReport, "utf-8");
               warn(`[system-enhancer] Dark matter scan complete: ${darkMatter.length} co-change patterns found`);
               try {
-                const projectName = path81.basename(path81.resolve(directory));
+                const projectName = path80.basename(path80.resolve(directory));
                 const knowledgeEntries = darkMatterToKnowledgeEntries2(darkMatter, projectName);
                 const knowledgePath = resolveSwarmKnowledgePath(directory);
                 const existingEntries = await readKnowledge(knowledgePath);
@@ -92326,7 +92026,7 @@ ${lines.join(`
             try {
               const taskId_ccp = ccpSession?.currentTaskId;
               if (taskId_ccp && !taskId_ccp.includes("..") && !taskId_ccp.includes("/") && !taskId_ccp.includes("\\") && !taskId_ccp.includes("\x00")) {
-                const evidencePath = path81.join(directory, ".swarm", "evidence", `${taskId_ccp}.json`);
+                const evidencePath = path80.join(directory, ".swarm", "evidence", `${taskId_ccp}.json`);
                 if (fs54.existsSync(evidencePath)) {
                   const evidenceContent = fs54.readFileSync(evidencePath, "utf-8");
                   const evidenceData = JSON.parse(evidenceContent);
@@ -93490,7 +93190,7 @@ import * as fs56 from "node:fs";
 // src/full-auto/policy.ts
 init_constants();
 import * as fs55 from "node:fs";
-import * as path82 from "node:path";
+import * as path81 from "node:path";
 var READ_ONLY_TOOLS = new Set([
   "check_gate_status",
   "completion_verify",
@@ -93689,11 +93389,11 @@ function normalizePath3(p) {
 function isWithinDirectory(target, root) {
   if (!target || !root)
     return false;
-  const resolvedTarget = path82.resolve(target);
-  const resolvedRoot = path82.resolve(root);
+  const resolvedTarget = path81.resolve(target);
+  const resolvedRoot = path81.resolve(root);
   if (resolvedTarget === resolvedRoot)
     return true;
-  const withSep = resolvedRoot.endsWith(path82.sep) ? resolvedRoot : resolvedRoot + path82.sep;
+  const withSep = resolvedRoot.endsWith(path81.sep) ? resolvedRoot : resolvedRoot + path81.sep;
   if (process.platform === "win32") {
     return resolvedTarget.toLowerCase().startsWith(withSep.toLowerCase());
   }
@@ -93752,7 +93452,7 @@ function classifyPathRisk(filePath, context) {
       highRiskBuild: false
     };
   }
-  const absolute = path82.isAbsolute(filePath) ? filePath : path82.resolve(context.directory, filePath);
+  const absolute = path81.isAbsolute(filePath) ? filePath : path81.resolve(context.directory, filePath);
   const resolvedAbsolute = (() => {
     try {
       let candidate = absolute;
@@ -93768,7 +93468,7 @@ function classifyPathRisk(filePath, context) {
           }
           return absolute;
         }
-        const parent = path82.dirname(candidate);
+        const parent = path81.dirname(candidate);
         if (parent === candidate)
           break;
         candidate = parent;
@@ -93780,7 +93480,7 @@ function classifyPathRisk(filePath, context) {
     }
   })();
   const withinProjectRoot = isWithinDirectory(absolute, context.directory) && isWithinDirectory(resolvedAbsolute, context.directory);
-  const relative18 = path82.relative(context.directory, absolute).replace(/\\/g, "/");
+  const relative18 = path81.relative(context.directory, absolute).replace(/\\/g, "/");
   let withinDeclaredScope = null;
   if (Array.isArray(context.declaredScope)) {
     withinDeclaredScope = context.declaredScope.length === 0 ? false : context.declaredScope.some((scope) => {
@@ -94090,7 +93790,7 @@ function classifyFullAutoToolAction(input) {
           recoverable: true
         };
       }
-      if (isProtectedPath(path82.relative(input.directory, path82.resolve(input.directory, p)), config3)) {
+      if (isProtectedPath(path81.relative(input.directory, path81.resolve(input.directory, p)), config3)) {
         return {
           action: "escalate_critic",
           reason: `write to protected path requires critic approval: ${p}`,
@@ -94864,7 +94564,7 @@ init_hive_promoter();
 
 // src/hooks/incremental-verify.ts
 import * as fs58 from "node:fs";
-import * as path83 from "node:path";
+import * as path82 from "node:path";
 
 // src/hooks/spawn-helper.ts
 import * as child_process6 from "node:child_process";
@@ -94942,18 +94642,18 @@ function spawnAsync(command, cwd, timeoutMs) {
 // src/hooks/incremental-verify.ts
 var emittedSkipAdvisories = new Set;
 function detectPackageManager(projectDir) {
-  if (fs58.existsSync(path83.join(projectDir, "bun.lockb")))
+  if (fs58.existsSync(path82.join(projectDir, "bun.lockb")))
     return "bun";
-  if (fs58.existsSync(path83.join(projectDir, "pnpm-lock.yaml")))
+  if (fs58.existsSync(path82.join(projectDir, "pnpm-lock.yaml")))
     return "pnpm";
-  if (fs58.existsSync(path83.join(projectDir, "yarn.lock")))
+  if (fs58.existsSync(path82.join(projectDir, "yarn.lock")))
     return "yarn";
-  if (fs58.existsSync(path83.join(projectDir, "package-lock.json")))
+  if (fs58.existsSync(path82.join(projectDir, "package-lock.json")))
     return "npm";
   return "bun";
 }
 function detectTypecheckCommand(projectDir) {
-  const pkgPath = path83.join(projectDir, "package.json");
+  const pkgPath = path82.join(projectDir, "package.json");
   if (fs58.existsSync(pkgPath)) {
     try {
       const pkg = JSON.parse(fs58.readFileSync(pkgPath, "utf8"));
@@ -94970,8 +94670,8 @@ function detectTypecheckCommand(projectDir) {
         ...pkg.dependencies,
         ...pkg.devDependencies
       };
-      if (!deps?.typescript && !fs58.existsSync(path83.join(projectDir, "tsconfig.json"))) {}
-      const hasTSMarkers = deps?.typescript || fs58.existsSync(path83.join(projectDir, "tsconfig.json"));
+      if (!deps?.typescript && !fs58.existsSync(path82.join(projectDir, "tsconfig.json"))) {}
+      const hasTSMarkers = deps?.typescript || fs58.existsSync(path82.join(projectDir, "tsconfig.json"));
       if (hasTSMarkers) {
         return { command: ["npx", "tsc", "--noEmit"], language: "typescript" };
       }
@@ -94979,13 +94679,13 @@ function detectTypecheckCommand(projectDir) {
       return null;
     }
   }
-  if (fs58.existsSync(path83.join(projectDir, "go.mod"))) {
+  if (fs58.existsSync(path82.join(projectDir, "go.mod"))) {
     return { command: ["go", "vet", "./..."], language: "go" };
   }
-  if (fs58.existsSync(path83.join(projectDir, "Cargo.toml"))) {
+  if (fs58.existsSync(path82.join(projectDir, "Cargo.toml"))) {
     return { command: ["cargo", "check"], language: "rust" };
   }
-  if (fs58.existsSync(path83.join(projectDir, "pyproject.toml")) || fs58.existsSync(path83.join(projectDir, "requirements.txt")) || fs58.existsSync(path83.join(projectDir, "setup.py"))) {
+  if (fs58.existsSync(path82.join(projectDir, "pyproject.toml")) || fs58.existsSync(path82.join(projectDir, "requirements.txt")) || fs58.existsSync(path82.join(projectDir, "setup.py"))) {
     return { command: null, language: "python" };
   }
   try {
@@ -95061,18 +94761,18 @@ ${errorSummary}`);
 init_schema();
 init_state();
 init_logger();
-import { appendFile as appendFile7, mkdir as mkdir15 } from "node:fs/promises";
-import * as path85 from "node:path";
+import { appendFile as appendFile7, mkdir as mkdir14 } from "node:fs/promises";
+import * as path84 from "node:path";
 
 // src/hooks/knowledge-application.ts
 init_logger();
 init_knowledge_store();
 var import_proper_lockfile7 = __toESM(require_proper_lockfile(), 1);
-import { existsSync as existsSync45 } from "node:fs";
-import { appendFile as appendFile6, mkdir as mkdir14, readFile as readFile13 } from "node:fs/promises";
-import * as path84 from "node:path";
+import { existsSync as existsSync44 } from "node:fs";
+import { appendFile as appendFile6, mkdir as mkdir13, readFile as readFile12 } from "node:fs/promises";
+import * as path83 from "node:path";
 function resolveApplicationLogPath(directory) {
-  return path84.join(directory, ".swarm", "knowledge-application.jsonl");
+  return path83.join(directory, ".swarm", "knowledge-application.jsonl");
 }
 var ACK_PATTERN = /KNOWLEDGE_(APPLIED|IGNORED|VIOLATED)\s*:\s*([0-9a-fA-F-]{8,64})(?:\s+reason\s*=\s*([^\n\r]+?))?(?=$|[\n\r]|\s+KNOWLEDGE_)/g;
 function parseAcknowledgments(text) {
@@ -95090,7 +94790,7 @@ function parseAcknowledgments(text) {
 }
 async function appendAudit(directory, record3) {
   const filePath = resolveApplicationLogPath(directory);
-  await mkdir14(path84.dirname(filePath), { recursive: true });
+  await mkdir13(path83.dirname(filePath), { recursive: true });
   await appendFile6(filePath, `${JSON.stringify(record3)}
 `, "utf-8");
 }
@@ -95134,7 +94834,7 @@ async function bumpCountersBatch(directory, bumps) {
   if (applyOne(swarm))
     await rewriteKnowledge(swarmPath, swarm);
   const hivePath = resolveHiveKnowledgePath();
-  if (existsSync45(hivePath)) {
+  if (existsSync44(hivePath)) {
     const hive = await readKnowledge(hivePath);
     if (applyOne(hive))
       await rewriteKnowledge(hivePath, hive);
@@ -95259,8 +94959,8 @@ async function knowledgeApplicationGateBefore(directory, input, config3) {
   }).catch(() => {});
 }
 async function writeWarnEvent(directory, record3) {
-  const filePath = path85.join(directory, ".swarm", "events.jsonl");
-  await mkdir15(path85.dirname(filePath), { recursive: true });
+  const filePath = path84.join(directory, ".swarm", "events.jsonl");
+  await mkdir14(path84.dirname(filePath), { recursive: true });
   await appendFile7(filePath, `${JSON.stringify(record3)}
 `, "utf-8");
 }
@@ -95469,7 +95169,343 @@ init_state();
 init_logger();
 init_curator_drift();
 init_extractors();
-init_knowledge_reader();
+
+// src/hooks/knowledge-reader.ts
+init_logger();
+init_knowledge_store();
+import { existsSync as existsSync45 } from "node:fs";
+import { mkdir as mkdir15, readFile as readFile13, writeFile as writeFile12 } from "node:fs/promises";
+import * as path86 from "node:path";
+var JACCARD_THRESHOLD = 0.6;
+var HIVE_TIER_BOOST = 0.05;
+var SAME_PROJECT_PENALTY = -0.05;
+var NORMAL_RETRIEVAL_STATUSES2 = new Set(["established", "promoted"]);
+function inferCategoriesFromPhase(phaseDescription) {
+  const lower = phaseDescription.toLowerCase();
+  const patterns = [
+    {
+      pattern: /\b(?:test|qa|quality|verification|validation)\b/,
+      categories: ["testing", "debugging"]
+    },
+    {
+      pattern: /\b(?:implement|build|develop|coding|code)\b/,
+      categories: ["tooling", "architecture", "debugging"]
+    },
+    {
+      pattern: /\b(?:integrat|deploy|ci|cd|release|publish)\b/,
+      categories: ["integration", "tooling", "performance"]
+    },
+    {
+      pattern: /\b(?:plan|design|architect|spec|requirement)\b/,
+      categories: ["architecture", "process"]
+    },
+    {
+      pattern: /\b(?:review|refactor|cleanup|polish|optimi)\b/,
+      categories: ["performance", "architecture", "process"]
+    },
+    {
+      pattern: /\b(?:secur|audit|harden|compliance)\b/,
+      categories: ["security", "testing"]
+    },
+    {
+      pattern: /\b(?:setup|config|scaffold|init|bootstrap)\b/,
+      categories: ["tooling", "other"]
+    },
+    {
+      pattern: /\b(?:doc|readme|changelog)\b/,
+      categories: ["process", "tooling"]
+    }
+  ];
+  for (const { pattern, categories } of patterns) {
+    if (pattern.test(lower)) {
+      return categories;
+    }
+  }
+  return ["process", "tooling"];
+}
+async function recordLessonsShown(directory, lessonIds, currentPhase) {
+  const shownFile = path86.join(directory, ".swarm", ".knowledge-shown.json");
+  try {
+    let shownData = {};
+    if (existsSync45(shownFile)) {
+      const content = await readFile13(shownFile, "utf-8");
+      shownData = JSON.parse(content);
+    }
+    const phaseMatch = /^Phase\s+(\d+)/i.exec(currentPhase);
+    const canonicalKey = phaseMatch ? `Phase ${phaseMatch[1]}` : currentPhase;
+    shownData[canonicalKey] = lessonIds;
+    await mkdir15(path86.dirname(shownFile), { recursive: true });
+    await writeFile12(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
+  } catch {
+    warn("[swarm] Knowledge: failed to record shown lessons");
+  }
+}
+async function readMergedKnowledge(directory, config3, context) {
+  const swarmPath = resolveSwarmKnowledgePath(directory);
+  const swarmEntries = await readKnowledge(swarmPath);
+  let hiveEntries = [];
+  if (config3.hive_enabled !== false) {
+    const hivePath = resolveHiveKnowledgePath();
+    hiveEntries = await readKnowledge(hivePath);
+  }
+  const seenLessons = new Set;
+  const merged = [];
+  for (const entry of hiveEntries) {
+    const normalized = normalize2(entry.lesson);
+    seenLessons.add(normalized);
+    merged.push({
+      ...entry,
+      relevanceScore: { category: 0, confidence: 0, keywords: 0 },
+      finalScore: 0
+    });
+  }
+  for (const entry of swarmEntries) {
+    const normalized = normalize2(entry.lesson);
+    if (seenLessons.has(normalized)) {
+      continue;
+    }
+    const swarmBigrams = wordBigrams(normalized);
+    const isHiveNearDup = hiveEntries.some((hiveEntry) => jaccardBigram(swarmBigrams, wordBigrams(normalize2(hiveEntry.lesson))) >= JACCARD_THRESHOLD);
+    if (isHiveNearDup)
+      continue;
+    const isSwarmNearDup = merged.some((m) => m.tier === "swarm" && jaccardBigram(swarmBigrams, wordBigrams(normalize2(m.lesson))) >= JACCARD_THRESHOLD);
+    if (isSwarmNearDup)
+      continue;
+    seenLessons.add(normalized);
+    merged.push({
+      ...entry,
+      relevanceScore: { category: 0, confidence: 0, keywords: 0 },
+      finalScore: 0
+    });
+  }
+  const retractionRecords = await readRetractionRecords(directory);
+  const suppressedLessons = new Set(retractionRecords.map((record3) => record3.normalized_lesson).filter((value) => typeof value === "string" && value.length > 0));
+  const scopeFilter = config3.scope_filter ?? ["global"];
+  const filtered = merged.filter((entry) => scopeFilter.some((pattern) => (entry.scope ?? "global") === pattern) && NORMAL_RETRIEVAL_STATUSES2.has(entry.status) && !suppressedLessons.has(normalize2(entry.lesson)));
+  const ranked = filtered.map((entry) => {
+    let categoryScore = 0;
+    if (context?.currentPhase) {
+      const phaseCategories = inferCategoriesFromPhase(context.currentPhase);
+      if (phaseCategories.includes(entry.category)) {
+        categoryScore = 1;
+      } else if (entry.category === "process") {
+        categoryScore = 0.5;
+      }
+    } else {
+      categoryScore = 0.5;
+    }
+    const confidenceScore = entry.confidence;
+    let keywordsScore = 0;
+    if (context?.techStack && entry.tags.length > 0) {
+      const matchingTags = entry.tags.filter((t) => context.techStack.some((s) => t.toLowerCase().includes(s.toLowerCase()) || s.toLowerCase().includes(t.toLowerCase()))).length;
+      keywordsScore = Math.min(matchingTags / Math.max(entry.tags.length, 1), 1);
+    } else if (entry.tags.length === 0) {
+      keywordsScore = 0.5;
+    }
+    const tierBoost = entry.tier === "hive" ? HIVE_TIER_BOOST : 0;
+    const isSameProjectSource = context?.projectName && entry.tier === "hive" && "source_project" in entry && entry.source_project === context.projectName;
+    const sameProjectPenalty = isSameProjectSource ? SAME_PROJECT_PENALTY : 0;
+    const finalScore = categoryScore * 0.4 + confidenceScore * 0.35 + keywordsScore * 0.25 + tierBoost + sameProjectPenalty;
+    const relevanceScore = {
+      category: categoryScore,
+      confidence: confidenceScore,
+      keywords: keywordsScore
+    };
+    return {
+      ...entry,
+      relevanceScore,
+      finalScore: Math.min(Math.max(finalScore, 0), 1)
+    };
+  });
+  ranked.sort((a, b) => {
+    const scoreDiff = b.finalScore - a.finalScore;
+    if (Math.abs(scoreDiff) > 0.001)
+      return scoreDiff;
+    const dateA = new Date(a.created_at).getTime();
+    const dateB = new Date(b.created_at).getTime();
+    return dateB - dateA;
+  });
+  const maxInject = config3.max_inject_count ?? 5;
+  const topN = ranked.slice(0, maxInject);
+  if (topN.length > 0 && context?.currentPhase) {
+    recordLessonsShown(directory, topN.map((e) => e.id), context.currentPhase).catch((err2) => {
+      warn("[knowledge-reader] recordLessonsShown unexpected rejection:", err2);
+    });
+  }
+  return topN;
+}
+async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
+  const shownFile = path86.join(directory, ".swarm", ".knowledge-shown.json");
+  try {
+    if (!existsSync45(shownFile)) {
+      return;
+    }
+    const content = await readFile13(shownFile, "utf-8");
+    const shownData = JSON.parse(content);
+    const shownIds = shownData[phaseInfo];
+    if (!shownIds || shownIds.length === 0) {
+      return;
+    }
+    const swarmPath = resolveSwarmKnowledgePath(directory);
+    const entries = await readKnowledge(swarmPath);
+    let updated = false;
+    const foundInSwarm = new Set;
+    for (const entry of entries) {
+      if (shownIds.includes(entry.id)) {
+        const ro = entry.retrieval_outcomes;
+        if (phaseSucceeded) {
+          ro.succeeded_after_shown_count = (ro.succeeded_after_shown_count ?? 0) + 1;
+        } else {
+          ro.failed_after_shown_count = (ro.failed_after_shown_count ?? 0) + 1;
+        }
+        updated = true;
+        foundInSwarm.add(entry.id);
+      }
+    }
+    if (updated) {
+      await rewriteKnowledge(swarmPath, entries);
+    }
+    const remainingIds = shownIds.filter((id) => !foundInSwarm.has(id));
+    if (remainingIds.length === 0) {
+      delete shownData[phaseInfo];
+      await writeFile12(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
+      return;
+    }
+    const hivePath = resolveHiveKnowledgePath();
+    const hiveEntries = await readKnowledge(hivePath);
+    let hiveUpdated = false;
+    for (const entry of hiveEntries) {
+      if (remainingIds.includes(entry.id)) {
+        const ro = entry.retrieval_outcomes;
+        if (phaseSucceeded) {
+          ro.succeeded_after_shown_count = (ro.succeeded_after_shown_count ?? 0) + 1;
+        } else {
+          ro.failed_after_shown_count = (ro.failed_after_shown_count ?? 0) + 1;
+        }
+        hiveUpdated = true;
+      }
+    }
+    if (hiveUpdated) {
+      await rewriteKnowledge(hivePath, hiveEntries);
+    }
+    delete shownData[phaseInfo];
+    await writeFile12(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
+  } catch {
+    warn("[swarm] Knowledge: failed to update retrieval outcomes");
+  }
+}
+var DIRECTIVE_BOOST_MIN_CONFIDENCE = 0.75;
+function lc(s) {
+  return (s ?? "").toLowerCase();
+}
+function anyMatch(haystack, needles) {
+  if (needles.length === 0)
+    return false;
+  const hay = haystack.map(lc);
+  return needles.some((n) => hay.some((h) => h.includes(lc(n))));
+}
+function tokenizeContext(ctx) {
+  const parts2 = [];
+  if (ctx.taskTitle)
+    parts2.push(ctx.taskTitle);
+  if (ctx.taskDescription)
+    parts2.push(ctx.taskDescription);
+  if (ctx.lastUserMessage)
+    parts2.push(ctx.lastUserMessage);
+  if (ctx.currentAction)
+    parts2.push(ctx.currentAction);
+  if (ctx.currentTool)
+    parts2.push(ctx.currentTool);
+  if (ctx.targetAgent)
+    parts2.push(ctx.targetAgent);
+  if (ctx.declaredScope)
+    parts2.push(ctx.declaredScope);
+  if (ctx.recentReviewerFailures)
+    parts2.push(...ctx.recentReviewerFailures);
+  if (ctx.recentTestFailures)
+    parts2.push(...ctx.recentTestFailures);
+  if (ctx.recentToolErrors)
+    parts2.push(...ctx.recentToolErrors);
+  if (ctx.planConstraints)
+    parts2.push(...ctx.planConstraints);
+  if (ctx.filePaths)
+    parts2.push(...ctx.filePaths);
+  return parts2.map(lc);
+}
+function scoreDirectiveAgainstContext(entry, ctx) {
+  const haystack = tokenizeContext(ctx);
+  const triggerHit = entry.triggers && entry.triggers.length > 0 ? anyMatch(haystack, entry.triggers) : false;
+  const actionHit = entry.applies_to_tools && entry.applies_to_tools.length > 0 ? entry.applies_to_tools.map(lc).some((t) => t === lc(ctx.currentTool) || t === lc(ctx.currentAction)) : false;
+  const agentHit = entry.applies_to_agents && entry.applies_to_agents.length > 0 ? entry.applies_to_agents.map(lc).some((a) => a === lc(ctx.targetAgent)) : false;
+  let score = 0;
+  if (triggerHit)
+    score += 0.5;
+  if (actionHit)
+    score += 0.35;
+  if (agentHit)
+    score += 0.25;
+  if (entry.directive_priority === "critical")
+    score += 0.4;
+  else if (entry.directive_priority === "high")
+    score += 0.2;
+  else if (entry.directive_priority === "medium")
+    score += 0.1;
+  return { triggerHit, actionHit, agentHit, score: Math.min(1, score) };
+}
+async function readContextualKnowledge(directory, config3, ctx) {
+  const projected = {
+    projectName: ctx.projectName ?? "unknown",
+    currentPhase: ctx.currentPhase ?? "Phase 0",
+    techStack: ctx.techStack,
+    recentErrors: [
+      ...ctx.recentReviewerFailures ?? [],
+      ...ctx.recentTestFailures ?? [],
+      ...ctx.recentToolErrors ?? []
+    ]
+  };
+  const wideCfg = {
+    ...config3,
+    max_inject_count: Math.max(20, config3.max_inject_count ?? 5)
+  };
+  const candidates = await readMergedKnowledge(directory, wideCfg, projected) ?? [];
+  const minConf = typeof config3.directive_min_confidence === "number" ? config3.directive_min_confidence : DIRECTIVE_BOOST_MIN_CONFIDENCE;
+  const rescored = candidates.map((entry) => {
+    const ds = scoreDirectiveAgainstContext(entry, ctx);
+    const confBoost = entry.confidence >= minConf && (ds.actionHit || ds.agentHit) ? 0.25 : 0;
+    const generatedSkillBoost = entry.generated_skill_path && entry.status !== "archived" ? 0.05 : 0;
+    const finalScore = Math.min(1, entry.finalScore + ds.score + confBoost + generatedSkillBoost);
+    return {
+      ...entry,
+      finalScore,
+      __directive: ds
+    };
+  });
+  rescored.sort((a, b) => b.finalScore - a.finalScore);
+  const max = config3.max_inject_count ?? 5;
+  const top = [];
+  const seen = new Set;
+  for (const e of rescored) {
+    if (top.length >= max)
+      break;
+    const ds = e.__directive;
+    const isCritical = e.directive_priority === "critical" && (ds.triggerHit || ds.actionHit || ds.agentHit);
+    if (isCritical && !seen.has(e.id)) {
+      top.push(e);
+      seen.add(e.id);
+    }
+  }
+  for (const e of rescored) {
+    if (top.length >= max)
+      break;
+    if (!seen.has(e.id)) {
+      top.push(e);
+      seen.add(e.id);
+    }
+  }
+  return top.map(({ __directive: _d, ...rest }) => rest);
+}
+
+// src/hooks/knowledge-injector.ts
 init_knowledge_store();
 init_utils2();
 var INJECTION_SENTINEL = "‌[[KNOWLEDGE-INJECTED]]";
@@ -103383,7 +103419,13 @@ var VALID_CATEGORIES3 = [
   "todo",
   "other"
 ];
-var VALID_STATUSES = ["candidate", "established", "promoted"];
+var VALID_STATUSES = [
+  "candidate",
+  "established",
+  "promoted",
+  "archived"
+];
+var DEFAULT_QUERY_STATUSES = new Set(["established", "promoted"]);
 var VALID_TIERS = ["swarm", "hive", "all"];
 function validateTierInput(tier) {
   if (typeof tier !== "string")
@@ -103450,9 +103492,13 @@ async function readHiveKnowledge() {
   }
   return readKnowledge(hivePath);
 }
-function filterSwarmEntries(entries, filters, scopeFilter) {
+function filterSwarmEntries(entries, filters, suppressedLessons, scopeFilter) {
   return entries.filter((entry) => {
-    if (filters.status && entry.status !== filters.status) {
+    if (filters.status) {
+      if (entry.status !== filters.status) {
+        return false;
+      }
+    } else if (!DEFAULT_QUERY_STATUSES.has(entry.status)) {
       return false;
     }
     if (filters.category && entry.category !== filters.category) {
@@ -103467,12 +103513,19 @@ function filterSwarmEntries(entries, filters, scopeFilter) {
         return false;
       }
     }
+    if (suppressedLessons.has(normalize2(entry.lesson))) {
+      return false;
+    }
     return true;
   });
 }
-function filterHiveEntries(entries, filters) {
+function filterHiveEntries(entries, filters, suppressedLessons) {
   return entries.filter((entry) => {
-    if (filters.status && entry.status !== filters.status) {
+    if (filters.status) {
+      if (entry.status !== filters.status) {
+        return false;
+      }
+    } else if (!DEFAULT_QUERY_STATUSES.has(entry.status)) {
       return false;
     }
     if (filters.category && entry.category !== filters.category) {
@@ -103481,6 +103534,9 @@ function filterHiveEntries(entries, filters) {
     if (filters.minScore !== undefined && entry.confidence < filters.minScore) {
       return false;
     }
+    if (suppressedLessons.has(normalize2(entry.lesson))) {
+      return false;
+    }
     return true;
   });
 }
@@ -103519,7 +103575,7 @@ var knowledge_query = createSwarmTool({
   description: 'Query swarm knowledge (project-level) or hive knowledge (cross-project) with optional filters. Returns human-readable formatted text output. Use tier "all" to query both swarm and hive knowledge.',
   args: {
     tier: exports_external.string().optional().describe("Knowledge tier to query: 'swarm', 'hive', or 'all' (default: 'all')"),
-    status: exports_external.string().optional().describe("Filter by status: 'candidate', 'established', or 'promoted'"),
+    status: exports_external.string().optional().describe("Filter by status: 'candidate', 'established', 'promoted', or 'archived'"),
     category: exports_external.string().optional().describe("Filter by category: 'process', 'architecture', 'tooling', 'security', 'testing', 'debugging', 'performance', 'integration', 'todo', or 'other'"),
     min_score: exports_external.number().optional().describe("Minimum confidence score filter (0.0-1.0)"),
     limit: exports_external.number().optional().describe(`Maximum number of results to return (default: ${DEFAULT_LIMIT}, max: 100)`)
@@ -103550,6 +103606,8 @@ var knowledge_query = createSwarmTool({
       category: category ?? undefined,
       minScore: minScore ?? undefined
     };
+    const retractionRecords = await readRetractionRecords(directory);
+    const suppressedLessons = new Set(retractionRecords.map((record3) => record3.normalized_lesson).filter((value) => typeof value === "string" && value.length > 0));
     const results = [];
     let scopeFilter;
     try {
@@ -103558,14 +103616,14 @@ var knowledge_query = createSwarmTool({
     } catch {}
     if (tier === "swarm" || tier === "all") {
       const swarmEntries = await readSwarmKnowledge(directory);
-      const filtered = filterSwarmEntries(swarmEntries, filters, scopeFilter);
+      const filtered = filterSwarmEntries(swarmEntries, filters, suppressedLessons, scopeFilter);
       for (const entry of filtered) {
         results.push({ entry, tier: "swarm" });
       }
     }
     if (tier === "hive" || tier === "all") {
       const hiveEntries = await readHiveKnowledge();
-      const filtered = filterHiveEntries(hiveEntries, filters);
+      const filtered = filterHiveEntries(hiveEntries, filters, suppressedLessons);
       for (const entry of filtered) {
         results.push({ entry, tier: "hive" });
       }
@@ -103824,7 +103882,6 @@ function phaseIsExplicitlyNonCode(directory, phase) {
 init_gate_evidence();
 init_curator();
 init_knowledge_curator();
-init_knowledge_reader();
 init_knowledge_store();
 init_review_receipt();
 init_utils2();