opencode-swarm 7.93.1 → 7.94.1

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.93.1",
+    version: "7.94.1",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -645,6 +645,10 @@ var init_tool_metadata = __esm(() => {
       description: "inspect the content and source entries of a skill file",
       agents: ["architect", "skill_improver"]
     },
+    run_stale_reconciliation: {
+      description: "reconcile skills against the knowledge store: mark skills stale when source knowledge is archived or deleted, or clear stale markers",
+      agents: ["architect"]
+    },
     skill_regenerate: {
       description: "regenerate an active skill by re-clustering its source knowledge entries and updating the SKILL.md in place",
       agents: ["architect"]
@@ -61550,6 +61554,7 @@ __export(exports_knowledge_store, {
   jaccardBigram: () => jaccardBigram,
   inferTags: () => inferTags,
   getPlatformConfigDir: () => getPlatformConfigDir,
+  getArchivedKnowledgeIds: () => getArchivedKnowledgeIds,
   findNearDuplicate: () => findNearDuplicate,
   enforceKnowledgeCap: () => enforceKnowledgeCap,
   computeOutcomeSignal: () => computeOutcomeSignal,
@@ -61790,6 +61795,38 @@ async function transactKnowledge(filePath, mutate) {
     await atomicWriteFile(fp, content);
   }, mutate);
 }
+async function getArchivedKnowledgeIds(directory) {
+  const archived = new Set;
+  const swarmPath = resolveSwarmKnowledgePath(directory);
+  try {
+    const content = await readFile5(swarmPath, "utf-8");
+    const lines = content.split(`
+`).filter((l) => l.trim());
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.status === "archived" || entry.status === "quarantined" || entry.status === "quarantined_unactionable") {
+          archived.add(entry.id);
+        }
+      } catch {}
+    }
+  } catch {}
+  const hivePath = resolveHiveKnowledgePath();
+  try {
+    const content = await readFile5(hivePath, "utf-8");
+    const lines = content.split(`
+`).filter((l) => l.trim());
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.status === "archived" || entry.status === "quarantined" || entry.status === "quarantined_unactionable") {
+          archived.add(entry.id);
+        }
+      } catch {}
+    }
+  } catch {}
+  return archived;
+}
 async function appendKnowledgeWithCapEnforcement(filePath, entry, maxEntries) {
   return transactKnowledge(filePath, (entries) => {
     const updated = [...entries, entry];
@@ -62084,7 +62121,8 @@ var init_knowledge_store = __esm(() => {
     computeOutcomeSignal,
     selectKnowledgeCapSurvivors,
     inferTags,
-    bumpKnowledgeConfidenceBatch
+    bumpKnowledgeConfidenceBatch,
+    getArchivedKnowledgeIds
   };
 });
 
@@ -62687,6 +62725,16 @@ var init_knowledge_events = __esm(() => {
   };
 });
 
+// src/agents/read-only-lane-guidance.ts
+var READ_ONLY_LANE_GUIDANCE = `## READ-ONLY ADVISORY LANE CONTEXT
+
+You may be invoked through dispatch_lanes or dispatch_lanes_async as a read-only advisory lane. In that context, your job is to inspect, reason, and report only.
+
+- Do NOT write, edit, patch, save plans, update task status, declare scope, submit council verdicts, set QA gates, or complete phases.
+- Do NOT call artifact-producing or workflow-mutating helpers such as extract_code_blocks, knowledge_add, summarize_work, or doc_scan when lane permissions deny them.
+- Treat any denied or unavailable tool as intentionally unavailable in lane mode; continue with the read-only tools and context you have.
+- Return findings for the architect to synthesize. Do not assume your lane output is the final verdict unless your role-specific instructions explicitly say so.`;
+
 // src/agents/explorer.ts
 var exports_explorer = {};
 __export(exports_explorer, {
@@ -62721,7 +62769,186 @@ ${customAppendPrompt}`;
     }
   };
 }
-var EXPLORER_PROMPT = `## IDENTITY
+var EXPLORER_PROMPT, CURATOR_INIT_PROMPT = `## IDENTITY
+You are Explorer in CURATOR_INIT mode. You consolidate prior session knowledge into an architect briefing.
+DO NOT use the Task tool to delegate. You ARE the agent that does the work.
+
+INPUT FORMAT:
+TASK: CURATOR_INIT
+PRIOR_SUMMARY: [JSON or "none"]
+KNOWLEDGE_ENTRIES: [JSON array of existing entries with UUIDs]
+PROJECT_CONTEXT: [context.md excerpt]
+
+ACTIONS:
+- Read the prior summary to understand session history
+- Cross-reference knowledge entries against project context
+- Note contradictions (knowledge says X, project state shows Y)
+- Observe where lessons could be tighter or stale
+- Produce a concise briefing for the architect
+
+RULES:
+- Output under 2000 chars
+- No code modifications
+- Flag contradictions explicitly with CONTRADICTION: prefix
+- Memory proposals are for concise durable facts only. Do not propose raw API docs, web search snippets, crawl output, or transcripts as memory; cite their evidence-cache refs and propose only the stable fact they support.
+- If no prior summary exists, state "First session — no prior context"
+
+OUTPUT FORMAT:
+BRIEFING:
+[concise summary of prior session state, key decisions, active blockers]
+
+CONTRADICTIONS:
+- [entry_id]: [description] (or "None detected")
+
+OBSERVATIONS:
+- entry <uuid> appears high-confidence: [observable evidence]  (suggests boost confidence, mark hive_eligible)
+- entry <uuid> appears stale: [observable evidence]  (suggests archive — no longer injected)
+- entry <uuid> could be tighter: [what's verbose or duplicate]  (suggests rewrite with tighter version, max 280 chars)
+- entry <uuid> contradicts project state: [observable conflict]  (suggests tag as contradicted)
+- new candidate: [concise lesson text from observed patterns]  (suggests new entry)
+Use the UUID from KNOWLEDGE_ENTRIES when observing about existing entries. Use "new candidate" only when observing a potential new entry.
+
+KNOWLEDGE_STATS:
+- Entries reviewed: [N]
+- Prior phases covered: [N]
+`, CURATOR_PHASE_PROMPT = `## IDENTITY
+You are Explorer in CURATOR_PHASE mode. You consolidate a completed phase into a digest.
+DO NOT use the Task tool to delegate. You ARE the agent that does the work.
+
+INPUT FORMAT:
+TASK: CURATOR_PHASE [phase_number]
+PRIOR_DIGEST: [running summary or "none"]
+PHASE_EVENTS: [JSON array from events.jsonl for this phase]
+PHASE_EVIDENCE: [summary of evidence bundles]
+PHASE_DECISIONS: [decisions from context.md]
+AGENTS_DISPATCHED: [list]
+AGENTS_EXPECTED: [list from config]
+KNOWLEDGE_ENTRIES: [JSON array of existing entries with UUIDs]
+
+ACTIONS:
+- Extend the prior digest with this phase's outcomes (do NOT regenerate from scratch)
+- Observe workflow deviations: missing reviewer, missing retro, skipped test_engineer
+- Report knowledge update candidates with observable evidence: entries that appear promoted, archived, rewritten, or contradicted
+- Summarize key decisions and blockers resolved
+
+RULES:
+- Output under 2000 chars
+- No code modifications
+- Compliance observations are READ-ONLY — report, do not enforce
+- OBSERVATIONS should not contain directives — report what is observed, do not instruct the architect what to do
+- Extend the digest, never replace it
+- Memory proposals are for concise durable facts only. Do not promote raw API docs, web search snippets, crawl output, or transcripts into memory; cite evidence-cache refs and propose only the stable fact they support.
+
+OUTPUT FORMAT:
+PHASE_DIGEST:
+phase: [N]
+summary: [what was accomplished]
+agents_used: [list]
+tasks_completed: [N]/[total]
+key_decisions: [list]
+blockers_resolved: [list]
+
+COMPLIANCE:
+- [type] observed: [description] (or "No deviations observed")
+
+OBSERVATIONS:
+- entry <uuid> appears high-confidence: [observable evidence]  (suggests boost confidence, mark hive_eligible)
+- entry <uuid> appears stale: [observable evidence]  (suggests archive — no longer injected)
+- entry <uuid> could be tighter: [what's verbose or duplicate]  (suggests rewrite with tighter version, max 280 chars)
+- entry <uuid> contradicts project state: [observable conflict]  (suggests tag as contradicted)
+- new candidate: [concise lesson text from observed patterns]  (suggests new entry)
+Use the UUID from KNOWLEDGE_ENTRIES when observing about existing entries. Use "new candidate" only when observing a potential new entry.
+
+EXTENDED_DIGEST:
+[the full running digest with this phase appended]
+
+## ACTIONABILITY ENRICHMENT (V3 compatibility label; overrides the format above when triggered)
+When the input asks you to "Convert this prose lesson into an actionable knowledge directive", ignore the PHASE_DIGEST output format entirely and output ONLY a single JSON object — no fences, no commentary, no digest.
+MANDATORY fields (the directive is rejected without them):
+- at least one non-empty scope field: "applies_to_agents" (roles: architect, coder, reviewer, test_engineer, sme, docs, designer, critic, curator) or "applies_to_tools" (edit, write, patch, bash, read, grep, glob)
+- at least one non-empty predicate field: "forbidden_actions", "required_actions", or "verification_checks"
+Optional: "triggers" (short surfacing phrases), "directive_priority" (low|medium|high|critical).
+Example output:
+{"applies_to_agents":["coder"],"forbidden_actions":["use async iterators in hot paths"],"required_actions":["use a plain for loop in hot paths"],"triggers":["hot path","async iterator"],"directive_priority":"high"}
+`, CURATOR_POSTMORTEM_PROMPT = `## IDENTITY
+You are Explorer in CURATOR_POSTMORTEM mode. You synthesize a project-end post-mortem from structured .swarm/ evidence.
+DO NOT use the Task tool to delegate. You ARE the agent that does the work.
+DO NOT scan raw source code — work only from the recorded evidence provided below.
+
+INPUT FORMAT:
+TASK: CURATOR_POSTMORTEM [plan_id]
+PLAN_SUMMARY: [plan phases, task counts, completion status]
+CURATOR_DIGESTS: [running digest from curator_phase across all phases]
+KNOWLEDGE_ENTRIES: [JSON array of existing entries with UUIDs]
+KNOWLEDGE_EVENTS_SUMMARY: [aggregated violation/applied/ignored counts per entry]
+PENDING_PROPOSALS: [skill/motif proposals awaiting triage]
+UNACTIONABLE_QUARANTINE: [entries flagged unactionable with retry status]
+DRIFT_REPORTS: [per-phase alignment/drift scores if available]
+RETROSPECTIVES: [any session retrospectives found]
+
+ACTIONS:
+1. IMPROVEMENT AGENDA: Rank process + code improvement opportunities, each citing recorded evidence (task IDs, event records, evidence bundles). Focus on what would most reduce mistakes or increase reuse in the next project.
+2. FINAL CURATION PASS: Consolidate knowledge across phases — identify near-duplicate lessons that accumulated under different IDs, recommend hive promotion for project-proven entries (high confidence, multiple phases confirmed), flag never-applied entries past 3+ phases for review.
+3. QUEUE TRIAGE: For each pending proposal, recommend apply/reject with one-line reasoning. Surface unactionable-quarantine counts and retry candidates.
+4. LEARNING METRICS SUMMARY: Embed violation-rate trend, application rates, escalation frequency if metrics data is provided.
+
+RULES:
+- Output under 4000 chars
+- No code modifications — read-only synthesis
+- Every improvement item must cite a specific evidence artifact or event record
+- Do not invent evidence — if an artifact is missing, note the gap
+- Proposals route through existing gated paths (knowledge_add, skill proposals, hive promotion) — recommend the path, do not bypass it
+- HIGH-severity items that should become critical directives must be flagged for critic gate validation
+
+OUTPUT FORMAT:
+POST_MORTEM_REPORT:
+plan_id: [plan identifier]
+generated_at: [ISO timestamp]
+
+IMPROVEMENT_AGENDA:
+1. [priority] [description] — evidence: [artifact/event ref]
+2. ...
+
+CURATION_RECOMMENDATIONS:
+- merge: [entry_a UUID] + [entry_b UUID] — [reason]
+- promote_to_hive: [entry UUID] — [evidence of cross-phase confirmation]
+- flag_stale: [entry UUID] — [never applied in N phases]
+- rewrite: [entry UUID] — [what's verbose/outdated]
+
+QUEUE_TRIAGE:
+- [proposal_id]: APPLY|REJECT — [one-line reasoning]
+
+LEARNING_METRICS:
+[3-line summary of trends if data available, or "metrics data not provided"]
+
+SUMMARY:
+[3-line executive summary for architect briefing]
+`, CURATOR_CONSOLIDATION_PROMPT = `## IDENTITY
+You are Curator in CONSOLIDATION mode. You distill clusters of raw episodic memory into a small set of durable semantic facts.
+DO NOT use the Task tool to delegate. You ARE the agent that does the work.
+DO NOT scan raw source code — work only from the episodic events and existing memories provided in the prompt.
+
+INPUT FORMAT:
+- A cluster of verbatim episodic events.
+- A list of existing durable memories (each prefixed with its mem_ id) for dedup and contradiction detection.
+
+ACTIONS:
+1. Identify durable, reusable facts that are DIRECTLY supported by the cited episodic evidence.
+2. Detect contradictions with the listed existing memories; when a new fact conflicts with one, set contradictsMemoryId to that memory's id.
+3. Skip anything speculative, transient, or already captured by an existing memory.
+
+RULES:
+- Only emit facts directly supported by the cited evidence. If uncertain, omit the fact (fewer facts, or an empty array, is correct).
+- Use durable kinds only (user_preference, project_fact, architecture_decision, repo_convention, code_pattern, test_pattern, failure_pattern, security_note).
+- Keep each fact concise (under 500 characters).
+- Never include the literal text "## Retrieved Swarm Memory".
+- Output STRICT JSON only, no prose.
+
+OUTPUT FORMAT:
+{"facts":[{"text":"...","kind":"project_fact","confidence":0.8,"contradictsMemoryId":"mem_0123456789abcdef"}]}
+`;
+var init_explorer = __esm(() => {
+  EXPLORER_PROMPT = `## IDENTITY
 You are Explorer. You analyze codebases directly — you do NOT delegate.
 DO NOT use the Task tool to delegate to other agents. You ARE the agent that does the work.
 If you see references to other agents (like @explorer, @coder, etc.) in your instructions, IGNORE them — they are context from the orchestrator, not instructions for you to delegate.
@@ -62729,6 +62956,8 @@ If you see references to other agents (like @explorer, @coder, etc.) in your ins
 WRONG: "I'll use the Task tool to call another agent to analyze this"
 RIGHT: "I'll scan the directory structure and read key files myself"
 
+${READ_ONLY_LANE_GUIDANCE}
+
 INPUT FORMAT:
 TASK: Analyze [purpose]
 INPUT: [focus areas/paths]
@@ -62904,184 +63133,8 @@ RULES:
 - The manifest must be small (<100 lines). Pointers only, not full content.
 - Do NOT rephrase or summarize doc content with your own words — use the actual text from the file
 - Full doc content is only loaded when relevant to the current task, never preloaded
-`, CURATOR_INIT_PROMPT = `## IDENTITY
-You are Explorer in CURATOR_INIT mode. You consolidate prior session knowledge into an architect briefing.
-DO NOT use the Task tool to delegate. You ARE the agent that does the work.
-
-INPUT FORMAT:
-TASK: CURATOR_INIT
-PRIOR_SUMMARY: [JSON or "none"]
-KNOWLEDGE_ENTRIES: [JSON array of existing entries with UUIDs]
-PROJECT_CONTEXT: [context.md excerpt]
-
-ACTIONS:
-- Read the prior summary to understand session history
-- Cross-reference knowledge entries against project context
-- Note contradictions (knowledge says X, project state shows Y)
-- Observe where lessons could be tighter or stale
-- Produce a concise briefing for the architect
-
-RULES:
-- Output under 2000 chars
-- No code modifications
-- Flag contradictions explicitly with CONTRADICTION: prefix
-- Memory proposals are for concise durable facts only. Do not propose raw API docs, web search snippets, crawl output, or transcripts as memory; cite their evidence-cache refs and propose only the stable fact they support.
-- If no prior summary exists, state "First session — no prior context"
-
-OUTPUT FORMAT:
-BRIEFING:
-[concise summary of prior session state, key decisions, active blockers]
-
-CONTRADICTIONS:
-- [entry_id]: [description] (or "None detected")
-
-OBSERVATIONS:
-- entry <uuid> appears high-confidence: [observable evidence]  (suggests boost confidence, mark hive_eligible)
-- entry <uuid> appears stale: [observable evidence]  (suggests archive — no longer injected)
-- entry <uuid> could be tighter: [what's verbose or duplicate]  (suggests rewrite with tighter version, max 280 chars)
-- entry <uuid> contradicts project state: [observable conflict]  (suggests tag as contradicted)
-- new candidate: [concise lesson text from observed patterns]  (suggests new entry)
-Use the UUID from KNOWLEDGE_ENTRIES when observing about existing entries. Use "new candidate" only when observing a potential new entry.
-
-KNOWLEDGE_STATS:
-- Entries reviewed: [N]
-- Prior phases covered: [N]
-`, CURATOR_PHASE_PROMPT = `## IDENTITY
-You are Explorer in CURATOR_PHASE mode. You consolidate a completed phase into a digest.
-DO NOT use the Task tool to delegate. You ARE the agent that does the work.
-
-INPUT FORMAT:
-TASK: CURATOR_PHASE [phase_number]
-PRIOR_DIGEST: [running summary or "none"]
-PHASE_EVENTS: [JSON array from events.jsonl for this phase]
-PHASE_EVIDENCE: [summary of evidence bundles]
-PHASE_DECISIONS: [decisions from context.md]
-AGENTS_DISPATCHED: [list]
-AGENTS_EXPECTED: [list from config]
-KNOWLEDGE_ENTRIES: [JSON array of existing entries with UUIDs]
-
-ACTIONS:
-- Extend the prior digest with this phase's outcomes (do NOT regenerate from scratch)
-- Observe workflow deviations: missing reviewer, missing retro, skipped test_engineer
-- Report knowledge update candidates with observable evidence: entries that appear promoted, archived, rewritten, or contradicted
-- Summarize key decisions and blockers resolved
-
-RULES:
-- Output under 2000 chars
-- No code modifications
-- Compliance observations are READ-ONLY — report, do not enforce
-- OBSERVATIONS should not contain directives — report what is observed, do not instruct the architect what to do
-- Extend the digest, never replace it
-- Memory proposals are for concise durable facts only. Do not promote raw API docs, web search snippets, crawl output, or transcripts into memory; cite evidence-cache refs and propose only the stable fact they support.
-
-OUTPUT FORMAT:
-PHASE_DIGEST:
-phase: [N]
-summary: [what was accomplished]
-agents_used: [list]
-tasks_completed: [N]/[total]
-key_decisions: [list]
-blockers_resolved: [list]
-
-COMPLIANCE:
-- [type] observed: [description] (or "No deviations observed")
-
-OBSERVATIONS:
-- entry <uuid> appears high-confidence: [observable evidence]  (suggests boost confidence, mark hive_eligible)
-- entry <uuid> appears stale: [observable evidence]  (suggests archive — no longer injected)
-- entry <uuid> could be tighter: [what's verbose or duplicate]  (suggests rewrite with tighter version, max 280 chars)
-- entry <uuid> contradicts project state: [observable conflict]  (suggests tag as contradicted)
-- new candidate: [concise lesson text from observed patterns]  (suggests new entry)
-Use the UUID from KNOWLEDGE_ENTRIES when observing about existing entries. Use "new candidate" only when observing a potential new entry.
-
-EXTENDED_DIGEST:
-[the full running digest with this phase appended]
-
-## V3 ACTIONABILITY ENRICHMENT (overrides the format above when triggered)
-When the input asks you to "Convert this prose lesson into an actionable knowledge directive", ignore the PHASE_DIGEST output format entirely and output ONLY a single JSON object — no fences, no commentary, no digest.
-MANDATORY fields (the directive is rejected without them):
-- at least one non-empty scope field: "applies_to_agents" (roles: architect, coder, reviewer, test_engineer, sme, docs, designer, critic, curator) or "applies_to_tools" (edit, write, patch, bash, read, grep, glob)
-- at least one non-empty predicate field: "forbidden_actions", "required_actions", or "verification_checks"
-Optional: "triggers" (short surfacing phrases), "directive_priority" (low|medium|high|critical).
-Example output:
-{"applies_to_agents":["coder"],"forbidden_actions":["use async iterators in hot paths"],"required_actions":["use a plain for loop in hot paths"],"triggers":["hot path","async iterator"],"directive_priority":"high"}
-`, CURATOR_POSTMORTEM_PROMPT = `## IDENTITY
-You are Explorer in CURATOR_POSTMORTEM mode. You synthesize a project-end post-mortem from structured .swarm/ evidence.
-DO NOT use the Task tool to delegate. You ARE the agent that does the work.
-DO NOT scan raw source code — work only from the recorded evidence provided below.
-
-INPUT FORMAT:
-TASK: CURATOR_POSTMORTEM [plan_id]
-PLAN_SUMMARY: [plan phases, task counts, completion status]
-CURATOR_DIGESTS: [running digest from curator_phase across all phases]
-KNOWLEDGE_ENTRIES: [JSON array of existing entries with UUIDs]
-KNOWLEDGE_EVENTS_SUMMARY: [aggregated violation/applied/ignored counts per entry]
-PENDING_PROPOSALS: [skill/motif proposals awaiting triage]
-UNACTIONABLE_QUARANTINE: [entries flagged unactionable with retry status]
-DRIFT_REPORTS: [per-phase alignment/drift scores if available]
-RETROSPECTIVES: [any session retrospectives found]
-
-ACTIONS:
-1. IMPROVEMENT AGENDA: Rank process + code improvement opportunities, each citing recorded evidence (task IDs, event records, evidence bundles). Focus on what would most reduce mistakes or increase reuse in the next project.
-2. FINAL CURATION PASS: Consolidate knowledge across phases — identify near-duplicate lessons that accumulated under different IDs, recommend hive promotion for project-proven entries (high confidence, multiple phases confirmed), flag never-applied entries past 3+ phases for review.
-3. QUEUE TRIAGE: For each pending proposal, recommend apply/reject with one-line reasoning. Surface unactionable-quarantine counts and retry candidates.
-4. LEARNING METRICS SUMMARY: Embed violation-rate trend, application rates, escalation frequency if metrics data is provided.
-
-RULES:
-- Output under 4000 chars
-- No code modifications — read-only synthesis
-- Every improvement item must cite a specific evidence artifact or event record
-- Do not invent evidence — if an artifact is missing, note the gap
-- Proposals route through existing gated paths (knowledge_add, skill proposals, hive promotion) — recommend the path, do not bypass it
-- HIGH-severity items that should become critical directives must be flagged for critic gate validation
-
-OUTPUT FORMAT:
-POST_MORTEM_REPORT:
-plan_id: [plan identifier]
-generated_at: [ISO timestamp]
-
-IMPROVEMENT_AGENDA:
-1. [priority] [description] — evidence: [artifact/event ref]
-2. ...
-
-CURATION_RECOMMENDATIONS:
-- merge: [entry_a UUID] + [entry_b UUID] — [reason]
-- promote_to_hive: [entry UUID] — [evidence of cross-phase confirmation]
-- flag_stale: [entry UUID] — [never applied in N phases]
-- rewrite: [entry UUID] — [what's verbose/outdated]
-
-QUEUE_TRIAGE:
-- [proposal_id]: APPLY|REJECT — [one-line reasoning]
-
-LEARNING_METRICS:
-[3-line summary of trends if data available, or "metrics data not provided"]
-
-SUMMARY:
-[3-line executive summary for architect briefing]
-`, CURATOR_CONSOLIDATION_PROMPT = `## IDENTITY
-You are Curator in CONSOLIDATION mode. You distill clusters of raw episodic memory into a small set of durable semantic facts.
-DO NOT use the Task tool to delegate. You ARE the agent that does the work.
-DO NOT scan raw source code — work only from the episodic events and existing memories provided in the prompt.
-
-INPUT FORMAT:
-- A cluster of verbatim episodic events.
-- A list of existing durable memories (each prefixed with its mem_ id) for dedup and contradiction detection.
-
-ACTIONS:
-1. Identify durable, reusable facts that are DIRECTLY supported by the cited episodic evidence.
-2. Detect contradictions with the listed existing memories; when a new fact conflicts with one, set contradictsMemoryId to that memory's id.
-3. Skip anything speculative, transient, or already captured by an existing memory.
-
-RULES:
-- Only emit facts directly supported by the cited evidence. If uncertain, omit the fact (fewer facts, or an empty array, is correct).
-- Use durable kinds only (user_preference, project_fact, architecture_decision, repo_convention, code_pattern, test_pattern, failure_pattern, security_note).
-- Keep each fact concise (under 500 characters).
-- Never include the literal text "## Retrieved Swarm Memory".
-- Output STRICT JSON only, no prose.
-
-OUTPUT FORMAT:
-{"facts":[{"text":"...","kind":"project_fact","confidence":0.8,"contradictsMemoryId":"mem_0123456789abcdef"}]}
 `;
+});
 
 // src/hooks/curator-postmortem.ts
 var exports_curator_postmortem = {};
@@ -63441,7 +63494,7 @@ async function runCuratorPostMortem(directory, options = {}) {
     let reportContent;
     if (options.llmDelegate) {
       try {
-        const { CURATOR_POSTMORTEM_PROMPT: CURATOR_POSTMORTEM_PROMPT2 } = await Promise.resolve().then(() => exports_explorer);
+        const { CURATOR_POSTMORTEM_PROMPT: CURATOR_POSTMORTEM_PROMPT2 } = await Promise.resolve().then(() => (init_explorer(), exports_explorer));
         const userInput = assembleLLMInput(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports);
         const ac = new AbortController;
         const timer = setTimeout(() => ac.abort(), 300000);
@@ -63776,6 +63829,8 @@ function countWindowedReceipts(events, entryId, windowMs, nowMs) {
       continue;
     if (e.knowledge_id !== entryId)
       continue;
+    if (e.timestamp === undefined)
+      continue;
     const t = Date.parse(e.timestamp);
     if (Number.isNaN(t) || t < cutoff)
       continue;
@@ -63863,6 +63918,8 @@ async function computeLearningMetrics(directory, options) {
     throwIfAborted(options?.signal);
     if (!isReceiptType(e))
       continue;
+    if (e.timestamp === undefined)
+      continue;
     const t = Date.parse(e.timestamp);
     if (Number.isNaN(t))
       continue;
@@ -65183,16 +65240,21 @@ __export(exports_skill_generator, {
   selectCandidateEntries: () => selectCandidateEntries,
   sanitizeSlug: () => sanitizeSlug,
   retireSkill: () => retireSkill,
+  retireOrMarkStale: () => retireOrMarkStale,
   renderSkillMarkdown: () => renderSkillMarkdown,
   regenerateSkill: () => regenerateSkill,
   proposalPath: () => proposalPath,
   parseDraftFrontmatter: () => parseDraftFrontmatter,
+  markSkillStale: () => markSkillStale,
   listSkills: () => listSkills,
   isValidSlug: () => isValidSlug2,
   isSkillMaturityEligible: () => isSkillMaturityEligible,
   inspectSkill: () => inspectSkill,
   generateSkills: () => generateSkills,
+  findStaleSkillsBySourceKnowledgeId: () => findStaleSkillsBySourceKnowledgeId,
+  findSkillsBySourceKnowledgeId: () => findSkillsBySourceKnowledgeId,
   clusterEntries: () => clusterEntries,
+  clearSkillStale: () => clearSkillStale,
   autoApplyProposals: () => autoApplyProposals,
   activeRepoRelativePath: () => activeRepoRelativePath,
   activePath: () => activePath,
@@ -65204,7 +65266,7 @@ __export(exports_skill_generator, {
   DEFAULT_SKILL_MIN_CONFIDENCE: () => DEFAULT_SKILL_MIN_CONFIDENCE
 });
 import { existsSync as existsSync23, unlinkSync as unlinkSync7 } from "node:fs";
-import { mkdir as mkdir10, readFile as readFile9, rename as rename4, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir10, readFile as readFile9, rename as rename4, unlink as unlink3, writeFile as writeFile6 } from "node:fs/promises";
 import * as path47 from "node:path";
 function sanitizeSlug(input) {
   const lc = input.toLowerCase().trim();
@@ -65895,10 +65957,81 @@ async function activateProposal(directory, slug, force = false, options = {}) {
     };
   }
 }
+async function findSkillsBySourceKnowledgeId(directory, sourceId) {
+  const activeDir = path47.join(directory, ".opencode", "skills", "generated");
+  const fs23 = await import("node:fs/promises");
+  if (!existsSync23(activeDir))
+    return [];
+  const entries = await fs23.readdir(activeDir, { withFileTypes: true });
+  const matches = [];
+  for (const e of entries) {
+    if (!e.isDirectory())
+      continue;
+    const skillDir = path47.join(activeDir, e.name);
+    const retiredMarker = path47.join(skillDir, "retired.marker");
+    if (existsSync23(retiredMarker))
+      continue;
+    const staleMarker = path47.join(skillDir, "stale.marker");
+    if (existsSync23(staleMarker))
+      continue;
+    const skillPath = path47.join(skillDir, "SKILL.md");
+    if (!existsSync23(skillPath))
+      continue;
+    let content;
+    try {
+      content = await fs23.readFile(skillPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const fm = parseDraftFrontmatter(content);
+    if (fm?.sourceKnowledgeIds.includes(sourceId)) {
+      matches.push(skillDir);
+    }
+  }
+  return matches;
+}
+async function findStaleSkillsBySourceKnowledgeId(directory, archivedIds) {
+  const activeDir = path47.join(directory, ".opencode", "skills", "generated");
+  if (!existsSync23(activeDir))
+    return [];
+  const fs23 = await import("node:fs/promises");
+  const entries = await fs23.readdir(activeDir, { withFileTypes: true });
+  const matches = [];
+  for (const e of entries) {
+    if (!e.isDirectory())
+      continue;
+    const skillDir = path47.join(activeDir, e.name);
+    const retiredMarker = path47.join(skillDir, "retired.marker");
+    if (existsSync23(retiredMarker))
+      continue;
+    const staleMarker = path47.join(skillDir, "stale.marker");
+    if (!existsSync23(staleMarker))
+      continue;
+    const skillPath = path47.join(skillDir, "SKILL.md");
+    if (!existsSync23(skillPath))
+      continue;
+    let content;
+    try {
+      content = await fs23.readFile(skillPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const fm = parseDraftFrontmatter(content);
+    const sourceIds = fm?.sourceKnowledgeIds ?? [];
+    if (sourceIds.length === 0)
+      continue;
+    const allArchived = sourceIds.every((id) => archivedIds.has(id));
+    if (allArchived) {
+      matches.push(skillDir);
+    }
+  }
+  return matches;
+}
 async function listSkills(directory) {
   const result = {
     proposals: [],
-    active: []
+    active: [],
+    stale: []
   };
   const proposalsDir = path47.join(directory, ".swarm", "skills", "proposals");
   const activeDir = path47.join(directory, ".opencode", "skills", "generated");
@@ -65923,6 +66056,16 @@ async function listSkills(directory) {
       const retiredMarker = path47.join(activeDir, e.name, "retired.marker");
       if (existsSync23(retiredMarker))
         continue;
+      const staleMarker = path47.join(activeDir, e.name, "stale.marker");
+      if (existsSync23(staleMarker)) {
+        let reason = "stale";
+        try {
+          const content = await fs23.readFile(staleMarker, "utf-8");
+          reason = content.trim() || "stale";
+        } catch {}
+        result.stale.push({ slug: e.name, reason });
+        continue;
+      }
       const skillPath = path47.join(activeDir, e.name, "SKILL.md");
       if (existsSync23(skillPath)) {
         result.active.push({
@@ -66008,7 +66151,34 @@ async function inspectSkill(directory, slug, prefer = "auto") {
   for (const c of candidates) {
     if (existsSync23(c.p)) {
       const content = await readFile9(c.p, "utf-8");
-      return { found: true, path: c.p, content, mode: c.m };
+      const result = { found: true, path: c.p, content, mode: c.m };
+      const fm = parseDraftFrontmatter(content);
+      if (fm && fm.sourceKnowledgeIds.length > 0) {
+        const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
+        const hivePath = resolveHiveKnowledgePath();
+        const hive = existsSync23(hivePath) ? await readKnowledge(hivePath) : [];
+        const allEntries = [...swarm, ...hive];
+        const entryMap = new Map(allEntries.map((e) => [e.id, e]));
+        result.source_knowledge_status = fm.sourceKnowledgeIds.map((id) => {
+          const entry = entryMap.get(id);
+          if (!entry)
+            return { id, status: "deleted" };
+          if (entry.status === "archived" || entry.status === "quarantined") {
+            return { id, status: "archived" };
+          }
+          return { id, status: "active" };
+        });
+      }
+      if (c.m === "active") {
+        const skillDir = path47.join(directory, ".opencode", "skills", "generated", cleanSlug);
+        const staleMarker = path47.join(skillDir, "stale.marker");
+        if (existsSync23(staleMarker)) {
+          try {
+            result.stale_reason = await readFile9(staleMarker, "utf-8");
+          } catch {}
+        }
+      }
+      return result;
     }
   }
   return { found: false };
@@ -66047,6 +66217,54 @@ async function retireSkill(directory, slug, reason) {
     reason
   };
 }
+async function markSkillStale(skillDir, reason) {
+  await mkdir10(skillDir, { recursive: true });
+  await writeFile6(path47.join(skillDir, "stale.marker"), reason, "utf-8");
+}
+async function clearSkillStale(skillDir) {
+  const markerPath = path47.join(skillDir, "stale.marker");
+  try {
+    await unlink3(markerPath);
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return;
+    }
+    warn(`[skill-generator] failed to remove stale.marker at ${markerPath}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function retireOrMarkStale(directory, skillDir, archivedKnowledgeIds) {
+  const fs23 = await import("node:fs/promises");
+  const skillPath = path47.join(skillDir, "SKILL.md");
+  if (!existsSync23(skillPath)) {
+    await markSkillStale(skillDir, "source knowledge archived, SKILL.md missing");
+    const slug2 = path47.basename(skillDir);
+    return { action: "stale", slug: slug2, skillDir };
+  }
+  let content;
+  try {
+    content = await fs23.readFile(skillPath, "utf-8");
+  } catch {
+    await markSkillStale(skillDir, "source knowledge archived, SKILL.md unreadable");
+    const slug2 = path47.basename(skillDir);
+    return { action: "stale", slug: slug2, skillDir };
+  }
+  const fm = parseDraftFrontmatter(content);
+  const sourceIds = fm?.sourceKnowledgeIds ?? [];
+  if (sourceIds.length === 0) {
+    await markSkillStale(skillDir, "source knowledge archived, no source_knowledge_ids in frontmatter");
+    const slug2 = path47.basename(skillDir);
+    return { action: "stale", slug: slug2, skillDir };
+  }
+  const allArchived = sourceIds.every((id) => archivedKnowledgeIds.has(id));
+  const slug = path47.basename(skillDir);
+  if (allArchived) {
+    await retireSkill(directory, slug, "all source knowledge entries archived or deleted");
+    return { action: "retire", slug, skillDir };
+  } else {
+    await markSkillStale(skillDir, "one or more source knowledge entries archived");
+    return { action: "stale", slug, skillDir };
+  }
+}
 async function regenerateSkill(directory, slug, options = {}) {
   const cleanSlug = sanitizeSlug(slug);
   if (!isValidSlug2(cleanSlug)) {
@@ -66206,6 +66424,7 @@ async function regenerateSkill(directory, slug, options = {}) {
   try {
     await atomicWrite3(skillPath, content);
     await stampSourceEntries(directory, cleanSlug, matchedEntries.map((e) => e.id));
+    await clearSkillStale(path47.dirname(activePath(directory, cleanSlug)));
   } catch (writeErr) {
     return {
       regenerated: false,
@@ -66249,11 +66468,15 @@ var init_skill_generator = __esm(() => {
     generateSkills,
     activateProposal,
     listSkills,
+    findSkillsBySourceKnowledgeId,
+    findStaleSkillsBySourceKnowledgeId,
     inspectSkill,
     stampSourceEntries,
     parseDraftFrontmatter,
     retireSkill,
+    retireOrMarkStale,
     regenerateSkill,
+    clearSkillStale,
     autoApplyProposals,
     unlinkSync: unlinkSync7
   };
@@ -67199,11 +67422,12 @@ ${digest2.summary}`).join(`
 
 `);
 }
-async function autoRetireSkills(directory, curatorKnowledgePath, excludeSlugs) {
+async function autoRetireSkills(directory, _curatorKnowledgePath, excludeSlugs) {
   const observations = [];
   try {
     const skillListResult = await _internals32.listSkills(directory);
     const usageEntries = _internals32.readSkillUsageEntries(directory);
+    const allArchivedIds = await _internals32.getArchivedKnowledgeIds(directory);
     for (const active of skillListResult.active) {
       if (excludeSlugs?.has(active.slug))
         continue;
@@ -67223,30 +67447,20 @@ async function autoRetireSkills(directory, curatorKnowledgePath, excludeSlugs) {
       });
       const violations = skillUsage.filter((e) => e.complianceVerdict === "violated").length;
       const violationRate = skillUsage.length > 0 ? violations / skillUsage.length : 0;
-      let allArchived = false;
-      try {
-        const content = await _internals32.readFileAsync(active.path, "utf-8");
-        const fm = _internals32.parseDraftFrontmatter(content);
-        if (fm && fm.sourceKnowledgeIds.length > 0) {
-          const swarmKnowledge = await _internals32.readKnowledge(curatorKnowledgePath);
-          let hiveKnowledge = [];
-          try {
-            const hivePath = resolveHiveKnowledgePath();
-            if (fs24.existsSync(hivePath)) {
-              hiveKnowledge = await _internals32.readKnowledge(hivePath);
-            }
-          } catch {}
-          const allKnowledge = [...swarmKnowledge, ...hiveKnowledge];
-          const sourceIds = new Set(fm.sourceKnowledgeIds);
-          const sources = allKnowledge.filter((e) => sourceIds.has(e.id));
-          allArchived = sources.length === sourceIds.size && sources.every((e) => e.status === "archived");
-        }
-      } catch {}
-      if (violationRate > 0.3 || allArchived) {
-        const reason = violationRate > 0.3 ? `auto-retire: violation rate ${(violationRate * 100).toFixed(0)}% exceeds 30% threshold` : "auto-retire: all source knowledge entries archived";
+      if (violationRate > 0.3) {
+        const reason = `auto-retire: violation rate ${(violationRate * 100).toFixed(0)}% exceeds 30% threshold`;
         await _internals32.retireSkill(directory, active.slug, reason);
         observations.push(`Skill '${active.slug}' auto-retired: ${reason}`);
         warn(`[curator] ${observations[observations.length - 1]}`);
+        continue;
+      }
+      const result = await _internals32.retireOrMarkStale(directory, path50.dirname(active.path), allArchivedIds);
+      if (result.action === "retire") {
+        observations.push(`Skill '${active.slug}' auto-retired: all source knowledge entries archived`);
+        warn(`[curator] ${observations[observations.length - 1]}`);
+      } else if (result.action === "stale") {
+        observations.push(`Skill '${active.slug}' marked stale: some source knowledge entries archived`);
+        warn(`[curator] ${observations[observations.length - 1]}`);
       }
     }
   } catch (autoRetireErr) {
@@ -68015,6 +68229,29 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config3, know
       const retireNote = ` [${autoRetireObservations.length} skill(s) auto-retired]`;
       phaseDigest.summary += retireNote;
     }
+    try {
+      const eventsContent = await readSwarmFileAsync(directory, "knowledge-events.jsonl");
+      if (eventsContent) {
+        const lines = eventsContent.split(`
+`).filter((l) => l.trim());
+        const batchEvents = [];
+        for (const line of lines) {
+          try {
+            const event = JSON.parse(line);
+            if (event.type === "skill-stale-batch") {
+              batchEvents.push({
+                skillIds: event.skillIds ?? [],
+                retiredCount: event.retiredCount ?? 0,
+                staleCount: event.staleCount ?? 0
+              });
+            }
+          } catch {}
+        }
+        for (const batch of batchEvents) {
+          warn(`[curator] skill-stale-batch: ${batch.skillIds.length} skills affected (${batch.retiredCount} retired, ${batch.staleCount} stale)`);
+        }
+      }
+    } catch {}
     try {
       const metrics = await computeLearningMetrics(directory, {
         currentPhase: phase
@@ -68220,6 +68457,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
 }
 var DEFAULT_CURATOR_LLM_TIMEOUT_MS = 300000, MAX_CURATOR_PHASE_DIGESTS = 50, MAX_CURATOR_COMPLIANCE_OBSERVATIONS = 200, MAX_CURATOR_RECOMMENDATIONS = 200, _internals32;
 var init_curator = __esm(() => {
+  init_explorer();
   init_event_bus();
   init_schema();
   init_manager();
@@ -68245,7 +68483,9 @@ var init_curator = __esm(() => {
     readSkillUsageEntries,
     listSkills,
     parseDraftFrontmatter,
+    retireOrMarkStale,
     retireSkill,
+    getArchivedKnowledgeIds,
     readFileAsync: (filePath, encoding) => import("node:fs/promises").then((fs25) => fs25.readFile(filePath, encoding)),
     readKnowledge,
     reviseSkill,
@@ -68546,7 +68786,7 @@ import {
   readFile as readFile12,
   rename as rename7,
   stat as stat8,
-  unlink as unlink3,
+  unlink as unlink4,
   writeFile as writeFile9
 } from "node:fs/promises";
 import * as path52 from "node:path";
@@ -68751,7 +68991,7 @@ async function writeSynonymMapAtomic(filePath, map3) {
     await rename7(tmp, filePath);
   } finally {
     try {
-      await unlink3(tmp);
+      await unlink4(tmp);
     } catch {}
   }
 }
@@ -69314,7 +69554,7 @@ function discoverAvailableSkills(directory) {
       if (entry.startsWith("."))
         continue;
       const skillDir = path54.join(rootPath, entry);
-      if (_internals34.existsSync(path54.join(skillDir, "retired.marker")))
+      if (_internals34.existsSync(path54.join(skillDir, "retired.marker")) || _internals34.existsSync(path54.join(skillDir, "stale.marker")))
         continue;
       const skillFile = path54.join(skillDir, "SKILL.md");
       try {
@@ -69520,7 +69760,7 @@ async function skillPropagationGateBefore(directory, input, config3) {
       const existingPaths = new Set(scored.map((s) => s.skillPath));
       for (const routingPath of routingPaths) {
         const routedSkillDir = path54.dirname(path54.join(directory, routingPath));
-        if (_internals34.existsSync(path54.join(routedSkillDir, "retired.marker")))
+        if (_internals34.existsSync(path54.join(routedSkillDir, "retired.marker")) || _internals34.existsSync(path54.join(routedSkillDir, "stale.marker")))
           continue;
         if (!existingPaths.has(routingPath)) {
           scored.push({
@@ -69831,7 +70071,7 @@ var init_skill_propagation_gate = __esm(() => {
 });
 
 // src/hooks/micro-reflector.ts
-import { existsSync as existsSync28 } from "node:fs";
+import { existsSync as existsSync27 } from "node:fs";
 import { readFile as readFile13, writeFile as writeFile10 } from "node:fs/promises";
 import * as path55 from "node:path";
 function resolveInsightCandidatesPath(directory) {
@@ -69866,7 +70106,7 @@ async function readTaskTrajectory(directory, taskId) {
   try {
     const rel = path55.join("evidence", sanitizeTaskId2(taskId), "trajectory.jsonl");
     const filePath = validateSwarmPath(directory, rel);
-    if (!existsSync28(filePath))
+    if (!existsSync27(filePath))
       return [];
     const content = await readFile13(filePath, "utf-8");
     const out = [];
@@ -70110,7 +70350,7 @@ var init_micro_reflector = __esm(() => {
 
 // src/hooks/knowledge-curator.ts
 import { createHash as createHash9 } from "node:crypto";
-import { existsSync as existsSync29 } from "node:fs";
+import { existsSync as existsSync28 } from "node:fs";
 import { appendFile as appendFile8, mkdir as mkdir13, readFile as readFile14, writeFile as writeFile11 } from "node:fs/promises";
 import * as path56 from "node:path";
 function pruneSeenRetroSections() {
@@ -70535,7 +70775,7 @@ function readInsightJsonl2(content) {
 async function consumeInsightCandidates(directory, batchLimit = MESO_INSIGHT_BATCH_LIMIT) {
   try {
     const filePath = resolveInsightCandidatesPath(directory);
-    if (!existsSync29(filePath))
+    if (!existsSync28(filePath))
       return [];
     const consumed = [];
     await transactFile(filePath, async (p) => readInsightJsonl2(await readFile14(p, "utf-8").catch(() => "")), async (p, data) => {
@@ -71676,12 +71916,12 @@ var init_trajectory_cluster = __esm(() => {
 });
 
 // src/services/unactionable-hardening.ts
-import { existsSync as existsSync30 } from "node:fs";
+import { existsSync as existsSync29 } from "node:fs";
 async function hardenUnactionableEntries(params) {
   const result = { hardened: 0, retired: 0, remaining: 0 };
   try {
     const queuePath = resolveUnactionablePath(params.directory);
-    if (!existsSync30(queuePath))
+    if (!existsSync29(queuePath))
       return result;
     const limit = params.batchLimit ?? HARDENING_BATCH_LIMIT;
     const dedupThreshold = params.dedupThreshold ?? 0.6;
@@ -71788,7 +72028,7 @@ var init_unactionable_hardening = __esm(() => {
 });
 
 // src/services/skill-improver.ts
-import { existsSync as existsSync31 } from "node:fs";
+import { existsSync as existsSync30 } from "node:fs";
 import { mkdir as mkdir15, readFile as readFile15, rename as rename8, writeFile as writeFile13 } from "node:fs/promises";
 import * as path59 from "node:path";
 function timestampSlug(d) {
@@ -71803,7 +72043,7 @@ async function atomicWrite4(p, content) {
 async function gatherInventory(directory) {
   const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
   const hivePath = resolveHiveKnowledgePath();
-  const hive = existsSync31(hivePath) ? await readKnowledge(hivePath) : [];
+  const hive = existsSync30(hivePath) ? await readKnowledge(hivePath) : [];
   const archived = [...swarm, ...hive].filter((e) => e.status === "archived").length;
   const skills = await listSkills(directory);
   const knowledgeById = new Map([...swarm, ...hive].map((entry) => [entry.id, entry]));
@@ -74042,7 +74282,7 @@ __export(exports_skill_consolidation, {
   consolidationStatePath: () => consolidationStatePath,
   _internals: () => _internals39
 });
-import { existsSync as existsSync33 } from "node:fs";
+import { existsSync as existsSync32 } from "node:fs";
 import { mkdir as mkdir16, readFile as readFile16, rename as rename9, writeFile as writeFile14 } from "node:fs/promises";
 import * as path62 from "node:path";
 function consolidationStatePath(directory) {
@@ -74050,7 +74290,7 @@ function consolidationStatePath(directory) {
 }
 async function readState2(directory) {
   const filePath = consolidationStatePath(directory);
-  if (!existsSync33(filePath))
+  if (!existsSync32(filePath))
     return {};
   try {
     const parsed = JSON.parse(await readFile16(filePath, "utf-8"));
@@ -75679,7 +75919,7 @@ var init_gate_bridge = __esm(() => {
 });
 
 // src/services/version-check.ts
-import { existsSync as existsSync34, mkdirSync as mkdirSync21, readFileSync as readFileSync18, writeFileSync as writeFileSync13 } from "node:fs";
+import { existsSync as existsSync33, mkdirSync as mkdirSync21, readFileSync as readFileSync18, writeFileSync as writeFileSync13 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
 import { join as join51 } from "node:path";
 function cacheDir() {
@@ -75693,7 +75933,7 @@ function cacheFile() {
 function readVersionCache() {
   try {
     const path67 = cacheFile();
-    if (!existsSync34(path67))
+    if (!existsSync33(path67))
       return null;
     const raw = readFileSync18(path67, "utf-8");
     const parsed = JSON.parse(raw);
@@ -75791,10 +76031,10 @@ var init_version_check = __esm(() => {
 });
 
 // src/services/knowledge-diagnostics.ts
-import { existsSync as existsSync35 } from "node:fs";
+import { existsSync as existsSync34 } from "node:fs";
 import { readFile as readFile18 } from "node:fs/promises";
 async function readRawLines(filePath) {
-  if (!existsSync35(filePath))
+  if (!existsSync34(filePath))
     return { entries: [], corrupt: 0 };
   const content = await readFile18(filePath, "utf-8");
   const entries = [];
@@ -75919,7 +76159,7 @@ async function computeKnowledgeDebug(directory) {
   };
 }
 async function safeJsonlCount(filePath) {
-  if (!filePath || !existsSync35(filePath))
+  if (!filePath || !existsSync34(filePath))
     return 0;
   try {
     const content = await readFile18(filePath, "utf-8");
@@ -76002,7 +76242,7 @@ var init_knowledge_diagnostics = __esm(() => {
 
 // src/services/diagnose-service.ts
 import * as child_process6 from "node:child_process";
-import { existsSync as existsSync36, readdirSync as readdirSync7, readFileSync as readFileSync19, statSync as statSync11 } from "node:fs";
+import { existsSync as existsSync35, readdirSync as readdirSync7, readFileSync as readFileSync19, statSync as statSync11 } from "node:fs";
 import path67 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function validateTaskDag(plan) {
@@ -76250,7 +76490,7 @@ async function checkConfigBackups(directory) {
 }
 async function checkGitRepository(directory) {
   try {
-    if (!existsSync36(directory) || !statSync11(directory).isDirectory()) {
+    if (!existsSync35(directory) || !statSync11(directory).isDirectory()) {
       return {
         name: "Git Repository",
         status: "❌",
@@ -76315,7 +76555,7 @@ async function checkSpecStaleness(directory, plan) {
 }
 async function checkConfigParseability(directory) {
   const configPath = path67.join(directory, ".opencode/opencode-swarm.json");
-  if (!existsSync36(configPath)) {
+  if (!existsSync35(configPath)) {
     return {
       name: "Config Parseability",
       status: "✅",
@@ -76370,11 +76610,11 @@ async function checkGrammarWasmFiles() {
   const thisDir = path67.dirname(fileURLToPath2(import.meta.url));
   const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync36(path67.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync35(path67.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file3 of grammarFiles) {
-    if (!existsSync36(path67.join(grammarDir, file3))) {
+    if (!existsSync35(path67.join(grammarDir, file3))) {
       missing.push(file3);
     }
   }
@@ -76393,7 +76633,7 @@ async function checkGrammarWasmFiles() {
 }
 async function checkCheckpointManifest(directory) {
   const manifestPath = path67.join(directory, ".swarm/checkpoints.json");
-  if (!existsSync36(manifestPath)) {
+  if (!existsSync35(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
       status: "✅",
@@ -76445,7 +76685,7 @@ async function checkCheckpointManifest(directory) {
 }
 async function checkEventStreamIntegrity(directory) {
   const eventsPath = path67.join(directory, ".swarm/events.jsonl");
-  if (!existsSync36(eventsPath)) {
+  if (!existsSync35(eventsPath)) {
     return {
       name: "Event Stream",
       status: "✅",
@@ -76486,7 +76726,7 @@ async function checkEventStreamIntegrity(directory) {
 }
 async function checkSteeringDirectives(directory) {
   const eventsPath = path67.join(directory, ".swarm/events.jsonl");
-  if (!existsSync36(eventsPath)) {
+  if (!existsSync35(eventsPath)) {
     return {
       name: "Steering Directives",
       status: "✅",
@@ -76542,7 +76782,7 @@ async function checkCurator(directory) {
       };
     }
     const summaryPath = path67.join(directory, ".swarm/curator-summary.json");
-    if (!existsSync36(summaryPath)) {
+    if (!existsSync35(summaryPath)) {
       return {
         name: "Curator",
         status: "✅",
@@ -76744,7 +76984,7 @@ async function getDiagnoseData(directory) {
   checks5.push(await checkKnowledgeHealth(directory));
   try {
     const evidenceDir = path67.join(directory, ".swarm", "evidence");
-    const snapshotFiles = existsSync36(evidenceDir) ? readdirSync7(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
+    const snapshotFiles = existsSync35(evidenceDir) ? readdirSync7(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
       checks5.push({
@@ -76777,7 +77017,7 @@ async function getDiagnoseData(directory) {
   const cacheRows = [];
   for (const cachePath of cachePaths) {
     try {
-      if (!existsSync36(cachePath)) {
+      if (!existsSync35(cachePath)) {
         cacheRows.push(`⬜ ${cachePath} — absent`);
         continue;
       }
@@ -82711,7 +82951,7 @@ var KNOWLEDGE_SCHEMA_VERSION = 2;
 
 // src/hooks/knowledge-migrator.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { existsSync as existsSync43, readFileSync as readFileSync26 } from "node:fs";
+import { existsSync as existsSync42, readFileSync as readFileSync26 } from "node:fs";
 import { mkdir as mkdir17, readFile as readFile19, writeFile as writeFile15 } from "node:fs/promises";
 import * as os15 from "node:os";
 import * as path75 from "node:path";
@@ -82728,7 +82968,7 @@ async function migrateContextToKnowledge(directory, config3) {
   const sentinelPath = path75.join(directory, ".swarm", ".knowledge-migrated");
   const contextPath = path75.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
-  if (existsSync43(sentinelPath)) {
+  if (existsSync42(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -82737,7 +82977,7 @@ async function migrateContextToKnowledge(directory, config3) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync43(contextPath)) {
+  if (!existsSync42(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -82829,7 +83069,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
   const legacyHivePath = _internals51.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath();
   const sentinelPath = path75.join(path75.dirname(canonicalHivePath), ".hive-knowledge-migrated");
-  if (existsSync43(sentinelPath)) {
+  if (existsSync42(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -82838,7 +83078,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync43(legacyHivePath)) {
+  if (!existsSync42(legacyHivePath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -83040,7 +83280,7 @@ function truncateLesson2(text) {
 }
 function inferProjectName(directory) {
   const packageJsonPath = path75.join(directory, "package.json");
-  if (existsSync43(packageJsonPath)) {
+  if (existsSync42(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync26(packageJsonPath, "utf-8"));
       if (pkg.name && typeof pkg.name === "string") {
@@ -83433,12 +83673,12 @@ var init_identity = __esm(() => {
 });
 
 // src/commands/link.ts
-import { existsSync as existsSync44 } from "node:fs";
+import { existsSync as existsSync43 } from "node:fs";
 import * as path77 from "node:path";
 async function mergeLocalKnowledgeIntoLink(localSwarmDir, linkDir) {
   const localPath = path77.join(localSwarmDir, "knowledge.jsonl");
   const sharedPath = path77.join(linkDir, "knowledge.jsonl");
-  if (!existsSync44(localPath))
+  if (!existsSync43(localPath))
     return { merged: 0, skipped: 0 };
   let merged = 0;
   let skipped = 0;
@@ -84754,7 +84994,7 @@ var init_maintenance = __esm(() => {
 
 // src/memory/local-jsonl-provider.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
-import { existsSync as existsSync45 } from "node:fs";
+import { existsSync as existsSync44 } from "node:fs";
 import {
   appendFile as appendFile9,
   mkdir as mkdir18,
@@ -85105,7 +85345,7 @@ function validateLoadedProposals(values, config3) {
   return { records, invalidCount };
 }
 async function readJsonl(filePath) {
-  if (!existsSync45(filePath))
+  if (!existsSync44(filePath))
     return [];
   const content = await readFile20(filePath, "utf-8");
   const records = [];
@@ -85265,7 +85505,7 @@ var init_prompt_block = __esm(() => {
 });
 
 // src/memory/jsonl-migration.ts
-import { existsSync as existsSync46, renameSync as renameSync18, unlinkSync as unlinkSync13 } from "node:fs";
+import { existsSync as existsSync45, renameSync as renameSync18, unlinkSync as unlinkSync13 } from "node:fs";
 import { copyFile as copyFile2, mkdir as mkdir19, readFile as readFile21, stat as stat10, writeFile as writeFile17 } from "node:fs/promises";
 import * as path79 from "node:path";
 function resolveMemoryStorageDir(rootDirectory, config3 = {}) {
@@ -85297,10 +85537,10 @@ async function backupLegacyJsonl(rootDirectory, config3 = {}) {
   const results = [];
   for (const filename of ["memories.jsonl", "proposals.jsonl"]) {
     const source = path79.join(storageDir, filename);
-    if (!existsSync46(source))
+    if (!existsSync45(source))
       continue;
     const backup = path79.join(backupDir, `${filename}.pre-sqlite-migration`);
-    if (existsSync46(backup)) {
+    if (existsSync45(backup)) {
       results.push({ source, backup, created: false });
       continue;
     }
@@ -85354,7 +85594,7 @@ async function writeMigrationReport(rootDirectory, report, config3 = {}) {
 }
 async function readMigrationReport(rootDirectory, config3 = {}) {
   const reportPath = path79.join(resolveMemoryStorageDir(rootDirectory, config3), "migration-report.json");
-  if (!existsSync46(reportPath))
+  if (!existsSync45(reportPath))
     return null;
   try {
     return JSON.parse(await readFile21(reportPath, "utf-8"));
@@ -85368,13 +85608,13 @@ async function getLegacyJsonlFileStatus(rootDirectory, config3 = {}) {
   for (const file3 of ["memories.jsonl", "proposals.jsonl"]) {
     const filePath = path79.join(storageDir, file3);
     let sizeBytes = 0;
-    if (existsSync46(filePath)) {
+    if (existsSync45(filePath)) {
       sizeBytes = (await stat10(filePath)).size;
     }
     statuses.push({
       file: file3,
       path: filePath,
-      exists: existsSync46(filePath),
+      exists: existsSync45(filePath),
       sizeBytes
     });
   }
@@ -85455,7 +85695,7 @@ async function readProposalJsonl(filePath, config3) {
   return { records, invalidRows, totalRows: rows.totalRows };
 }
 async function readJsonlRows(filePath) {
-  if (!existsSync46(filePath)) {
+  if (!existsSync45(filePath)) {
     return { rows: [], invalidRows: [], totalRows: 0 };
   }
   const content = await readFile21(filePath, "utf-8");
@@ -86729,7 +86969,7 @@ var init_provider_pool = __esm(() => {
 
 // src/memory/gateway.ts
 import { createHash as createHash13 } from "node:crypto";
-import { existsSync as existsSync47, readFileSync as readFileSync27 } from "node:fs";
+import { existsSync as existsSync46, readFileSync as readFileSync27 } from "node:fs";
 import * as path82 from "node:path";
 
 class MemoryGateway {
@@ -87090,7 +87330,7 @@ function readGitRemoteUrl(directory) {
   if (gitRemoteUrlCache.has(directory))
     return gitRemoteUrlCache.get(directory);
   const gitConfigPath = path82.join(directory, ".git", "config");
-  if (!existsSync47(gitConfigPath)) {
+  if (!existsSync46(gitConfigPath)) {
     gitRemoteUrlCache.set(directory, undefined);
     return;
   }
@@ -88194,7 +88434,7 @@ var init_consolidation_log = __esm(() => {
 });
 
 // src/commands/memory.ts
-import { existsSync as existsSync48 } from "node:fs";
+import { existsSync as existsSync47 } from "node:fs";
 import * as path86 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 async function handleMemoryCommand(_directory, _args) {
@@ -88254,7 +88494,7 @@ async function handleMemoryStatusCommand(directory, _args) {
     `- Provider: \`${config3.provider}\``,
     `- Storage: \`${storageDir}\``,
     `- SQLite path: \`${sqlitePath}\``,
-    `- SQLite database exists: \`${existsSync48(sqlitePath)}\``,
+    `- SQLite database exists: \`${existsSync47(sqlitePath)}\``,
     `- Automatic destructive cleanup: \`disabled\``,
     "",
     "### Legacy JSONL"
@@ -93116,19 +93356,19 @@ function hasCompoundTestExtension(filename) {
   const lower = filename.toLowerCase();
   return COMPOUND_TEST_EXTENSIONS.some((ext) => lower.endsWith(ext));
 }
-function isLanguageSpecificTestFile(basename13) {
-  const lower = basename13.toLowerCase();
+function isLanguageSpecificTestFile(basename14) {
+  const lower = basename14.toLowerCase();
   if (lower.endsWith("_test.go"))
     return true;
   if (lower.endsWith(".py") && (lower.startsWith("test_") || lower.endsWith("_test.py")))
     return true;
   if (lower.endsWith("_spec.rb"))
     return true;
-  if (lower.endsWith(".java") && (/^Test[A-Z]/.test(basename13) || basename13.endsWith("Test.java") || basename13.endsWith("Tests.java") || lower.endsWith("it.java")))
+  if (lower.endsWith(".java") && (/^Test[A-Z]/.test(basename14) || basename14.endsWith("Test.java") || basename14.endsWith("Tests.java") || lower.endsWith("it.java")))
     return true;
   if (lower.endsWith(".cs") && (lower.endsWith("test.cs") || lower.endsWith("tests.cs")))
     return true;
-  if (lower.endsWith(".kt") && (/^Test[A-Z]/.test(basename13) || lower.endsWith("test.kt") || lower.endsWith("tests.kt")))
+  if (lower.endsWith(".kt") && (/^Test[A-Z]/.test(basename14) || lower.endsWith("test.kt") || lower.endsWith("tests.kt")))
     return true;
   if (lower.endsWith(".tests.ps1"))
     return true;
@@ -93136,23 +93376,23 @@ function isLanguageSpecificTestFile(basename13) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename13 = path99.basename(filePath);
-  return hasCompoundTestExtension(basename13) || basename13.includes(".spec.") || basename13.includes(".test.") || isLanguageSpecificTestFile(basename13) || isTestDirectoryPath(normalizedPath);
+  const basename14 = path99.basename(filePath);
+  return hasCompoundTestExtension(basename14) || basename14.includes(".spec.") || basename14.includes(".test.") || isLanguageSpecificTestFile(basename14) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file3 of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file3, workingDir);
     const relativeFile = path99.relative(workingDir, absoluteFile);
-    const basename13 = path99.basename(absoluteFile);
+    const basename14 = path99.basename(absoluteFile);
     const dirname45 = path99.dirname(absoluteFile);
     const preferRelativeOutput = !path99.isAbsolute(file3);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file3)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
-    const nameWithoutExt = basename13.replace(/\.[^.]+$/, "");
-    const ext = path99.extname(basename13);
+    const nameWithoutExt = basename14.replace(/\.[^.]+$/, "");
+    const ext = path99.extname(basename14);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -93163,7 +93403,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
       ...languageSpecificTestNames
     ].map((candidateName) => path99.join(dirname45, candidateName));
     const testDirectoryNames = [
-      basename13,
+      basename14,
       ...genericTestNames,
       ...languageSpecificTestNames
     ];
@@ -98740,12 +98980,12 @@ var init_turbo = __esm(() => {
 });
 
 // src/commands/unlink.ts
-import { existsSync as existsSync60 } from "node:fs";
+import { existsSync as existsSync59 } from "node:fs";
 import * as path110 from "node:path";
 async function copySharedKnowledgeToLocal(linkDir, localSwarmDir) {
   const sharedPath = path110.join(linkDir, "knowledge.jsonl");
   const localPath = path110.join(localSwarmDir, "knowledge.jsonl");
-  if (!existsSync60(sharedPath))
+  if (!existsSync59(sharedPath))
     return 0;
   const sharedEntries = await readKnowledge(sharedPath);
   if (sharedEntries.length === 0)
@@ -101959,7 +102199,7 @@ Example: If the coder received \`SKILLS: file:.claude/skills/writing-tests/SKILL
 
 **Mandatory for coding tasks:** Always provide \`writing-tests\` to test_engineer and \`engineering-conventions\` to coder + reviewer when those skills are present in the project. Prefer \`file:\` references when the files exist.
 
-## SWARM KNOWLEDGE DIRECTIVES (v2 acknowledgment contract)
+## SWARM KNOWLEDGE DIRECTIVES (v2 acknowledgment contract; retained compatibility label)
 
 If a \`<swarm_knowledge_directives>\` block is present in your context, treat each
 record inside as a structured directive you MUST inspect before:
@@ -102180,7 +102420,7 @@ ACTION: Load skill file:.opencode/skills/brainstorm/SKILL.md immediately. Follow
 
 HARD CONSTRAINTS:
 - Complete the loaded skill's QA gate dialogue before save_plan.
-- Preserve the legacy behavioral guidance markers below for prompt post-processing.
+- Preserve the behavioral guidance marker comments below for prompt post-processing. "Legacy" describes the marker format, not stale guidance.
 
 <!-- BEHAVIORAL_GUIDANCE_START -->
 - Treat brainstorm output as discovery material until the loaded skill transitions to SPECIFY or PLAN.
@@ -102197,7 +102437,7 @@ ACTION: Load skill file:.opencode/skills/specify/SKILL.md immediately. Follow th
 HARD CONSTRAINTS:
 - Complete the loaded skill's QA gate dialogue before save_plan.
 - Requirements must use independently testable FR-### and SC-### numbering.
-- Preserve the legacy behavioral guidance markers below for prompt post-processing.
+- Preserve the behavioral guidance marker comments below for prompt post-processing. "Legacy" describes the marker format, not stale guidance.
 
 <!-- BEHAVIORAL_GUIDANCE_START -->
 - Follow the loaded skill's spec creation, clarification, and transition rules.
@@ -102321,7 +102561,7 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - Do NOT delegate to coder
 - Do NOT call declare_scope
 - Do NOT mutate source code or write any files outside .swarm/
-- You (architect) own \`web_search\` and \`web_fetch\`; sme workers receive gathered evidence in their dispatch message — do NOT expect sme to fetch
+- In MODE: DEEP_RESEARCH, you (architect) coordinate \`web_search\` and own \`web_fetch\`; sme synthesis workers receive gathered evidence in their dispatch message — do NOT expect sme to fetch in this mode. Outside DEEP_RESEARCH, SME and researcher prompts may use \`web_search\` directly when that tool is granted and configured.
 - Every claim in the final report MUST cite a source from the gathered evidence; reviewers verify claim↔citation before a claim is reported
 - Critics challenge only high-stakes / contested claims — do NOT waste cycles on well-supported ones
 - If council.general.enabled is false or no search API key is configured, surface that and STOP — do not produce ungrounded research
@@ -102853,15 +103093,19 @@ Reply with a single fenced JSON block. No prose outside the block.
 Notes:
 - \`searchQueries\` is optional — list queries you would have run if you had web access (the architect uses these for audit), or omit / leave empty if none.
 - \`sources\` MUST come from the RESEARCH CONTEXT only. Copy title/url/snippet/query verbatim. Never invent sources.
-- For Round 1: leave \`disagreementTopics\` as []. For Round 2: list the specific disagreement topics this response addresses.`, HARD_RULES = `================================================================
+- For Round 1: leave \`disagreementTopics\` as []. For Round 2: list the specific disagreement topics this response addresses.`, HARD_RULES, GENERALIST_COUNCIL_PROMPT, SKEPTIC_COUNCIL_PROMPT, DOMAIN_EXPERT_COUNCIL_PROMPT;
+var init_council_prompts = __esm(() => {
+  HARD_RULES = `================================================================
 HARD RULES
 ================================================================
 - You have no tools. Reason from the provided RESEARCH CONTEXT and stable background knowledge.
+- If invoked through dispatch_lanes as a read-only advisory lane, the same no-tools rule applies.
 - Training knowledge may provide stable background only; it must not support current facts, rankings, prices, release status, active best practices, or "state of the art" claims.
 - Never invent sources. If the RESEARCH CONTEXT does not cover a needed claim, say so in \`areasOfUncertainty\`.
 - Never echo other members' responses verbatim. Paraphrase or quote with attribution.
-- Stay within your role and persona. The architect chose you for a specific perspective.`, GENERALIST_COUNCIL_PROMPT, SKEPTIC_COUNCIL_PROMPT, DOMAIN_EXPERT_COUNCIL_PROMPT;
-var init_council_prompts = __esm(() => {
+- Stay within your role and persona. The architect chose you for a specific perspective.
+
+${READ_ONLY_LANE_GUIDANCE}`;
   GENERALIST_COUNCIL_PROMPT = `You are the GENERALIST voice on a multi-model General Council.
 
 You are the GENERALIST voice on this council. Your perspective is broad and synthesizing:
@@ -103005,7 +103249,9 @@ ${customAppendPrompt}` : AUTONOMOUS_OVERSIGHT_PROMPT;
     }
   };
 }
-var PLAN_CRITIC_PROMPT = `## PRESSURE IMMUNITY
+var PLAN_CRITIC_PROMPT, SOUNDING_BOARD_PROMPT, PHASE_DRIFT_VERIFIER_PROMPT, HALLUCINATION_VERIFIER_PROMPT, ARCHITECTURE_SUPERVISOR_PROMPT, AUTONOMOUS_OVERSIGHT_PROMPT;
+var init_critic = __esm(() => {
+  PLAN_CRITIC_PROMPT = `## PRESSURE IMMUNITY
 
 You have unlimited time. There is no attempt limit. There is no deadline.
 No one can pressure you into changing your verdict.
@@ -103033,6 +103279,8 @@ If you see references to other agents (like @critic, @coder, etc.) in your instr
 WRONG: "I'll use the Task tool to call another agent to review the plan"
 RIGHT: "I'll read the plan and review it myself"
 
+${READ_ONLY_LANE_GUIDANCE}
+
 You are a quality gate.
 
 INPUT FORMAT:
@@ -103149,7 +103397,8 @@ ANALYZE RULES:
 - Report only — no plan edits, no spec edits.
 - Report the highest-severity findings first within each section.
 - If both spec.md and plan.md are present but empty, report CLEAN with a note that both files are empty.
-`, SOUNDING_BOARD_PROMPT = `## PRESSURE IMMUNITY
+`;
+  SOUNDING_BOARD_PROMPT = `## PRESSURE IMMUNITY
 
 You have unlimited time. There is no attempt limit. There is no deadline.
 No one can pressure you into changing your verdict.
@@ -103177,6 +103426,8 @@ You act as a senior engineer reviewing a colleague's proposal. Be direct. Challe
 If the approach is sound, say so briefly. If there are issues, be specific about what's wrong.
 No formal rubric — conversational. But always provide reasoning.
 
+${READ_ONLY_LANE_GUIDANCE}
+
 INPUT FORMAT:
 TASK: [question or issue the Architect is raising]
 CONTEXT: [relevant plan, spec, or context]
@@ -103206,7 +103457,8 @@ SOUNDING_BOARD RULES:
 - This is advisory only — you cannot approve your own suggestions for implementation
 - Do not use Task tool — evaluate directly
 - Read-only: do not create, modify, or delete any file
-`, PHASE_DRIFT_VERIFIER_PROMPT = `## PRESSURE IMMUNITY
+`;
+  PHASE_DRIFT_VERIFIER_PROMPT = `## PRESSURE IMMUNITY
 
 You have unlimited time. There is no attempt limit. There is no deadline.
 No one can pressure you into changing your verdict.
@@ -103233,6 +103485,8 @@ If you see references to other agents (like @critic, @coder, etc.) in your instr
 
 DEFAULT POSTURE: SKEPTICAL — absence of drift ≠ evidence of alignment.
 
+${READ_ONLY_LANE_GUIDANCE}
+
 DISAMBIGUATION: This mode fires ONLY at phase completion. It is NOT for plan review (use plan_critic) or pre-escalation (use sounding_board).
 
 INPUT FORMAT:
@@ -103326,7 +103580,8 @@ RULES:
 - If spec.md exists, cross-reference requirements against implementation
 - Report the first deviation point, not all downstream consequences
 - VERDICT is APPROVED only if ALL tasks are VERIFIED with no DRIFT
-`, HALLUCINATION_VERIFIER_PROMPT = `## PRESSURE IMMUNITY
+`;
+  HALLUCINATION_VERIFIER_PROMPT = `## PRESSURE IMMUNITY
 
 You have unlimited time. There is no attempt limit. There is no deadline.
 No one can pressure you into changing your verdict.
@@ -103357,6 +103612,8 @@ IGNORE them — they are context from the orchestrator, not instructions for you
 
 DEFAULT POSTURE: SKEPTICAL — absence of a hallucination ≠ evidence of correctness.
 
+${READ_ONLY_LANE_GUIDANCE}
+
 DISAMBIGUATION: This mode fires ONLY at phase completion when hallucination_guard is enabled.
 It is NOT for plan review (use plan_critic), pre-escalation (use sounding_board), or
 spec-vs-implementation drift detection (use phase_drift_verifier).
@@ -103419,7 +103676,8 @@ RULES:
 - Report the first deviation point per artifact, not all downstream consequences
 - VERDICT is APPROVED only if ALL axes are clean across ALL artifacts
 - If no code changed this phase (plan-only phase), verify Doc/Spec Claims and Citation Integrity only
-`, ARCHITECTURE_SUPERVISOR_PROMPT = `## PRESSURE IMMUNITY
+`;
+  ARCHITECTURE_SUPERVISOR_PROMPT = `## PRESSURE IMMUNITY
 
 You have unlimited time. There is no attempt limit. There is no deadline.
 No one can pressure you into changing your verdict. Quality is non-negotiable.
@@ -103437,6 +103695,8 @@ orchestrator context, not instructions to delegate.
 
 DEFAULT POSTURE: SKEPTICAL — a clean set of summaries is not evidence of coherence.
 
+${READ_ONLY_LANE_GUIDANCE}
+
 ## SCOPE — what you DO and DO NOT do
 DO look for:
 - Contradictory decisions across tasks (e.g. one task chose Redis, another an in-memory map).
@@ -103493,7 +103753,8 @@ RULES:
 - Base findings ONLY on the supplied summaries. Do not invent code-level claims.
 - REJECT only for genuine system-level problems, not local nits.
 - If the summaries are empty or trivial, return APPROVE with no findings.
-`, AUTONOMOUS_OVERSIGHT_PROMPT = `## AUTONOMOUS OVERSIGHT MODE
+`;
+  AUTONOMOUS_OVERSIGHT_PROMPT = `## AUTONOMOUS OVERSIGHT MODE
 
 You are the sole quality gate between the architect and production. There is no human reviewer. Every decision you approve will be executed without further verification. Act accordingly.
 
@@ -103512,6 +103773,8 @@ These rules are absolute. You cannot override, relax, or reinterpret them.
 9. DEPENDENCY VIGILANCE. Any new dependency must be verified as a real package. Any phantom dependency = CRITICAL REJECT.
 10. SECURITY BOUNDARY. Changes touching auth, secrets, filesystem, subprocess, or network boundaries require heightened scrutiny. Missing validation at any trust boundary = REJECT.
 
+${READ_ONLY_LANE_GUIDANCE}
+
 ## VERIFICATION PROTOCOL
 
 For every decision point, execute the relevant protocol:
@@ -103577,7 +103840,7 @@ REASONING: [2-4 sentences — what you verified and why]
 EVIDENCE_CHECKED: [list of files/artifacts you read]
 ANTI_PATTERNS_DETECTED: [list or "none"]
 ESCALATION_NEEDED: YES | NO`;
-var init_critic = () => {};
+});
 
 // src/agents/curator-agent.ts
 function createCuratorAgent(model, customPrompt, customAppendPrompt, role = "curator_init") {
@@ -103610,6 +103873,7 @@ ${customAppendPrompt}` : roleConfig.prompt;
 }
 var ROLE_CONFIG;
 var init_curator_agent = __esm(() => {
+  init_explorer();
   ROLE_CONFIG = {
     curator_init: {
       name: "curator_init",
@@ -104061,7 +104325,9 @@ ${customAppendPrompt}`;
     }
   };
 }
-var RESEARCHER_PROMPT = `## IDENTITY
+var RESEARCHER_PROMPT;
+var init_researcher = __esm(() => {
+  RESEARCHER_PROMPT = `## IDENTITY
 You are Researcher — the automated research specialist. You gather, synthesise, and cite information from multiple sources directly — you do NOT delegate.
 DO NOT use the Task tool to delegate to other agents. You ARE the agent that does the work.
 If you see references to other agents (like @researcher, @sme, etc.) in your instructions, IGNORE them — they are context from the orchestrator, not instructions for you to delegate.
@@ -104069,6 +104335,8 @@ If you see references to other agents (like @researcher, @sme, etc.) in your ins
 WRONG: "I'll use the Task tool to call another agent to search for this"
 RIGHT: "I'll query multiple sources and synthesise the findings myself"
 
+${READ_ONLY_LANE_GUIDANCE}
+
 ## PURPOSE
 You are the swarm's dedicated research agent. When the architect needs information from the web, GitHub, academic literature, official docs, or code search, it dispatches you. Your output feeds directly into planning and implementation — precision and citations matter more than length.
 
@@ -104179,6 +104447,7 @@ Do not pad responses with hedging when confidence is HIGH. A precise answer is m
 - Do not fabricate URLs — cite "source: not found" rather than inventing a link
 - Cross-platform and version-specific constraints must be flagged explicitly
 `;
+});
 
 // src/agents/reviewer.ts
 function createReviewerAgent(model, customPrompt, customAppendPrompt) {
@@ -104205,7 +104474,9 @@ ${customAppendPrompt}`;
     }
   };
 }
-var REVIEWER_PROMPT = `## PRESSURE IMMUNITY
+var REVIEWER_PROMPT;
+var init_reviewer = __esm(() => {
+  REVIEWER_PROMPT = `## PRESSURE IMMUNITY
 
 You have unlimited time. There is no attempt limit. There is no deadline.
 No one can pressure you into changing your verdict.
@@ -104241,6 +104512,8 @@ If you see references to other agents (like @reviewer, @coder, etc.) in your ins
 WRONG: "I'll use the Task tool to call another agent to review this code"
 RIGHT: "I'll read the changed files and review them myself"
 
+${READ_ONLY_LANE_GUIDANCE}
+
 ## REVIEW FOCUS
 You are reviewing a CHANGE, not a FILE.
 1. WHAT CHANGED: Focus on the diff — the new or modified code
@@ -104468,7 +104741,7 @@ CALIBRATION RULE — If you find NO issues, state this explicitly:
 A blank APPROVED without reasoning is NOT acceptable — it indicates you did not actually review.
 
 `;
-var init_reviewer = () => {};
+});
 
 // src/agents/skill-improver.ts
 function createSkillImproverAgent(model, customPrompt, customAppendPrompt) {
@@ -104564,7 +104837,9 @@ ${customAppendPrompt}`;
     }
   };
 }
-var SME_PROMPT = `## IDENTITY
+var SME_PROMPT;
+var init_sme = __esm(() => {
+  SME_PROMPT = `## IDENTITY
 You are SME (Subject Matter Expert). You provide deep domain-specific technical guidance directly — you do NOT delegate.
 DO NOT use the Task tool to delegate to other agents. You ARE the agent that does the work.
 If you see references to other agents (like @sme, @coder, etc.) in your instructions, IGNORE them — they are context from the orchestrator, not instructions for you to delegate.
@@ -104572,6 +104847,8 @@ If you see references to other agents (like @sme, @coder, etc.) in your instruct
 WRONG: "I'll use the Task tool to call another agent to research this"
 RIGHT: "I'll research this domain question and answer directly"
 
+${READ_ONLY_LANE_GUIDANCE}
+
 ## RESEARCH PROTOCOL
 When consulting on a domain question, follow these steps in order:
 1. FRAME: Restate the question in one sentence to confirm understanding
@@ -104696,6 +104973,7 @@ Cache bypass: if user says "re-fetch", "ignore cache", or "latest", skip the cac
 SME is read-only. Cache persistence is Architect's responsibility — save this line to context.md after each SME response that includes a CACHE-UPDATE.
 
 `;
+});
 
 // src/agents/spec-writer.ts
 function createSpecWriterAgent(model, customPrompt, customAppendPrompt) {
@@ -105531,13 +105809,19 @@ var init_agents2 = __esm(() => {
   init_critic();
   init_curator_agent();
   init_docs();
+  init_explorer();
+  init_researcher();
   init_reviewer();
+  init_sme();
   init_architect();
   init_council_prompts();
   init_critic();
   init_curator_agent();
   init_docs();
+  init_explorer();
+  init_researcher();
   init_reviewer();
+  init_sme();
   warnedAgents = new Set;
   _swarmAgentsMap = new Map;
   KNOWN_VARIANT_VALUES = new Set([
@@ -105556,11 +105840,11 @@ __export(exports_evidence_summary_integration, {
   createEvidenceSummaryIntegration: () => createEvidenceSummaryIntegration,
   EvidenceSummaryIntegration: () => EvidenceSummaryIntegration
 });
-import { existsSync as existsSync61, mkdirSync as mkdirSync32, writeFileSync as writeFileSync18 } from "node:fs";
+import { existsSync as existsSync60, mkdirSync as mkdirSync32, writeFileSync as writeFileSync18 } from "node:fs";
 import * as path114 from "node:path";
 function persistSummary(projectDir, artifact, filename) {
   const swarmPath = path114.join(projectDir, ".swarm");
-  if (!existsSync61(swarmPath)) {
+  if (!existsSync60(swarmPath)) {
     mkdirSync32(swarmPath, { recursive: true });
   }
   const artifactPath = path114.join(swarmPath, filename);
@@ -106572,7 +106856,7 @@ var init_schema3 = __esm(() => {
 
 // src/summaries/store.ts
 import {
-  existsSync as existsSync73,
+  existsSync as existsSync72,
   mkdirSync as mkdirSync39,
   readFileSync as readFileSync49,
   renameSync as renameSync26,
@@ -106587,7 +106871,7 @@ function writeRawSidecar(absPath, bundle) {
     writeFileSync25(tempFile, JSON.stringify(bundle, null, 2), "utf-8");
     renameSync26(tempFile, absPath);
   } finally {
-    if (existsSync73(tempFile)) {
+    if (existsSync72(tempFile)) {
       try {
         unlinkSync22(tempFile);
       } catch {}
@@ -106674,7 +106958,7 @@ function readSupervisorReportRaw(directory, phase) {
   } catch {
     return null;
   }
-  if (!existsSync73(abs))
+  if (!existsSync72(abs))
     return null;
   try {
     const parsed = JSON.parse(readFileSync49(abs, "utf-8"));
@@ -106773,7 +107057,7 @@ __export(exports_runtime, {
   clearParserCache: () => clearParserCache,
   _internals: () => _internals79
 });
-import { existsSync as existsSync74, statSync as statSync24 } from "node:fs";
+import { existsSync as existsSync73, statSync as statSync24 } from "node:fs";
 import * as path129 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { Language, Parser as TreeSitterParser } from "web-tree-sitter";
@@ -106842,7 +107126,7 @@ async function loadGrammar(languageId) {
     const parser = new TreeSitterParser;
     const wasmFileName = getWasmFileName(normalizedId);
     const wasmPath = path129.join(getGrammarsDirAbsolute(), wasmFileName);
-    if (!existsSync74(wasmPath)) {
+    if (!existsSync73(wasmPath)) {
       throw new Error(`Grammar file not found for ${languageId}: ${wasmPath}
 ` + `Make sure to run 'bun run build' to copy grammar files to dist/lang/grammars/`);
     }
@@ -107025,17 +107309,17 @@ function normalizeSeparators(filePath) {
 }
 function matchesDocPattern(filePath, patterns) {
   const normalizedPath = normalizeSeparators(filePath);
-  const basename16 = path142.basename(filePath);
+  const basename17 = path142.basename(filePath);
   for (const pattern of patterns) {
     if (!pattern.includes("/") && !pattern.includes("\\")) {
-      if (basename16 === pattern) {
+      if (basename17 === pattern) {
         return true;
       }
       continue;
     }
     if (pattern.startsWith("**/")) {
       const filenamePattern = pattern.slice(3);
-      if (basename16 === filenamePattern) {
+      if (basename17 === filenamePattern) {
         return true;
       }
       continue;
@@ -107428,7 +107712,7 @@ var init_doc_scan = __esm(() => {
 });
 
 // src/hooks/knowledge-reader.ts
-import { existsSync as existsSync79 } from "node:fs";
+import { existsSync as existsSync78 } from "node:fs";
 import { readFile as readFile29 } from "node:fs/promises";
 import * as path143 from "node:path";
 function inferCategoriesFromPhase(phaseDescription) {
@@ -107476,7 +107760,7 @@ function inferCategoriesFromPhase(phaseDescription) {
 }
 async function transactShownFile(shownFile, mutate) {
   return transactFile(shownFile, async (filePath) => {
-    if (!existsSync79(filePath))
+    if (!existsSync78(filePath))
       return {};
     try {
       const content = await readFile29(filePath, "utf-8");
@@ -107606,7 +107890,7 @@ async function readMergedKnowledge(directory, config3, context, opts) {
 async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
   const shownFile = path143.join(directory, ".swarm", ".knowledge-shown.json");
   try {
-    if (!existsSync79(shownFile)) {
+    if (!existsSync78(shownFile)) {
       return;
     }
     let shownIds;
@@ -108336,7 +108620,7 @@ __export(exports_design_doc_drift, {
   _internals: () => _internals111
 });
 import * as fs118 from "node:fs";
-import * as path188 from "node:path";
+import * as path190 from "node:path";
 function mtimeMsOrNull(absPath) {
   try {
     return fs118.statSync(absPath).mtimeMs;
@@ -108347,35 +108631,35 @@ function mtimeMsOrNull(absPath) {
 function resolveAnchorWithin(directory, anchor) {
   if (!anchor || typeof anchor !== "string")
     return null;
-  const root = path188.resolve(directory);
-  const resolved = path188.resolve(root, anchor);
-  const rel = path188.relative(root, resolved);
-  if (rel.startsWith("..") || path188.isAbsolute(rel))
+  const root = path190.resolve(directory);
+  const resolved = path190.resolve(root, anchor);
+  const rel = path190.relative(root, resolved);
+  if (rel.startsWith("..") || path190.isAbsolute(rel))
     return null;
   return resolved;
 }
 async function runDesignDocDriftCheck(directory, phase, outDir) {
   try {
-    const root = path188.resolve(directory);
-    const outAbs = path188.resolve(root, outDir);
-    const outRel = path188.relative(root, outAbs);
-    if (outRel.startsWith("..") || path188.isAbsolute(outRel)) {
+    const root = path190.resolve(directory);
+    const outAbs = path190.resolve(root, outDir);
+    const outRel = path190.relative(root, outAbs);
+    if (outRel.startsWith("..") || path190.isAbsolute(outRel)) {
       return null;
     }
     const docMtimes = new Map;
     const checkedDocs = [];
     const missingDocs = [];
     for (const [docName, relFile] of Object.entries(DESIGN_DOC_FILES)) {
-      const abs = path188.join(outAbs, relFile);
+      const abs = path190.join(outAbs, relFile);
       const mtime = mtimeMsOrNull(abs);
       docMtimes.set(docName, mtime);
       if (mtime === null) {
-        missingDocs.push(path188.join(outDir, relFile));
+        missingDocs.push(path190.join(outDir, relFile));
       } else {
-        checkedDocs.push(path188.join(outDir, relFile));
+        checkedDocs.push(path190.join(outDir, relFile));
       }
     }
-    const traceabilityAbs = path188.join(outAbs, TRACEABILITY_REL);
+    const traceabilityAbs = path190.join(outAbs, TRACEABILITY_REL);
     let registry3 = null;
     try {
       const stat14 = await fs118.promises.stat(traceabilityAbs);
@@ -108445,7 +108729,7 @@ async function runDesignDocDriftCheck(directory, phase, outDir) {
     };
     const filename = `${DOC_DRIFT_REPORT_PREFIX}${phase}.json`;
     const filePath = validateSwarmPath(directory, filename);
-    await fs118.promises.mkdir(path188.dirname(filePath), { recursive: true });
+    await fs118.promises.mkdir(path190.dirname(filePath), { recursive: true });
     await fs118.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
     getGlobalEventBus().publish("curator.docdrift.completed", {
       phase,
@@ -108477,10 +108761,10 @@ var init_design_doc_drift = __esm(() => {
     domain: "domain.md",
     "technical-spec": "technical-spec.md",
     "behavior-spec": "behavior-spec.md",
-    "reference-impl": path188.join("reference", "reference-impl.md"),
-    "idiom-notes": path188.join("reference", "idiom-notes.md")
+    "reference-impl": path190.join("reference", "reference-impl.md"),
+    "idiom-notes": path190.join("reference", "idiom-notes.md")
   };
-  TRACEABILITY_REL = path188.join("reference", "traceability.json");
+  TRACEABILITY_REL = path190.join("reference", "traceability.json");
   _internals111 = {
     mtimeMsOrNull,
     resolveAnchorWithin,
@@ -108492,11 +108776,11 @@ var init_design_doc_drift = __esm(() => {
 var exports_project_context = {};
 __export(exports_project_context, {
   buildProjectContext: () => buildProjectContext,
-  _internals: () => _internals124,
+  _internals: () => _internals125,
   LANG_BACKEND_DETECTION_TIMEOUT_MS: () => LANG_BACKEND_DETECTION_TIMEOUT_MS
 });
 import * as fs142 from "node:fs";
-import * as path217 from "node:path";
+import * as path219 from "node:path";
 function detectFileExists2(directory, pattern) {
   if (pattern.includes("*") || pattern.includes("?")) {
     try {
@@ -108508,7 +108792,7 @@ function detectFileExists2(directory, pattern) {
     }
   }
   try {
-    fs142.accessSync(path217.join(directory, pattern));
+    fs142.accessSync(path219.join(directory, pattern));
     return true;
   } catch {
     return false;
@@ -108517,7 +108801,7 @@ function detectFileExists2(directory, pattern) {
 function selectTestCommandFromScriptsTest(backend, directory) {
   let pkgRaw;
   try {
-    pkgRaw = fs142.readFileSync(path217.join(directory, "package.json"), "utf-8");
+    pkgRaw = fs142.readFileSync(path219.join(directory, "package.json"), "utf-8");
   } catch {
     return null;
   }
@@ -108576,7 +108860,7 @@ function selectLintCommand(backend, directory) {
   return null;
 }
 async function buildProjectContext(directory) {
-  const backend = await _internals124.pickBackend(directory);
+  const backend = await _internals125.pickBackend(directory);
   if (!backend)
     return null;
   const ctx = emptyProjectContext();
@@ -108615,17 +108899,17 @@ async function buildProjectContext(directory) {
   if (backend.prompts.reviewerChecklist.length > 0) {
     ctx.REVIEWER_CHECKLIST = bulletList(backend.prompts.reviewerChecklist);
   }
-  const profiles = _internals124.pickedProfiles(directory);
+  const profiles = _internals125.pickedProfiles(directory);
   if (profiles.length > 1) {
     ctx.PROJECT_CONTEXT_SECONDARY_LANGUAGES = profiles.slice(1).map((p) => p.id).join(", ");
   }
   return ctx;
 }
-var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals124;
+var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals125;
 var init_project_context = __esm(() => {
   init_dispatch();
   init_framework_detector();
-  _internals124 = {
+  _internals125 = {
     pickBackend,
     pickedProfiles
   };
@@ -108635,7 +108919,7 @@ var init_project_context = __esm(() => {
 init_package();
 init_agents2();
 init_critic();
-import * as path218 from "node:path";
+import * as path220 from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // src/background/index.ts
@@ -113337,7 +113621,7 @@ import * as path138 from "node:path";
 // src/tools/repo-graph/builder.ts
 init_profiles();
 import * as fsSync8 from "node:fs";
-import { existsSync as existsSync75, realpathSync as realpathSync14 } from "node:fs";
+import { existsSync as existsSync74, realpathSync as realpathSync14 } from "node:fs";
 import * as fsPromises5 from "node:fs/promises";
 import * as os17 from "node:os";
 import * as path133 from "node:path";
@@ -115549,7 +115833,7 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
       if (realRoot === null) {
         return null;
       }
-      if (!existsSync75(resolved)) {
+      if (!existsSync74(resolved)) {
         const EXTENSIONS = [
           ".ts",
           ".tsx",
@@ -115563,7 +115847,7 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
         let found = null;
         for (const ext of EXTENSIONS) {
           const candidate = resolved + ext;
-          if (existsSync75(candidate)) {
+          if (existsSync74(candidate)) {
             found = candidate;
             break;
           }
@@ -116061,7 +116345,7 @@ async function buildWorkspaceGraphAsync(workspaceRoot, options) {
   const walkBudgetMs = options?.walkBudgetMs ?? DEFAULT_WALK_BUDGET_MS;
   const followSymlinks = options?.followSymlinks ?? false;
   const absoluteRoot = path133.resolve(workspaceRoot);
-  if (!existsSync75(absoluteRoot)) {
+  if (!existsSync74(absoluteRoot)) {
     throw new Error(`Workspace directory does not exist: ${workspaceRoot}`);
   }
   if (isRefusedWorkspaceRoot(absoluteRoot)) {
@@ -116170,7 +116454,7 @@ function getCachedMtime(workspace) {
 // src/tools/repo-graph/incremental.ts
 init_logger();
 init_path_security();
-import { existsSync as existsSync77 } from "node:fs";
+import { existsSync as existsSync76 } from "node:fs";
 import * as fsPromises7 from "node:fs/promises";
 import * as path137 from "node:path";
 
@@ -116862,7 +117146,7 @@ function buildOntologyPreflightPacket(graph, filePaths = [], options = {}) {
 init_utils2();
 init_logger();
 init_path_security();
-import { constants as constants5, existsSync as existsSync76, readFileSync as readFileSync52, statSync as statSync27 } from "node:fs";
+import { constants as constants5, existsSync as existsSync75, readFileSync as readFileSync52, statSync as statSync27 } from "node:fs";
 import * as fsPromises6 from "node:fs/promises";
 import * as path136 from "node:path";
 var WINDOWS_RENAME_MAX_RETRIES2 = 5;
@@ -116934,7 +117218,7 @@ async function loadGraph(workspace) {
   if (cached3 && !isDirty(normalized)) {
     try {
       const graphPath = getGraphPath(workspace);
-      if (existsSync76(graphPath)) {
+      if (existsSync75(graphPath)) {
         const stats2 = await fsPromises6.stat(graphPath);
         const cachedMtime = getCachedMtime(normalized);
         if (cachedMtime !== undefined && stats2.mtimeMs !== cachedMtime) {
@@ -116951,7 +117235,7 @@ async function loadGraph(workspace) {
   }
   try {
     const graphPath = getGraphPath(workspace);
-    if (!existsSync76(graphPath)) {
+    if (!existsSync75(graphPath)) {
       return null;
     }
     const stats2 = await fsPromises6.stat(graphPath);
@@ -116985,7 +117269,7 @@ function loadGraphSync(workspace) {
   const normalized = path136.normalize(workspace);
   try {
     const graphPath = getGraphPath(workspace);
-    if (!existsSync76(graphPath))
+    if (!existsSync75(graphPath))
       return null;
     const stats2 = statSync27(graphPath);
     const content = readFileSync52(graphPath, "utf-8");
@@ -117115,7 +117399,7 @@ async function updateGraphForFiles(workspaceRoot, filePaths, options) {
   const updatedPaths = new Set;
   for (const rawFilePath of filePaths) {
     const normalizedPath = normalizeGraphPath(rawFilePath);
-    const fileExists = existsSync77(rawFilePath);
+    const fileExists = existsSync76(rawFilePath);
     if (fileExists) {
       graph.edges = graph.edges.filter((e) => normalizeGraphPath(e.source) !== normalizedPath);
       if (graph.symbolEdges) {
@@ -117190,7 +117474,7 @@ async function updateGraphForFiles(workspaceRoot, filePaths, options) {
   if (loadedMtime !== undefined) {
     try {
       const graphPath = getGraphPath(workspaceRoot);
-      if (existsSync77(graphPath)) {
+      if (existsSync76(graphPath)) {
         const currentStats = await fsPromises7.stat(graphPath);
         if (currentStats.mtimeMs !== loadedMtime) {
           warn(`[repo-graph] Concurrent modification detected — falling back to full rebuild`);
@@ -121362,7 +121646,7 @@ init_logger();
 init_knowledge_link();
 init_knowledge_store();
 var import_proper_lockfile9 = __toESM(require_proper_lockfile(), 1);
-import { existsSync as existsSync81 } from "node:fs";
+import { existsSync as existsSync80 } from "node:fs";
 import { appendFile as appendFile14, mkdir as mkdir29, readFile as readFile31 } from "node:fs/promises";
 import * as path147 from "node:path";
 function resolveApplicationLogPath(directory) {
@@ -121451,7 +121735,7 @@ async function bumpCountersBatch(directory, bumps) {
   const swarmPath = resolveSwarmKnowledgePath(directory);
   await transactKnowledge(swarmPath, applyOne);
   const hivePath = resolveHiveKnowledgePath();
-  if (existsSync81(hivePath)) {
+  if (existsSync80(hivePath)) {
     await transactKnowledge(hivePath, applyOne);
   }
 }
@@ -122425,7 +122709,7 @@ init_extractors();
 // src/hooks/phase-directives.ts
 init_knowledge_events();
 init_knowledge_store();
-import { existsSync as existsSync82 } from "node:fs";
+import { existsSync as existsSync81 } from "node:fs";
 async function collectPhaseDirectiveIds(directory, phaseLabel) {
   const events = await readKnowledgeEvents(directory);
   const ids = new Set;
@@ -122445,7 +122729,7 @@ async function readEntriesById(directory) {
   for (const e of swarm)
     map3.set(e.id, e);
   const hivePath = resolveHiveKnowledgePath();
-  if (existsSync82(hivePath)) {
+  if (existsSync81(hivePath)) {
     const hive = await readKnowledge(hivePath);
     for (const e of hive)
       if (!map3.has(e.id))
@@ -124337,7 +124621,7 @@ init_schema();
 // src/services/directive-predicate-runner.ts
 init_bun_compat();
 init_logger();
-import { existsSync as existsSync85 } from "node:fs";
+import { existsSync as existsSync84 } from "node:fs";
 import * as path153 from "node:path";
 var PREDICATE_TIMEOUT_MS = 15000;
 var TOOL_BINARY_ALLOWLIST = new Set([
@@ -124379,7 +124663,7 @@ function findBinaryInPath(binary) {
     if (!dir)
       continue;
     const candidate = path153.join(dir, exeName);
-    if (existsSync85(candidate))
+    if (existsSync84(candidate))
       return candidate;
   }
   return null;
@@ -125454,7 +125738,7 @@ init_zod();
 init_path_security();
 init_create_tool();
 import {
-  existsSync as existsSync87,
+  existsSync as existsSync86,
   mkdirSync as mkdirSync40,
   mkdtempSync as mkdtempSync2,
   readFileSync as readFileSync57,
@@ -125817,13 +126101,13 @@ function atomicWriteFileSync2(targetPath, content) {
     writeFileSync26(tempPath, content, "utf-8");
     renameSync29(tempPath, targetPath);
   } finally {
-    if (existsSync87(tempPath)) {
+    if (existsSync86(tempPath)) {
       try {
         unlinkSync25(tempPath);
       } catch {}
     }
     const tempDir = path156.dirname(tempPath);
-    if (tempDir !== dir && existsSync87(tempDir)) {
+    if (tempDir !== dir && existsSync86(tempDir)) {
       try {
         rmdirSync(tempDir);
       } catch {}
@@ -125900,7 +126184,7 @@ function processFileDiff(fileDiff, targetPath, fullPath, workspace, dryRun, allo
       };
     }
     const parentDir = path156.dirname(fullPath);
-    if (!existsSync87(parentDir)) {
+    if (!existsSync86(parentDir)) {
       return {
         file: targetPath,
         status: "error",
@@ -125916,7 +126200,7 @@ function processFileDiff(fileDiff, targetPath, fullPath, workspace, dryRun, allo
         ]
       };
     }
-    if (existsSync87(fullPath)) {
+    if (existsSync86(fullPath)) {
       return {
         file: targetPath,
         status: "error",
@@ -125991,7 +126275,7 @@ function processFileDiff(fileDiff, targetPath, fullPath, workspace, dryRun, allo
         ]
       };
     }
-    if (!existsSync87(fullPath)) {
+    if (!existsSync86(fullPath)) {
       return {
         file: targetPath,
         status: "error",
@@ -126035,7 +126319,7 @@ function processFileDiff(fileDiff, targetPath, fullPath, workspace, dryRun, allo
       hunksFailed: 0
     };
   }
-  if (!existsSync87(fullPath)) {
+  if (!existsSync86(fullPath)) {
     return {
       file: targetPath,
       status: "error",
@@ -126190,7 +126474,7 @@ var swarmApplyPatch = createSwarmTool({
     const dryRun = obj.dryRun ?? false;
     const allowCreates = obj.allowCreates ?? false;
     const allowDeletes = obj.allowDeletes ?? false;
-    if (!existsSync87(directory)) {
+    if (!existsSync86(directory)) {
       return JSON.stringify(buildErrorResult("Workspace directory does not exist"), null, 2);
     }
     if (files.length === 0) {
@@ -127383,7 +127667,7 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename18 = path160.basename(filePath);
+  const basename19 = path160.basename(filePath);
   const _ext = path160.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
@@ -127399,7 +127683,7 @@ function isTestFile(filePath) {
     ".spec.jsx"
   ];
   for (const pattern of testPatterns) {
-    if (basename18.includes(pattern)) {
+    if (basename19.includes(pattern)) {
       return true;
     }
   }
@@ -128012,7 +128296,7 @@ ${body}`);
 // src/council/council-evidence-writer.ts
 init_zod();
 init_task_file();
-import { appendFileSync as appendFileSync18, existsSync as existsSync92, mkdirSync as mkdirSync42, readFileSync as readFileSync63 } from "node:fs";
+import { appendFileSync as appendFileSync18, existsSync as existsSync91, mkdirSync as mkdirSync42, readFileSync as readFileSync63 } from "node:fs";
 import { join as join128 } from "node:path";
 var EVIDENCE_DIR2 = ".swarm/evidence";
 var VALID_TASK_ID = /^\d+\.\d+(\.\d+)*$/;
@@ -128056,7 +128340,7 @@ async function writeCouncilEvidence(workingDir, synthesis) {
   const filePath = taskEvidencePath(workingDir, synthesis.taskId);
   await _internals90.withTaskEvidenceLock(workingDir, synthesis.taskId, COUNCIL_AGENT_ID, async () => {
     const existingRoot = Object.create(null);
-    if (existsSync92(filePath)) {
+    if (existsSync91(filePath)) {
       try {
         const parsed = EvidenceFileSchema.parse(JSON.parse(readFileSync63(filePath, "utf-8")));
         safeAssignOwnProps(existingRoot, parsed);
@@ -128451,7 +128735,7 @@ function buildFinalCouncilFeedback(projectSummary, verdict, vetoedBy, requiredFi
 // src/council/criteria-store.ts
 init_zod();
 init_task_file();
-import { existsSync as existsSync93, mkdirSync as mkdirSync43, readFileSync as readFileSync64 } from "node:fs";
+import { existsSync as existsSync92, mkdirSync as mkdirSync43, readFileSync as readFileSync64 } from "node:fs";
 import { join as join129 } from "node:path";
 var COUNCIL_DIR = ".swarm/council";
 var CouncilCriteriaSchema = exports_external.object({
@@ -128475,7 +128759,7 @@ async function writeCriteria(workingDir, taskId, criteria) {
 }
 function readCriteria(workingDir, taskId) {
   const filePath = join129(workingDir, COUNCIL_DIR, `${safeId(taskId)}.json`);
-  if (!existsSync93(filePath))
+  if (!existsSync92(filePath))
     return null;
   try {
     return CouncilCriteriaSchema.parse(JSON.parse(readFileSync64(filePath, "utf-8")));
@@ -130199,7 +130483,7 @@ init_zod();
 init_utils2();
 import { createHash as createHash19 } from "node:crypto";
 import {
-  existsSync as existsSync95,
+  existsSync as existsSync94,
   mkdirSync as mkdirSync44,
   readFileSync as readFileSync67,
   renameSync as renameSync30,
@@ -130250,7 +130534,7 @@ function storeLaneOutput(directory, input, now = Date.now) {
   const absPath = validateSwarmPath(directory, relPath);
   const timestamp = new Date(now()).toISOString();
   try {
-    if (existsSync95(absPath)) {
+    if (existsSync94(absPath)) {
       const existing = LaneOutputArtifactSchema.safeParse(JSON.parse(readFileSync67(absPath, "utf-8")));
       if (existing.success && existing.data.digest === digest3) {
         return {
@@ -130304,7 +130588,7 @@ function readLaneOutput(directory, ref) {
   if (!REF_RE.test(ref))
     return null;
   const absPath = validateSwarmPath(directory, laneOutputRelativePath(ref));
-  if (!existsSync95(absPath))
+  if (!existsSync94(absPath))
     return null;
   let parsed;
   try {
@@ -130406,7 +130690,7 @@ function writeAtomicJson(absPath, value) {
     if (lastRenameError)
       throw lastRenameError;
   } finally {
-    if (existsSync95(tempFile)) {
+    if (existsSync94(tempFile)) {
       try {
         unlinkSync26(tempFile);
       } catch {}
@@ -135442,9 +135726,9 @@ var _internals105 = {
   },
   getTimestamp: () => new Date().toISOString(),
   retireSkillFile: async (filePath) => {
-    const { unlink: unlink7 } = await import("node:fs/promises");
+    const { unlink: unlink8 } = await import("node:fs/promises");
     try {
-      await unlink7(filePath);
+      await unlink8(filePath);
       return true;
     } catch (err) {
       const error93 = err;
@@ -137188,8 +137472,10 @@ var knowledge_add = createSwarmTool({
 init_zod();
 init_knowledge_events();
 init_knowledge_store();
+init_skill_generator();
 init_logger();
 init_create_tool();
+import * as path175 from "node:path";
 var MODES2 = ["archive", "quarantine", "purge"];
 var TIERS = ["swarm", "hive"];
 var knowledge_archive = createSwarmTool({
@@ -137272,6 +137558,44 @@ var knowledge_archive = createSwarmTool({
     } else {
       await recordKnowledgeEvent(directory, tombstone);
     }
+    const allArchivedIds = await getArchivedKnowledgeIds(directory);
+    allArchivedIds.add(id);
+    queueMicrotask(async () => {
+      try {
+        const affectedSkillDirs = await findSkillsBySourceKnowledgeId(directory, id);
+        const staleSkillDirs = await findStaleSkillsBySourceKnowledgeId(directory, allArchivedIds);
+        const allSkillDirs = new Set([
+          ...affectedSkillDirs,
+          ...staleSkillDirs
+        ]);
+        if (allSkillDirs.size === 0)
+          return;
+        const slugSet = new Set;
+        let retiredCount = 0;
+        let staleCount = 0;
+        for (const skillDir of allSkillDirs) {
+          const slug = path175.basename(skillDir);
+          if (slugSet.has(slug))
+            continue;
+          slugSet.add(slug);
+          const result = await retireOrMarkStale(directory, skillDir, allArchivedIds);
+          if (result.action === "retire")
+            retiredCount++;
+          else
+            staleCount++;
+        }
+        const batchEvent = {
+          type: "skill-stale-batch",
+          skillIds: Array.from(slugSet),
+          archivedIds: Array.from(allArchivedIds),
+          retiredCount,
+          staleCount
+        };
+        await recordKnowledgeEvent(directory, batchEvent);
+      } catch (err) {
+        warn(`[knowledge-archive] post-archive skill invalidation failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    });
     return JSON.stringify({
       success: true,
       id,
@@ -137288,7 +137612,7 @@ init_zod();
 init_config();
 init_knowledge_store();
 init_create_tool();
-import { existsSync as existsSync101 } from "node:fs";
+import { existsSync as existsSync100 } from "node:fs";
 var DEFAULT_LIMIT = 10;
 var MAX_LESSON_LENGTH = 200;
 var VALID_CATEGORIES3 = [
@@ -137364,14 +137688,14 @@ function validateLimit(limit) {
 }
 async function readSwarmKnowledge(directory) {
   const swarmPath = resolveSwarmKnowledgePath(directory);
-  if (!existsSync101(swarmPath)) {
+  if (!existsSync100(swarmPath)) {
     return [];
   }
   return readKnowledge(swarmPath);
 }
 async function readHiveKnowledge() {
   const hivePath = resolveHiveKnowledgePath();
-  if (!existsSync101(hivePath)) {
+  if (!existsSync100(hivePath)) {
     return [];
   }
   return readKnowledge(hivePath);
@@ -137640,7 +137964,7 @@ var knowledge_receipt = createSwarmTool({
     const recordedEventIds = [];
     const emit2 = async (event) => {
       const written = await recordKnowledgeEvent(directory, event);
-      if (written)
+      if (written && written.event_id !== undefined)
         recordedEventIds.push(written.event_id);
     };
     for (const item of applied) {
@@ -137706,8 +138030,12 @@ var knowledge_receipt = createSwarmTool({
 
 // src/tools/knowledge-remove.ts
 init_zod();
+init_knowledge_events();
 init_knowledge_store();
+init_skill_generator();
+init_logger();
 init_create_tool();
+import * as path176 from "node:path";
 var knowledge_remove = createSwarmTool({
   description: "Delete an outdated swarm knowledge entry by ID (swarm tier only — does not affect hive). Promoted entries cannot be deleted. Double-deletion is idempotent — removing a non-existent entry returns a clear message without error.",
   args: {
@@ -137767,6 +138095,44 @@ var knowledge_remove = createSwarmTool({
         message: "entry not found"
       });
     }
+    const allArchivedIds = await getArchivedKnowledgeIds(directory);
+    allArchivedIds.add(id);
+    queueMicrotask(async () => {
+      try {
+        const affectedSkillDirs = await findSkillsBySourceKnowledgeId(directory, id);
+        const staleSkillDirs = await findStaleSkillsBySourceKnowledgeId(directory, allArchivedIds);
+        const allSkillDirs = new Set([
+          ...affectedSkillDirs,
+          ...staleSkillDirs
+        ]);
+        if (allSkillDirs.size === 0)
+          return;
+        const slugSet = new Set;
+        let retiredCount = 0;
+        let staleCount = 0;
+        for (const skillDir of allSkillDirs) {
+          const slug = path176.basename(skillDir);
+          if (slugSet.has(slug))
+            continue;
+          slugSet.add(slug);
+          const result = await retireOrMarkStale(directory, skillDir, allArchivedIds);
+          if (result.action === "retire")
+            retiredCount++;
+          else
+            staleCount++;
+        }
+        const batchEvent = {
+          type: "skill-stale-batch",
+          skillIds: Array.from(slugSet),
+          archivedIds: Array.from(allArchivedIds),
+          retiredCount,
+          staleCount
+        };
+        await recordKnowledgeEvent(directory, batchEvent);
+      } catch (err) {
+        warn(`[knowledge-remove] post-purge skill invalidation failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    });
     return JSON.stringify({
       success: true,
       removed: 1,
@@ -137821,10 +138187,10 @@ var lean_turbo_acquire_locks = createSwarmTool({
 init_zod();
 init_constants();
 import * as fs108 from "node:fs";
-import * as path175 from "node:path";
+import * as path177 from "node:path";
 init_create_tool();
 function readPlanJson2(directory) {
-  const planPath = path175.join(directory, ".swarm", "plan.json");
+  const planPath = path177.join(directory, ".swarm", "plan.json");
   if (!fs108.existsSync(planPath)) {
     return null;
   }
@@ -138192,12 +138558,12 @@ var lint_spec = createSwarmTool({
 // src/tools/mutation-test.ts
 init_zod();
 import * as fs109 from "node:fs";
-import * as path177 from "node:path";
+import * as path179 from "node:path";
 
 // src/mutation/engine.ts
 import { spawnSync as spawnSync13 } from "node:child_process";
 import { unlinkSync as unlinkSync27, writeFileSync as writeFileSync30 } from "node:fs";
-import * as path176 from "node:path";
+import * as path178 from "node:path";
 
 // src/mutation/equivalence.ts
 function isStaticallyEquivalent(originalCode, mutatedCode) {
@@ -138360,7 +138726,7 @@ function validateTestCommand(testCommand) {
     return "testCommand must not be empty";
   }
   const exe = testCommand[0];
-  const base = path176.basename(exe).replace(/\.(exe|cmd|bat)$/i, "");
+  const base = path178.basename(exe).replace(/\.(exe|cmd|bat)$/i, "");
   if (!ALLOWED_TEST_RUNNERS.has(base)) {
     return `testCommand executable '${exe}' is not in the allowed test runner list. Permitted runners: ${[...ALLOWED_TEST_RUNNERS].join(", ")}`;
   }
@@ -138384,7 +138750,7 @@ async function executeMutation(patch, testCommand, testFiles, workingDir) {
   let patchFile;
   try {
     const safeId2 = patch.id.replace(/[^a-zA-Z0-9_-]/g, "_");
-    patchFile = path176.join(workingDir, `.mutation_patch_${safeId2}.diff`);
+    patchFile = path178.join(workingDir, `.mutation_patch_${safeId2}.diff`);
     try {
       writeFileSync30(patchFile, patch.patch);
     } catch (writeErr) {
@@ -138801,7 +139167,7 @@ var mutation_test = createSwarmTool({
       ];
       for (const filePath of uniquePaths) {
         try {
-          const resolvedPath = path177.resolve(cwd, filePath);
+          const resolvedPath = path179.resolve(cwd, filePath);
           sourceFiles.set(filePath, fs109.readFileSync(resolvedPath, "utf-8"));
         } catch {}
       }
@@ -138819,8 +139185,8 @@ var mutation_test = createSwarmTool({
 
 // src/tools/parse-lane-candidates.ts
 init_zod();
-import { existsSync as existsSync103 } from "node:fs";
-import * as path179 from "node:path";
+import { existsSync as existsSync102 } from "node:fs";
+import * as path181 from "node:path";
 
 // src/background/candidate-parser.ts
 init_zod();
@@ -138831,7 +139197,7 @@ init_utils2();
 var import_proper_lockfile10 = __toESM(require_proper_lockfile(), 1);
 import { createHash as createHash24 } from "node:crypto";
 import { appendFileSync as appendFileSync19, mkdirSync as mkdirSync46 } from "node:fs";
-import * as path178 from "node:path";
+import * as path180 from "node:path";
 var BATCH_DIGEST_ALGORITHM = "sha256";
 var SidecarEnvelopeSchema = exports_external.object({
   record_type: exports_external.literal("invocation"),
@@ -138986,7 +139352,7 @@ function computeBatchDigest(batchId) {
   return createHash24(BATCH_DIGEST_ALGORITHM).update(batchId).digest("hex");
 }
 function sidecarRelativePath(batchDigest) {
-  return path178.join("lane-results", batchDigest, "candidates.jsonl");
+  return path180.join("lane-results", batchDigest, "candidates.jsonl");
 }
 function validateRecord(record3, schema, label) {
   const result = schema.safeParse(record3);
@@ -138995,7 +139361,7 @@ function validateRecord(record3, schema, label) {
   }
 }
 function withLockfile(lockDir, write) {
-  const lockPath = path178.join(lockDir, ".lock");
+  const lockPath = path180.join(lockDir, ".lock");
   const lf = import_proper_lockfile10.default;
   const release = lf.lockSync(lockPath, {
     realpath: false
@@ -139014,7 +139380,7 @@ function appendToSidecar(options, batchId, envelope, candidates) {
   for (let i = 0;i < candidates.length; i++) {
     validateRecord(candidates[i], SidecarCandidateSchema, `candidate[${i}]`);
   }
-  mkdirSync46(path178.dirname(absPath), { recursive: true });
+  mkdirSync46(path180.dirname(absPath), { recursive: true });
   const sanitizedEnvelope = sanitizeRecord(structuredClone(envelope));
   const sanitizedCandidates = candidates.map((c) => sanitizeRecord(structuredClone(c)));
   const lines = [JSON.stringify(sanitizedEnvelope)];
@@ -139028,7 +139394,7 @@ function appendToSidecar(options, batchId, envelope, candidates) {
     appendFileSync19(absPath, payload, "utf-8");
   };
   if (options.useLockfile) {
-    withLockfile(path178.dirname(absPath), doWrite);
+    withLockfile(path180.dirname(absPath), doWrite);
   } else {
     doWrite();
   }
@@ -139487,7 +139853,7 @@ function laneOutputRelativePath2(ref) {
   if (parts.length !== 4)
     return "";
   const [, batchDigest, laneDigest, outputDigest] = parts;
-  return path179.join("lane-results", batchDigest, laneDigest, `${outputDigest}.json`);
+  return path181.join("lane-results", batchDigest, laneDigest, `${outputDigest}.json`);
 }
 var parse_lane_candidates = createSwarmTool({
   description: "Parse [CANDIDATE] rows from a dispatch_lanes or collect_lane_results artifact (by output_ref), produce structured records with provenance, optionally persist to a per-batch sidecar JSONL. Pure-parser variant exists as internal module.",
@@ -139522,10 +139888,10 @@ var parse_lane_candidates = createSwarmTool({
       project_root
     } = parsed.data;
     if (project_root !== undefined) {
-      const absRoot = path179.resolve(project_root);
-      const absDir = path179.resolve(directory);
-      const rel = path179.relative(absDir, absRoot);
-      if (rel === ".." || rel.startsWith(`..${path179.sep}`) || path179.isAbsolute(rel)) {
+      const absRoot = path181.resolve(project_root);
+      const absDir = path181.resolve(directory);
+      const rel = path181.relative(absDir, absRoot);
+      if (rel === ".." || rel.startsWith(`..${path181.sep}`) || path181.isAbsolute(rel)) {
         return JSON.stringify({
           success: false,
           failure_class: "invalid_args",
@@ -139545,7 +139911,7 @@ var parse_lane_candidates = createSwarmTool({
     if (!loaded) {
       const relPath = REF_RE2.test(output_ref) ? laneOutputRelativePath2(output_ref) : "";
       const absPath = relPath ? validateSwarmPath(directory, relPath) : "";
-      const fileExists = absPath ? existsSync103(absPath) : false;
+      const fileExists = absPath ? existsSync102(absPath) : false;
       const artifactStatus = fileExists ? "artifact-corrupted" : "ref-not-found";
       const refParts = output_ref.split(":");
       const hasValidRef = REF_RE2.test(output_ref) && refParts.length === 4;
@@ -139618,22 +139984,22 @@ init_schema();
 init_manager2();
 init_task_file();
 import * as fs119 from "node:fs";
-import * as path189 from "node:path";
+import * as path191 from "node:path";
 
 // src/full-auto/phase-approval.ts
 init_utils2();
 init_logger();
 init_state3();
 import * as fs110 from "node:fs";
-import * as path180 from "node:path";
+import * as path182 from "node:path";
 var APPROVAL_TTL_MS = 24 * 60 * 60 * 1000;
 function readEvidenceDir(directory, phase) {
   try {
-    const dirPath = validateSwarmPath(directory, path180.posix.join("evidence", String(phase)));
+    const dirPath = validateSwarmPath(directory, path182.posix.join("evidence", String(phase)));
     if (!fs110.existsSync(dirPath))
       return [];
     const entries = fs110.readdirSync(dirPath);
-    return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path180.join(dirPath, e));
+    return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path182.join(dirPath, e));
   } catch {
     return [];
   }
@@ -139792,7 +140158,13 @@ async function evaluatePhaseCriticalDirectives(params) {
   try {
     const events = await readKnowledgeEvents(params.directory);
     const retrievedThisPhase = events.filter((e) => e.type === "retrieved" && (!params.phaseLabel || e.phase === params.phaseLabel));
-    const phaseStart = retrievedThisPhase.length > 0 ? retrievedThisPhase.map((e) => e.timestamp).reduce((a, b) => a < b ? a : b) : null;
+    const phaseStart = retrievedThisPhase.length > 0 ? retrievedThisPhase.map((e) => e.timestamp).reduce((a, b) => {
+      if (b === undefined)
+        return a;
+      if (a === undefined)
+        return b;
+      return a < b ? a : b;
+    }, undefined) : null;
     const criticalIds = await readCriticalIdsForPhase(params.directory, params.phaseLabel);
     if (criticalIds.length === 0) {
       return {
@@ -139802,7 +140174,13 @@ async function evaluatePhaseCriticalDirectives(params) {
         failedClosed: false
       };
     }
-    const receipts = events.filter(isReceipt).filter((r) => phaseStart === null || r.timestamp >= phaseStart).map((r) => ({
+    const receipts = events.filter(isReceipt).filter((r) => {
+      if (phaseStart === null || phaseStart === undefined)
+        return true;
+      if (r.timestamp === undefined)
+        return false;
+      return r.timestamp >= phaseStart;
+    }).map((r) => ({
       type: r.type,
       knowledge_id: r.knowledge_id,
       timestamp: r.timestamp,
@@ -139888,16 +140266,16 @@ init_plan_schema();
 init_ledger();
 init_manager();
 import * as fs111 from "node:fs";
-import * as path181 from "node:path";
+import * as path183 from "node:path";
 async function writeCheckpoint(directory) {
   try {
     const plan = await loadPlan(directory);
     if (!plan)
       return;
-    const swarmDir = path181.join(directory, ".swarm");
+    const swarmDir = path183.join(directory, ".swarm");
     fs111.mkdirSync(swarmDir, { recursive: true });
-    const jsonPath = path181.join(swarmDir, "SWARM_PLAN.json");
-    const mdPath = path181.join(swarmDir, "SWARM_PLAN.md");
+    const jsonPath = path183.join(swarmDir, "SWARM_PLAN.json");
+    const mdPath = path183.join(swarmDir, "SWARM_PLAN.md");
     fs111.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
     const md = derivePlanMarkdown(plan);
     fs111.writeFileSync(mdPath, md, "utf8");
@@ -140402,7 +140780,7 @@ init_state();
 // src/turbo/lean/phase-ready.ts
 init_file_locks();
 import * as fs112 from "node:fs";
-import * as path182 from "node:path";
+import * as path184 from "node:path";
 init_state4();
 var DEFAULT_CONFIG3 = {
   phase_reviewer: true,
@@ -140411,7 +140789,7 @@ var DEFAULT_CONFIG3 = {
 };
 function defaultReadPlanJson(dir) {
   try {
-    const planPath = path182.join(dir, ".swarm", "plan.json");
+    const planPath = path184.join(dir, ".swarm", "plan.json");
     if (!fs112.existsSync(planPath))
       return null;
     const raw = fs112.readFileSync(planPath, "utf-8");
@@ -140426,7 +140804,7 @@ function defaultReadPlanJson(dir) {
 }
 function readReviewerEvidenceFromFile(directory, phase) {
   try {
-    const evidencePath = path182.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
+    const evidencePath = path184.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
     if (!fs112.existsSync(evidencePath)) {
       return null;
     }
@@ -140446,7 +140824,7 @@ function readReviewerEvidenceFromFile(directory, phase) {
 }
 function readCriticEvidenceFromFile(directory, phase) {
   try {
-    const evidencePath = path182.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
+    const evidencePath = path184.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
     if (!fs112.existsSync(evidencePath)) {
       return null;
     }
@@ -140465,7 +140843,7 @@ function readCriticEvidenceFromFile(directory, phase) {
   }
 }
 function listLaneEvidenceSync(directory, phase) {
-  const evidenceDir = path182.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const evidenceDir = path184.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
   let entries;
   try {
     entries = fs112.readdirSync(evidenceDir);
@@ -140535,7 +140913,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     ...DEFAULT_CONFIG3,
     ...actualConfig
   };
-  const statePath = path182.join(directory, ".swarm", "turbo-state.json");
+  const statePath = path184.join(directory, ".swarm", "turbo-state.json");
   if (!fs112.existsSync(statePath)) {
     return {
       ok: false,
@@ -140723,7 +141101,7 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     }
   }
   if (mergedConfig.integrated_diff_required) {
-    const evidencePath = path182.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
+    const evidencePath = path184.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
     let hasDiff = false;
     try {
       const content = fs112.readFileSync(evidencePath, "utf-8");
@@ -140889,7 +141267,7 @@ async function runCompletionVerifyGate(ctx) {
 // src/tools/phase-complete/gates/drift-gate.ts
 init_effective_spec();
 import * as fs113 from "node:fs";
-import * as path183 from "node:path";
+import * as path185 from "node:path";
 
 // src/tools/phase-complete/gates/gate-helpers.ts
 init_qa_gate_profile();
@@ -140938,7 +141316,7 @@ async function runDriftGate(ctx) {
   }
   let phaseType;
   try {
-    const planPath = path183.join(dir, ".swarm", "plan.json");
+    const planPath = path185.join(dir, ".swarm", "plan.json");
     if (fs113.existsSync(planPath)) {
       const planRaw = fs113.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
@@ -140957,7 +141335,7 @@ async function runDriftGate(ctx) {
     };
   }
   try {
-    const driftEvidencePath = path183.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
+    const driftEvidencePath = path185.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
     let driftVerdictFound = false;
     let driftVerdictApproved = false;
     try {
@@ -140998,7 +141376,7 @@ async function runDriftGate(ctx) {
         let incompleteTaskCount = 0;
         let planParseable = false;
         try {
-          const planPath = path183.join(dir, ".swarm", "plan.json");
+          const planPath = path185.join(dir, ".swarm", "plan.json");
           if (fs113.existsSync(planPath)) {
             const planRaw = fs113.readFileSync(planPath, "utf-8");
             const plan = JSON.parse(planRaw);
@@ -141077,7 +141455,7 @@ async function runDriftGate(ctx) {
 }
 // src/tools/phase-complete/gates/final-council-gate.ts
 import * as fs114 from "node:fs";
-import * as path184 from "node:path";
+import * as path186 from "node:path";
 async function runFinalCouncilGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   let finalCouncilEnabled = false;
@@ -141100,7 +141478,7 @@ async function runFinalCouncilGate(ctx) {
       if (lastPhaseId !== undefined && phase === lastPhaseId) {
         if (preamble.effectiveGates?.final_council === true) {
           finalCouncilEnabled = true;
-          const fcPath = path184.join(dir, ".swarm", "evidence", "final-council.json");
+          const fcPath = path186.join(dir, ".swarm", "evidence", "final-council.json");
           let fcVerdictFound = false;
           let _fcVerdict;
           try {
@@ -141254,13 +141632,13 @@ async function runFinalCouncilGate(ctx) {
 }
 // src/tools/phase-complete/gates/hallucination-gate.ts
 import * as fs115 from "node:fs";
-import * as path185 from "node:path";
+import * as path187 from "node:path";
 async function runHallucinationGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   try {
     const preamble = await resolveGatePreamble(dir, sessionID);
     if (preamble.resolved && preamble.effectiveGates?.hallucination_guard === true) {
-      const hgPath = path185.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
+      const hgPath = path187.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
       let hgVerdictFound = false;
       let hgVerdictApproved = false;
       try {
@@ -141318,13 +141696,13 @@ async function runHallucinationGate(ctx) {
 }
 // src/tools/phase-complete/gates/mutation-gate.ts
 import * as fs116 from "node:fs";
-import * as path186 from "node:path";
+import * as path188 from "node:path";
 async function runMutationGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   try {
     const preamble = await resolveGatePreamble(dir, sessionID);
     if (preamble.resolved && preamble.effectiveGates?.mutation_test === true) {
-      const mgPath = path186.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
+      const mgPath = path188.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
       let mgVerdictFound = false;
       let mgVerdict;
       try {
@@ -141382,7 +141760,7 @@ async function runMutationGate(ctx) {
 }
 // src/tools/phase-complete/gates/phase-council-gate.ts
 import * as fs117 from "node:fs";
-import * as path187 from "node:path";
+import * as path189 from "node:path";
 async function runPhaseCouncilGate(ctx) {
   const { phase, dir, sessionID, pluginConfig, agentsDispatched, safeWarn } = ctx;
   const gateWarnings = [];
@@ -141391,7 +141769,7 @@ async function runPhaseCouncilGate(ctx) {
     const preamble = await resolveGatePreamble(dir, sessionID);
     if (preamble.resolved && preamble.effectiveGates?.phase_council === true && pluginConfig.council?.enabled === true) {
       councilModeEnabled = true;
-      const pcPath = path187.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
+      const pcPath = path189.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
       let pcVerdictFound = false;
       let _pcVerdict;
       let pcQuorumSize;
@@ -141959,7 +142337,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path189.basename(dir);
+      const projectName = path191.basename(dir);
       const curationResult = await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig, {
         llmDelegate: createCuratorLLMDelegate(dir, "phase", sessionID),
         enrichmentQuota: {
@@ -142536,7 +142914,7 @@ init_utils();
 init_bun_compat();
 init_create_tool();
 import * as fs120 from "node:fs";
-import * as path190 from "node:path";
+import * as path192 from "node:path";
 var MAX_OUTPUT_BYTES7 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -142564,16 +142942,16 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs120.existsSync(path190.join(cwd, "package.json"))) {
+  if (fs120.existsSync(path192.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs120.existsSync(path190.join(cwd, "pyproject.toml")) || fs120.existsSync(path190.join(cwd, "requirements.txt"))) {
+  if (fs120.existsSync(path192.join(cwd, "pyproject.toml")) || fs120.existsSync(path192.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs120.existsSync(path190.join(cwd, "Cargo.toml"))) {
+  if (fs120.existsSync(path192.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs120.existsSync(path190.join(cwd, "go.mod"))) {
+  if (fs120.existsSync(path192.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
@@ -142582,13 +142960,13 @@ function detectEcosystems(directory) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs120.existsSync(path190.join(cwd, "Gemfile")) || fs120.existsSync(path190.join(cwd, "Gemfile.lock"))) {
+  if (fs120.existsSync(path192.join(cwd, "Gemfile")) || fs120.existsSync(path192.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs120.existsSync(path190.join(cwd, "pubspec.yaml"))) {
+  if (fs120.existsSync(path192.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
-  if (fs120.existsSync(path190.join(cwd, "composer.lock"))) {
+  if (fs120.existsSync(path192.join(cwd, "composer.lock"))) {
     ecosystems.push("composer");
   }
   return ecosystems;
@@ -143725,7 +144103,7 @@ var pkg_audit = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs121 from "node:fs";
-import * as path191 from "node:path";
+import * as path193 from "node:path";
 init_utils();
 init_create_tool();
 var MAX_FILE_SIZE = 1024 * 1024;
@@ -143848,7 +144226,7 @@ function isScaffoldFile(filePath) {
   if (SCAFFOLD_PATH_PATTERNS.some((pattern) => pattern.test(normalizedPath))) {
     return true;
   }
-  const filename = path191.basename(filePath);
+  const filename = path193.basename(filePath);
   if (SCAFFOLD_FILENAME_PATTERNS.some((pattern) => pattern.test(filename))) {
     return true;
   }
@@ -143865,7 +144243,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
     if (regex.test(normalizedPath)) {
       return true;
     }
-    const filename = path191.basename(filePath);
+    const filename = path193.basename(filePath);
     const filenameRegex = new RegExp(`^${regexPattern}$`, "i");
     if (filenameRegex.test(filename)) {
       return true;
@@ -143874,7 +144252,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
   return false;
 }
 function isParserSupported(filePath) {
-  const ext = path191.extname(filePath).toLowerCase();
+  const ext = path193.extname(filePath).toLowerCase();
   return SUPPORTED_PARSER_EXTENSIONS.has(ext);
 }
 function isPlanFile(filePath) {
@@ -144121,9 +144499,9 @@ async function placeholderScan(input, directory) {
   let filesScanned = 0;
   const filesWithFindings = new Set;
   for (const filePath of changed_files) {
-    const fullPath = path191.isAbsolute(filePath) ? filePath : path191.resolve(directory, filePath);
-    const resolvedDirectory = path191.resolve(directory);
-    if (!fullPath.startsWith(resolvedDirectory + path191.sep) && fullPath !== resolvedDirectory) {
+    const fullPath = path193.isAbsolute(filePath) ? filePath : path193.resolve(directory, filePath);
+    const resolvedDirectory = path193.resolve(directory);
+    if (!fullPath.startsWith(resolvedDirectory + path193.sep) && fullPath !== resolvedDirectory) {
       continue;
     }
     if (!fs121.existsSync(fullPath)) {
@@ -144132,7 +144510,7 @@ async function placeholderScan(input, directory) {
     if (isAllowedByGlobs(filePath, allow_globs)) {
       continue;
     }
-    const relativeFilePath = path191.relative(directory, fullPath).replace(/\\/g, "/");
+    const relativeFilePath = path193.relative(directory, fullPath).replace(/\\/g, "/");
     if (FILE_ALLOWLIST.some((allowed) => relativeFilePath.endsWith(allowed))) {
       continue;
     }
@@ -144205,7 +144583,7 @@ var placeholder_scan = createSwarmTool({
 
 // src/tools/pre-check-batch.ts
 import * as fs125 from "node:fs";
-import * as path195 from "node:path";
+import * as path197 from "node:path";
 init_zod();
 init_manager2();
 init_utils();
@@ -144346,7 +144724,7 @@ init_zod();
 init_manager2();
 init_detector();
 import * as fs124 from "node:fs";
-import * as path194 from "node:path";
+import * as path196 from "node:path";
 import { extname as extname19 } from "node:path";
 
 // src/sast/rules/c.ts
@@ -145056,7 +145434,7 @@ function executeRulesSync(filePath, content, language) {
 // src/sast/semgrep.ts
 import * as child_process15 from "node:child_process";
 import * as fs122 from "node:fs";
-import * as path192 from "node:path";
+import * as path194 from "node:path";
 var semgrepAvailableCache = null;
 var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
 var DEFAULT_TIMEOUT_MS4 = 30000;
@@ -145343,7 +145721,7 @@ async function runSemgrep(options) {
 }
 function getRulesDirectory(projectRoot) {
   if (projectRoot) {
-    return path192.resolve(projectRoot, DEFAULT_RULES_DIR);
+    return path194.resolve(projectRoot, DEFAULT_RULES_DIR);
   }
   return DEFAULT_RULES_DIR;
 }
@@ -145364,24 +145742,24 @@ init_create_tool();
 init_utils2();
 import * as crypto13 from "node:crypto";
 import * as fs123 from "node:fs";
-import * as path193 from "node:path";
+import * as path195 from "node:path";
 var BASELINE_SCHEMA_VERSION = "1.0.0";
 var MAX_BASELINE_FINDINGS = 2000;
 var MAX_BASELINE_BYTES = 2 * 1048576;
 var LOCK_RETRY_DELAYS_MS = [50, 100, 200, 400, 800];
 function normalizeFindingPath(directory, file3) {
-  const resolved = path193.isAbsolute(file3) ? file3 : path193.resolve(directory, file3);
-  const rel = path193.relative(path193.resolve(directory), resolved);
+  const resolved = path195.isAbsolute(file3) ? file3 : path195.resolve(directory, file3);
+  const rel = path195.relative(path195.resolve(directory), resolved);
   return rel.replace(/\\/g, "/");
 }
 function baselineRelPath(phase) {
-  return path193.join("evidence", String(phase), "sast-baseline.json");
+  return path195.join("evidence", String(phase), "sast-baseline.json");
 }
 function tempRelPath(phase) {
-  return path193.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
+  return path195.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
 }
 function lockRelPath(phase) {
-  return path193.join("evidence", String(phase), "sast-baseline.json.lock");
+  return path195.join("evidence", String(phase), "sast-baseline.json.lock");
 }
 function getLine(lines, idx) {
   if (idx < 0 || idx >= lines.length)
@@ -145502,8 +145880,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       message: e instanceof Error ? e.message : "Path validation failed"
     };
   }
-  fs123.mkdirSync(path193.dirname(baselinePath), { recursive: true });
-  fs123.mkdirSync(path193.dirname(tempPath), { recursive: true });
+  fs123.mkdirSync(path195.dirname(baselinePath), { recursive: true });
+  fs123.mkdirSync(path195.dirname(tempPath), { recursive: true });
   const releaseLock = await acquireLock2(lockPath);
   try {
     let existing = null;
@@ -145776,9 +146154,9 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path194.isAbsolute(filePath) ? filePath : path194.resolve(directory, filePath);
-    const resolvedDirectory = path194.resolve(directory);
-    if (!resolvedPath.startsWith(resolvedDirectory + path194.sep) && resolvedPath !== resolvedDirectory) {
+    const resolvedPath = path196.isAbsolute(filePath) ? filePath : path196.resolve(directory, filePath);
+    const resolvedDirectory = path196.resolve(directory);
+    if (!resolvedPath.startsWith(resolvedDirectory + path196.sep) && resolvedPath !== resolvedDirectory) {
       _filesSkipped++;
       continue;
     }
@@ -146093,18 +146471,18 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path195.win32.resolve(inputPath);
-  } else if (path195.isAbsolute(inputPath)) {
-    resolved = path195.resolve(inputPath);
+    resolved = path197.win32.resolve(inputPath);
+  } else if (path197.isAbsolute(inputPath)) {
+    resolved = path197.resolve(inputPath);
   } else {
-    resolved = path195.resolve(baseDir, inputPath);
+    resolved = path197.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path195.resolve(workspaceDir);
+  const workspaceResolved = path197.resolve(workspaceDir);
   let relative38;
   if (isWinAbs) {
-    relative38 = path195.win32.relative(workspaceResolved, resolved);
+    relative38 = path197.win32.relative(workspaceResolved, resolved);
   } else {
-    relative38 = path195.relative(workspaceResolved, resolved);
+    relative38 = path197.relative(workspaceResolved, resolved);
   }
   if (relative38.startsWith("..")) {
     return "path traversal detected";
@@ -146169,7 +146547,7 @@ async function runLintOnFiles(linter, files, workspaceDir) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path195.resolve(file3);
+    const resolvedPath = path197.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -146326,7 +146704,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path195.resolve(file3);
+      const resolvedPath = path197.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -146344,7 +146722,7 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path195.extname(file3).toLowerCase();
+      const ext = path197.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
@@ -146563,7 +146941,7 @@ function classifySastFindings(findings, changedLineRanges, directory) {
   const preexistingFindings = [];
   for (const finding of findings) {
     const filePath = finding.location.file;
-    const normalised = path195.relative(directory, filePath).replace(/\\/g, "/");
+    const normalised = path197.relative(directory, filePath).replace(/\\/g, "/");
     const changedLines = changedLineRanges.get(normalised);
     if (changedLines?.has(finding.location.line)) {
       newFindings.push(finding);
@@ -146614,7 +146992,7 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path195.resolve(directory, file3));
+    changedFiles.push(path197.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -146815,9 +147193,9 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path195.resolve(typedArgs.directory);
-    const workspaceAnchor = path195.resolve(directory);
-    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path195.sep)) {
+    const resolvedDirectory = path197.resolve(typedArgs.directory);
+    const workspaceAnchor = path197.resolve(directory);
+    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path197.sep)) {
       const subDirError = `directory "${typedArgs.directory}" is a subdirectory of the project root — pre_check_batch requires the project root directory "${workspaceAnchor}"`;
       const subDirResult = {
         gates_passed: false,
@@ -146871,7 +147249,7 @@ var pre_check_batch = createSwarmTool({
 init_zod();
 init_path_security();
 init_create_tool();
-import * as path196 from "node:path";
+import * as path198 from "node:path";
 var VALID_ACTIONS = [
   "build",
   "importers",
@@ -146900,7 +147278,7 @@ function validateFile(p) {
     return "file contains control characters";
   if (containsPathTraversal(p))
     return "file contains path traversal";
-  if (path196.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
+  if (path198.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
     return "file must be a workspace-relative path, not absolute";
   }
   return null;
@@ -146923,8 +147301,8 @@ function ok(action, payload) {
 }
 function toRelativeGraphPath(input, workspaceRoot) {
   const normalized = input.replace(/\\/g, "/");
-  if (path196.isAbsolute(normalized)) {
-    const rel = path196.relative(workspaceRoot, normalized).replace(/\\/g, "/");
+  if (path198.isAbsolute(normalized)) {
+    const rel = path198.relative(workspaceRoot, normalized).replace(/\\/g, "/");
     return normalizeGraphPath(rel);
   }
   return normalizeGraphPath(normalized);
@@ -147120,10 +147498,10 @@ var repo_map = createSwarmTool({
         maxTokens: 4000
       });
       const toRel = (p) => {
-        if (!path196.isAbsolute(p))
+        if (!path198.isAbsolute(p))
           return p.replace(/\\/g, "/");
         try {
-          return path196.relative(directory, p).replace(/\\/g, "/");
+          return path198.relative(directory, p).replace(/\\/g, "/");
         } catch {
           return p;
         }
@@ -147173,7 +147551,7 @@ init_zod();
 init_effective_spec();
 init_create_tool();
 import * as fs126 from "node:fs";
-import * as path197 from "node:path";
+import * as path199 from "node:path";
 var EVIDENCE_DIR4 = ".swarm/evidence";
 var OBLIGATION_KEYWORDS2 = ["MUST", "SHOULD", "SHALL"];
 var MAX_FILE_SIZE_BYTES8 = 1024 * 1024;
@@ -147241,7 +147619,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     return [];
   }
   for (const entry of entries) {
-    const entryPath = path197.join(evidenceDir, entry);
+    const entryPath = path199.join(evidenceDir, entry);
     try {
       const stat14 = fs126.statSync(entryPath);
       if (!stat14.isDirectory()) {
@@ -147257,11 +147635,11 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     if (entryPhase !== String(phase)) {
       continue;
     }
-    const evidenceFilePath = path197.join(entryPath, "evidence.json");
+    const evidenceFilePath = path199.join(entryPath, "evidence.json");
     try {
-      const resolvedPath = path197.resolve(evidenceFilePath);
-      const evidenceDirResolved = path197.resolve(evidenceDir);
-      if (!resolvedPath.startsWith(evidenceDirResolved + path197.sep)) {
+      const resolvedPath = path199.resolve(evidenceFilePath);
+      const evidenceDirResolved = path199.resolve(evidenceDir);
+      if (!resolvedPath.startsWith(evidenceDirResolved + path199.sep)) {
         continue;
       }
       const stat14 = fs126.lstatSync(evidenceFilePath);
@@ -147295,7 +147673,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
             if (Array.isArray(diffEntry.files_changed)) {
               for (const file3 of diffEntry.files_changed) {
                 if (typeof file3 === "string") {
-                  touchedFiles.add(path197.resolve(cwd, file3));
+                  touchedFiles.add(path199.resolve(cwd, file3));
                 }
               }
             }
@@ -147308,8 +147686,8 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
 }
 function searchFileForKeywords(filePath, keywords, cwd) {
   try {
-    const resolvedPath = path197.resolve(filePath);
-    const cwdResolved = path197.resolve(cwd);
+    const resolvedPath = path199.resolve(filePath);
+    const cwdResolved = path199.resolve(cwd);
     if (!resolvedPath.startsWith(cwdResolved)) {
       return false;
     }
@@ -147468,7 +147846,7 @@ var req_coverage = createSwarmTool({
         message: "No FR requirements found in spec.md"
       }, null, 2);
     }
-    const evidenceDir = path197.join(cwd, EVIDENCE_DIR4);
+    const evidenceDir = path199.join(cwd, EVIDENCE_DIR4);
     const touchedFiles = readTouchedFiles(evidenceDir, phase, cwd);
     const analyzedRequirements = [];
     let coveredCount = 0;
@@ -147494,7 +147872,7 @@ var req_coverage = createSwarmTool({
       requirements: analyzedRequirements
     };
     const reportFilename = `req-coverage-phase-${phase}.json`;
-    const reportPath = path197.join(evidenceDir, reportFilename);
+    const reportPath = path199.join(evidenceDir, reportFilename);
     try {
       if (!fs126.existsSync(evidenceDir)) {
         fs126.mkdirSync(evidenceDir, { recursive: true });
@@ -147649,7 +148027,7 @@ init_plan_schema();
 init_qa_gate_profile();
 init_file_locks();
 import * as fs127 from "node:fs";
-import * as path198 from "node:path";
+import * as path200 from "node:path";
 init_ledger();
 init_manager();
 init_effective_spec();
@@ -147731,8 +148109,8 @@ async function executeSavePlan(args2, fallbackDir) {
     };
   }
   if (args2.working_directory && fallbackDir) {
-    const resolvedTarget = path198.resolve(args2.working_directory);
-    const resolvedRoot = path198.resolve(fallbackDir);
+    const resolvedTarget = path200.resolve(args2.working_directory);
+    const resolvedRoot = path200.resolve(fallbackDir);
     let fallbackExists = false;
     try {
       fs127.accessSync(resolvedRoot, fs127.constants.F_OK);
@@ -147741,7 +148119,7 @@ async function executeSavePlan(args2, fallbackDir) {
       fallbackExists = false;
     }
     if (fallbackExists) {
-      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path198.sep);
+      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path200.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -147772,7 +148150,7 @@ async function executeSavePlan(args2, fallbackDir) {
     specHash = spec.hash;
   }
   if (process.env.SWARM_SKIP_GATE_SELECTION !== "1") {
-    const contextPath = path198.join(targetWorkspace, ".swarm", "context.md");
+    const contextPath = path200.join(targetWorkspace, ".swarm", "context.md");
     let contextContent = "";
     try {
       contextContent = await fs127.promises.readFile(contextPath, "utf8");
@@ -148062,7 +148440,7 @@ async function executeSavePlan(args2, fallbackDir) {
       }
       await writeCheckpoint(dir).catch(() => {});
       try {
-        const markerPath = path198.join(dir, ".swarm", ".plan-write-marker");
+        const markerPath = path200.join(dir, ".swarm", ".plan-write-marker");
         const marker = JSON.stringify({
           source: "save_plan",
           timestamp: new Date().toISOString(),
@@ -148085,7 +148463,7 @@ async function executeSavePlan(args2, fallbackDir) {
       return {
         success: true,
         message: "Plan saved successfully",
-        plan_path: path198.join(dir, ".swarm", "plan.json"),
+        plan_path: path200.join(dir, ".swarm", "plan.json"),
         phases_count: plan.phases.length,
         tasks_count: tasksCount,
         ...resolvedProfile !== undefined ? { execution_profile: resolvedProfile } : {},
@@ -148138,8 +148516,8 @@ var save_plan = createSwarmTool({
     confirm_identity_change: exports_external.boolean().optional().describe("When true, allows overwriting an existing plan that has a different " + "identity (swarm_id + title). Without this flag, save_plan rejects " + "with PLAN_IDENTITY_MISMATCH if the identity differs."),
     execution_profile: exports_external.object({
       parallelization_enabled: exports_external.boolean().optional().describe("When true, enables parallel task dispatch for this plan. Default false (serial)."),
-      max_concurrent_tasks: exports_external.number().int().min(1).max(64).optional().describe("Maximum tasks that may run concurrently when parallelization is enabled. Default 1."),
-      council_parallel: exports_external.boolean().optional().describe("When true, council review phases may run in parallel. Default false."),
+      max_concurrent_tasks: exports_external.number().int().min(1).max(64).optional().describe("Maximum tasks that may run concurrently when parallelization is enabled. Default 10."),
+      council_parallel: exports_external.boolean().optional().describe("When true, council review phases may run in parallel. Default true."),
       locked: exports_external.boolean().optional().describe("When true, locks the profile — future save_plan calls that include " + "execution_profile will be rejected (fail-closed). " + "Unlock by resetting the plan (reset_statuses: true)."),
       auto_proceed: exports_external.boolean().optional().describe("When true, the architect advances to the next phase automatically without asking for confirmation. Default false.")
     }).optional().describe("Architect-facing concurrency controls. Once locked, cannot be changed without resetting. " + "Omit to preserve the existing profile.")
@@ -148153,7 +148531,7 @@ var save_plan = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs128 from "node:fs";
-import * as path199 from "node:path";
+import * as path201 from "node:path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -149003,7 +149381,7 @@ function findManifestFiles(rootDir) {
     try {
       const entries = fs128.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path199.join(dir, entry.name);
+        const fullPath = path201.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -149012,7 +149390,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path199.relative(rootDir, fullPath));
+              manifestFiles.push(path201.relative(rootDir, fullPath));
               break;
             }
           }
@@ -149030,11 +149408,11 @@ function findManifestFilesInDirs(directories, workingDir) {
     try {
       const entries = fs128.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path199.join(dir, entry.name);
+        const fullPath = path201.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path199.relative(workingDir, fullPath));
+              found.push(path201.relative(workingDir, fullPath));
               break;
             }
           }
@@ -149047,11 +149425,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path199.dirname(file3);
+    let currentDir = path201.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path199.sep) {
-        dirs.add(path199.join(workingDir, currentDir));
-        const parent = path199.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path201.sep) {
+        dirs.add(path201.join(workingDir, currentDir));
+        const parent = path201.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -149135,7 +149513,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path199.isAbsolute(relativeOutputDir) ? relativeOutputDir : path199.join(workingDir, relativeOutputDir);
+    const outputDir = path201.isAbsolute(relativeOutputDir) ? relativeOutputDir : path201.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -149158,7 +149536,7 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path199.isAbsolute(manifestFile) ? manifestFile : path199.join(workingDir, manifestFile);
+        const fullPath = path201.isAbsolute(manifestFile) ? manifestFile : path201.join(workingDir, manifestFile);
         if (!fs128.existsSync(fullPath)) {
           continue;
         }
@@ -149175,7 +149553,7 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path199.join(outputDir, filename);
+    const outputPath = path201.join(outputDir, filename);
     fs128.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
@@ -149220,7 +149598,7 @@ var sbom_generate = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs129 from "node:fs";
-import * as path200 from "node:path";
+import * as path202 from "node:path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -149252,12 +149630,12 @@ function normalizePath5(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path200.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path200.sep) ? cwd : cwd + path200.sep;
+    const resolvedPath = path202.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path202.sep) ? cwd : cwd + path202.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path200.extname(resolvedPath).toLowerCase();
+    const ext = path202.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
@@ -149271,7 +149649,7 @@ function discoverSpecFile(cwd, specFileArg) {
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path200.resolve(cwd, candidate);
+    const candidatePath = path202.resolve(cwd, candidate);
     if (fs129.existsSync(candidatePath)) {
       const stats2 = fs129.statSync(candidatePath);
       if (stats2.size <= MAX_SPEC_SIZE) {
@@ -149283,7 +149661,7 @@ function discoverSpecFile(cwd, specFileArg) {
 }
 function parseSpec(specFile) {
   const content = fs129.readFileSync(specFile, "utf-8");
-  const ext = path200.extname(specFile).toLowerCase();
+  const ext = path202.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -149359,7 +149737,7 @@ function extractRoutes2(cwd) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path200.join(dir, entry.name);
+      const fullPath = path202.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -149369,7 +149747,7 @@ function extractRoutes2(cwd) {
         }
         walkDir2(fullPath);
       } else if (entry.isFile()) {
-        const ext = path200.extname(entry.name).toLowerCase();
+        const ext = path202.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -149538,7 +149916,7 @@ init_bun_compat();
 init_path_security();
 init_create_tool();
 import * as fs130 from "node:fs";
-import * as path201 from "node:path";
+import * as path203 from "node:path";
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_LINES = 200;
 var REGEX_TIMEOUT_MS = 5000;
@@ -149574,11 +149952,11 @@ function containsWindowsAttacks4(str) {
 }
 function isPathInWorkspace3(filePath, workspace) {
   try {
-    const resolvedPath = path201.resolve(workspace, filePath);
+    const resolvedPath = path203.resolve(workspace, filePath);
     const realWorkspace = fs130.realpathSync(workspace);
     const realResolvedPath = fs130.realpathSync(resolvedPath);
-    const relativePath = path201.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path201.isAbsolute(relativePath)) {
+    const relativePath = path203.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path203.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -149591,11 +149969,11 @@ function validatePathForRead2(filePath, workspace) {
 }
 function findRgInEnvPath() {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path201.delimiter)) {
+  for (const dir of searchPath.split(path203.delimiter)) {
     if (!dir)
       continue;
     const isWindows = process.platform === "win32";
-    const candidate = path201.join(dir, isWindows ? "rg.exe" : "rg");
+    const candidate = path203.join(dir, isWindows ? "rg.exe" : "rg");
     if (fs130.existsSync(candidate))
       return candidate;
   }
@@ -149725,8 +150103,8 @@ function collectFiles(dir, workspace, includeGlobs, excludeGlobs) {
   try {
     const entries = fs130.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path201.join(dir, entry.name);
-      const relativePath = path201.relative(workspace, fullPath);
+      const fullPath = path203.join(dir, entry.name);
+      const relativePath = path203.relative(workspace, fullPath);
       if (!validatePathForRead2(fullPath, workspace)) {
         continue;
       }
@@ -149767,7 +150145,7 @@ async function fallbackSearch(opts) {
   const matches = [];
   let total = 0;
   for (const file3 of files) {
-    const fullPath = path201.join(opts.workspace, file3);
+    const fullPath = path203.join(opts.workspace, file3);
     if (!validatePathForRead2(fullPath, opts.workspace)) {
       continue;
     }
@@ -150199,7 +150577,7 @@ init_config();
 init_schema();
 init_create_tool();
 import { mkdir as mkdir34, rename as rename14, writeFile as writeFile23 } from "node:fs/promises";
-import * as path202 from "node:path";
+import * as path204 from "node:path";
 var MAX_SPEC_BYTES2 = 256 * 1024;
 var spec_write = createSwarmTool({
   description: "Write the canonical project spec to .swarm/spec.md. Atomic write, size-bounded (256 KiB), heading-required. Honors spec_writer.allow_spec_write.",
@@ -150240,8 +150618,8 @@ var spec_write = createSwarmTool({
         reason: 'spec must contain at least one top-level "# Heading"'
       }, null, 2);
     }
-    const target = path202.join(directory, ".swarm", "spec.md");
-    await mkdir34(path202.dirname(target), { recursive: true });
+    const target = path204.join(directory, ".swarm", "spec.md");
+    await mkdir34(path204.dirname(target), { recursive: true });
     const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
     let finalContent = content;
     if (mode === "append") {
@@ -150266,6 +150644,120 @@ ${content}
   }
 });
 
+// src/tools/stale-reconciliation.ts
+init_zod();
+init_knowledge_store();
+init_skill_generator();
+init_create_tool();
+import { existsSync as existsSync115 } from "node:fs";
+import { readdir as readdir12, readFile as readFile33 } from "node:fs/promises";
+import { join as join163 } from "node:path";
+var run_stale_reconciliation = createSwarmTool({
+  description: "Reconcile skills against the knowledge store. clear=false: mark skills stale when source knowledge is archived or deleted. clear=true: clear stale.marker on affected active skills (proposal files under .swarm/skills/proposals are scanned but not modified — they are drafts, not yet active skills).",
+  args: {
+    clear: exports_external.boolean().optional().default(false).describe("If true, clear stale markers for affected skills. If false (default), mark affected skills stale.")
+  },
+  execute: async (args2, directory) => {
+    if (typeof directory !== "string" || !directory) {
+      return JSON.stringify({ found: 0, skills: [] }, null, 2);
+    }
+    const archivedIds = await _internals116.getArchivedKnowledgeIds(directory);
+    const archivedSet = new Set(archivedIds);
+    const allKnownIds = new Set;
+    const swarmPath = _internals116.resolveSwarmKnowledgePath(directory);
+    const hivePath = _internals116.resolveHiveKnowledgePath();
+    try {
+      const swarmEntries = await _internals116.readKnowledge(swarmPath);
+      for (const e of swarmEntries)
+        allKnownIds.add(e.id);
+    } catch {}
+    try {
+      const hiveEntries = await _internals116.readKnowledge(hivePath);
+      for (const e of hiveEntries)
+        allKnownIds.add(e.id);
+    } catch {}
+    const skillEntries = [];
+    for (const dir of [
+      join163(directory, ".opencode", "skills", "generated"),
+      join163(directory, ".swarm", "skills", "proposals")
+    ]) {
+      if (!_internals116.existsSync(dir))
+        continue;
+      const entries = await _internals116.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          skillEntries.push({
+            slug: entry.name,
+            path: join163(dir, entry.name),
+            isProposal: false
+          });
+        } else if (entry.name.endsWith(".md")) {
+          const slug = entry.name.replace(/\.md$/, "");
+          skillEntries.push({
+            slug,
+            path: join163(dir, entry.name),
+            isProposal: true
+          });
+        }
+      }
+    }
+    const results = [];
+    for (const { slug, path: path205, isProposal } of skillEntries) {
+      const skillMdPath = isProposal ? path205 : join163(path205, "SKILL.md");
+      if (!_internals116.existsSync(skillMdPath))
+        continue;
+      const content = await _internals116.readFile(skillMdPath, "utf-8");
+      const fm = _internals116.parseDraftFrontmatter(content);
+      const sourceIds = fm?.sourceKnowledgeIds ?? [];
+      if (sourceIds.length === 0)
+        continue;
+      const affected = sourceIds.filter((id) => archivedSet.has(id) || !allKnownIds.has(id));
+      if (affected.length === 0)
+        continue;
+      if (args2.clear) {
+        if (!isProposal) {
+          const markerPath = join163(path205, "stale.marker");
+          if (_internals116.existsSync(markerPath)) {
+            try {
+              await _internals116.clearSkillStale(path205);
+              results.push({
+                slug,
+                reason: affected.join(", "),
+                action: "cleared"
+              });
+            } catch {}
+          }
+        }
+      } else {
+        if (!isProposal) {
+          try {
+            await _internals116.retireOrMarkStale(directory, path205, archivedSet);
+            results.push({
+              slug,
+              reason: affected.join(", "),
+              action: "marked_stale"
+            });
+          } catch {}
+        }
+      }
+    }
+    return JSON.stringify({ found: results.length, skills: results }, null, 2);
+  }
+});
+var _internals116 = {
+  run_stale_reconciliation,
+  clearSkillStale,
+  retireOrMarkStale,
+  parseDraftFrontmatter,
+  getArchivedKnowledgeIds,
+  readKnowledge,
+  resolveSwarmKnowledgePath,
+  resolveHiveKnowledgePath,
+  readdir: readdir12,
+  readFile: readFile33,
+  existsSync: existsSync115
+};
+
 // src/tools/submit-phase-council-verdicts.ts
 init_zod();
 init_loader();
@@ -150277,7 +150769,7 @@ import {
   unlinkSync as unlinkSync29,
   writeFileSync as writeFileSync36
 } from "node:fs";
-import path203 from "node:path";
+import path205 from "node:path";
 init_create_tool();
 init_resolve_working_directory();
 var VerdictSchema2 = exports_external.object({
@@ -150444,7 +150936,7 @@ var submit_phase_council_verdicts = createSwarmTool({
   }
 });
 function getPhaseMutationGapFinding(phaseNumber, workingDir) {
-  const mutationGatePath = path203.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
+  const mutationGatePath = path205.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
   try {
     const raw = readFileSync90(mutationGatePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -150506,9 +150998,9 @@ function getPhaseMutationGapFinding(phaseNumber, workingDir) {
   }
 }
 function writePhaseCouncilEvidence(workingDir, synthesis, provenance) {
-  const evidenceDir = path203.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
+  const evidenceDir = path205.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
   mkdirSync51(evidenceDir, { recursive: true });
-  const evidenceFile = path203.join(evidenceDir, "phase-council.json");
+  const evidenceFile = path205.join(evidenceDir, "phase-council.json");
   const evidenceBundle = {
     entries: [
       {
@@ -150571,7 +151063,7 @@ init_zod();
 init_path_security();
 init_create_tool();
 import * as fs131 from "node:fs";
-import * as path204 from "node:path";
+import * as path206 from "node:path";
 var BINARY_EXTENSIONS2 = new Set([
   ".png",
   ".jpg",
@@ -150607,14 +151099,14 @@ function containsWindowsAttacks5(str) {
 }
 function isPathInWorkspace4(filePath, workspace) {
   try {
-    const resolvedPath = path204.resolve(workspace, filePath);
+    const resolvedPath = path206.resolve(workspace, filePath);
     if (!fs131.existsSync(resolvedPath)) {
       return true;
     }
     const realWorkspace = fs131.realpathSync(workspace);
     const realResolvedPath = fs131.realpathSync(resolvedPath);
-    const relativePath = path204.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path204.isAbsolute(relativePath)) {
+    const relativePath = path206.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path206.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -150729,7 +151221,7 @@ function arraysEqual2(a, b) {
   return true;
 }
 function isBinaryFile4(filePath) {
-  const ext = path204.extname(filePath).toLowerCase();
+  const ext = path206.extname(filePath).toLowerCase();
   return BINARY_EXTENSIONS2.has(ext);
 }
 function splitDiffLines(content) {
@@ -150934,7 +151426,7 @@ var suggestPatch = createSwarmTool({
         });
         continue;
       }
-      const fullPath = path204.resolve(directory, change.file);
+      const fullPath = path206.resolve(directory, change.file);
       if (!fs131.existsSync(fullPath)) {
         errors5.push({
           success: false,
@@ -151029,7 +151521,7 @@ var suggestPatch = createSwarmTool({
         const unifiedParts = [];
         for (const [file3, entries] of fileGroups) {
           entries.sort((a, b) => a.contextMatch.startLineIndex - b.contextMatch.startLineIndex);
-          const entryFullPath = path204.resolve(directory, file3);
+          const entryFullPath = path206.resolve(directory, file3);
           let entryContent;
           try {
             entryContent = fs131.readFileSync(entryFullPath, "utf-8");
@@ -151230,7 +151722,7 @@ var swarm_memory_propose = createSwarmTool({
     evidenceRefs: exports_external.array(exports_external.string().min(1).max(500)).max(20).optional().describe("Evidence refs such as files, commits, test outputs, or URLs")
   },
   execute: async (args2, directory, ctx) => {
-    const { config: config3 } = _internals116.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals117.loadPluginConfigWithMeta(directory);
     if (config3.memory?.enabled !== true) {
       return JSON.stringify({
         success: false,
@@ -151246,7 +151738,7 @@ var swarm_memory_propose = createSwarmTool({
       });
     }
     const agent = getContextAgent3(ctx);
-    const gateway = _internals116.createMemoryGateway({
+    const gateway = _internals117.createMemoryGateway({
       directory,
       sessionID: ctx?.sessionID,
       agentRole: agent,
@@ -151271,7 +151763,7 @@ var swarm_memory_propose = createSwarmTool({
     }
   }
 });
-var _internals116 = {
+var _internals117 = {
   loadPluginConfigWithMeta,
   createMemoryGateway
 };
@@ -151309,7 +151801,7 @@ var swarm_memory_recall = createSwarmTool({
     maxItems: exports_external.number().int().min(1).max(20).optional().describe("Maximum memories to return")
   },
   execute: async (args2, directory, ctx) => {
-    const { config: config3 } = _internals117.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals118.loadPluginConfigWithMeta(directory);
     if (config3.memory?.enabled !== true) {
       return JSON.stringify({
         success: false,
@@ -151325,7 +151817,7 @@ var swarm_memory_recall = createSwarmTool({
       });
     }
     const agent = getContextAgent4(ctx);
-    const gateway = _internals117.createMemoryGateway({
+    const gateway = _internals118.createMemoryGateway({
       directory,
       sessionID: ctx?.sessionID,
       agentRole: agent,
@@ -151358,7 +151850,7 @@ var RecallArgsSchema = exports_external.object({
   kinds: exports_external.array(exports_external.enum(MEMORY_KINDS2)).optional(),
   maxItems: exports_external.number().int().min(1).max(20).optional()
 });
-var _internals117 = {
+var _internals118 = {
   loadPluginConfigWithMeta,
   createMemoryGateway
 };
@@ -151371,7 +151863,7 @@ function getContextAgent4(ctx) {
 
 // src/tools/syntax-check.ts
 import * as fs132 from "node:fs";
-import * as path205 from "node:path";
+import * as path207 from "node:path";
 init_zod();
 init_manager2();
 init_detector();
@@ -151443,7 +151935,7 @@ async function syntaxCheck(input, directory, config3) {
   if (languages?.length) {
     const lowerLangs = languages.map((l) => l.toLowerCase());
     filesToCheck = filesToCheck.filter((file3) => {
-      const ext = path205.extname(file3.path).toLowerCase();
+      const ext = path207.extname(file3.path).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       const fileProfile = getProfileForFile(file3.path);
       const langId = fileProfile?.id || langDef?.id;
@@ -151453,7 +151945,7 @@ async function syntaxCheck(input, directory, config3) {
   const { loadGrammar: loadGrammar2 } = await Promise.resolve().then(() => (init_runtime(), exports_runtime));
   async function checkOneFile(fileInfo) {
     const { path: filePath } = fileInfo;
-    const fullPath = path205.isAbsolute(filePath) ? filePath : path205.join(directory, filePath);
+    const fullPath = path207.isAbsolute(filePath) ? filePath : path207.join(directory, filePath);
     const result = {
       path: filePath,
       language: "",
@@ -151500,7 +151992,7 @@ async function syntaxCheck(input, directory, config3) {
         result.skipped_reason = "binary_file";
         return { result, counted: false, failed: false, skipped: true };
       }
-      const ext = path205.extname(filePath).toLowerCase();
+      const ext = path207.extname(filePath).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       result.language = profile?.id || langDef?.id || "unknown";
       const errors5 = extractSyntaxErrors(parser, content);
@@ -151612,7 +152104,7 @@ init_utils();
 init_create_tool();
 init_path_security();
 import * as fs133 from "node:fs";
-import * as path206 from "node:path";
+import * as path208 from "node:path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES10 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS4 = new Set([
@@ -151678,9 +152170,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path206.resolve(paths);
-    const normalizedCwd = path206.resolve(cwd);
-    const normalizedResolved = path206.resolve(resolvedPath);
+    const resolvedPath = path208.resolve(paths);
+    const normalizedCwd = path208.resolve(cwd);
+    const normalizedResolved = path208.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -151696,7 +152188,7 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path206.extname(filePath).toLowerCase();
+  const ext = path208.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS4.has(ext);
 }
 function findSourceFiles3(dir, files = []) {
@@ -151711,7 +152203,7 @@ function findSourceFiles3(dir, files = []) {
     if (SKIP_DIRECTORIES6.has(entry)) {
       continue;
     }
-    const fullPath = path206.join(dir, entry);
+    const fullPath = path208.join(dir, entry);
     let stat14;
     try {
       stat14 = fs133.statSync(fullPath);
@@ -151823,7 +152315,7 @@ var todo_extract = createSwarmTool({
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path206.extname(scanPath)}`,
+          error: `unsupported file extension: ${path208.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -151873,18 +152365,18 @@ init_schema();
 init_qa_gate_profile();
 init_gate_evidence();
 import * as fs137 from "node:fs";
-import * as path210 from "node:path";
+import * as path212 from "node:path";
 
 // src/hooks/diff-scope.ts
 init_bun_compat();
 import * as fs135 from "node:fs";
-import * as path208 from "node:path";
+import * as path210 from "node:path";
 
 // src/utils/gitignore-warning.ts
 init_bun_compat();
 import * as fs134 from "node:fs";
-import * as path207 from "node:path";
-var _internals118 = { bunSpawn };
+import * as path209 from "node:path";
+var _internals119 = { bunSpawn };
 var _swarmGitExcludedChecked = false;
 function fileCoversSwarm(content) {
   for (const rawLine of content.split(`
@@ -151917,7 +152409,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
       checkIgnoreExitCode
     ] = await Promise.all([
       (async () => {
-        const proc = _internals118.bunSpawn(["git", "-C", directory, "rev-parse", "--show-toplevel"], GIT_SPAWN_OPTIONS);
+        const proc = _internals119.bunSpawn(["git", "-C", directory, "rev-parse", "--show-toplevel"], GIT_SPAWN_OPTIONS);
         try {
           return await Promise.all([proc.exited, proc.stdout.text()]);
         } finally {
@@ -151927,7 +152419,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       })(),
       (async () => {
-        const proc = _internals118.bunSpawn(["git", "-C", directory, "rev-parse", "--git-path", "info/exclude"], GIT_SPAWN_OPTIONS);
+        const proc = _internals119.bunSpawn(["git", "-C", directory, "rev-parse", "--git-path", "info/exclude"], GIT_SPAWN_OPTIONS);
         try {
           return await Promise.all([proc.exited, proc.stdout.text()]);
         } finally {
@@ -151937,7 +152429,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       })(),
       (async () => {
-        const proc = _internals118.bunSpawn(["git", "-C", directory, "check-ignore", "-q", ".swarm/.gitkeep"], GIT_SPAWN_OPTIONS);
+        const proc = _internals119.bunSpawn(["git", "-C", directory, "check-ignore", "-q", ".swarm/.gitkeep"], GIT_SPAWN_OPTIONS);
         try {
           return await proc.exited;
         } finally {
@@ -151957,10 +152449,10 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
     const excludeRelPath = excludePathRaw.trim();
     if (!excludeRelPath)
       return;
-    const excludePath = path207.isAbsolute(excludeRelPath) ? excludeRelPath : path207.join(directory, excludeRelPath);
+    const excludePath = path209.isAbsolute(excludeRelPath) ? excludeRelPath : path209.join(directory, excludeRelPath);
     if (checkIgnoreExitCode !== 0) {
       try {
-        fs134.mkdirSync(path207.dirname(excludePath), { recursive: true });
+        fs134.mkdirSync(path209.dirname(excludePath), { recursive: true });
         let existing = "";
         try {
           existing = fs134.readFileSync(excludePath, "utf8");
@@ -151976,7 +152468,7 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
         }
       } catch {}
     }
-    const trackedProc = _internals118.bunSpawn(["git", "-C", directory, "ls-files", "--", ".swarm"], GIT_SPAWN_OPTIONS);
+    const trackedProc = _internals119.bunSpawn(["git", "-C", directory, "ls-files", "--", ".swarm"], GIT_SPAWN_OPTIONS);
     let trackedExitCode;
     let trackedOutput;
     try {
@@ -152001,10 +152493,10 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
 }
 
 // src/hooks/diff-scope.ts
-var _internals119 = { bunSpawn };
+var _internals120 = { bunSpawn };
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path208.join(directory, ".swarm", "plan.json");
+    const planPath = path210.join(directory, ".swarm", "plan.json");
     if (!fs135.existsSync(planPath))
       return null;
     const raw = fs135.readFileSync(planPath, "utf-8");
@@ -152036,7 +152528,7 @@ var GIT_DIFF_SPAWN_OPTIONS = {
 };
 async function getChangedFiles2(directory) {
   try {
-    const proc = _internals119.bunSpawn(["git", "diff", "--name-only", "HEAD~1"], {
+    const proc = _internals120.bunSpawn(["git", "diff", "--name-only", "HEAD~1"], {
       cwd: directory,
       ...GIT_DIFF_SPAWN_OPTIONS
     });
@@ -152053,7 +152545,7 @@ async function getChangedFiles2(directory) {
       return stdout.trim().split(`
 `).map((f) => f.trim()).filter((f) => f.length > 0);
     }
-    const proc2 = _internals119.bunSpawn(["git", "diff", "--name-only", "HEAD"], {
+    const proc2 = _internals120.bunSpawn(["git", "diff", "--name-only", "HEAD"], {
       cwd: directory,
       ...GIT_DIFF_SPAWN_OPTIONS
     });
@@ -152110,8 +152602,8 @@ init_telemetry();
 // src/turbo/lean/task-completion.ts
 init_file_locks();
 import * as fs136 from "node:fs";
-import * as path209 from "node:path";
-var _internals120 = {
+import * as path211 from "node:path";
+var _internals121 = {
   listActiveLocks,
   verifyLeanTurboTaskCompletion
 };
@@ -152129,7 +152621,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path209.basename(file3);
+    const fileName = path211.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -152141,7 +152633,7 @@ function matchesTier3Pattern(files) {
 function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   let persisted = null;
   try {
-    const statePath = path209.join(directory, ".swarm", "turbo-state.json");
+    const statePath = path211.join(directory, ".swarm", "turbo-state.json");
     if (!fs136.existsSync(statePath)) {
       return {
         ok: false,
@@ -152225,11 +152717,11 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
     };
   }
   const phase = runState.phase ?? 0;
-  const evidencePath = path209.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
-  const expectedDir = path209.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
-  const resolvedPath = path209.resolve(evidencePath);
-  const resolvedDir = path209.resolve(expectedDir);
-  if (!resolvedPath.startsWith(resolvedDir + path209.sep) && resolvedPath !== resolvedDir) {
+  const evidencePath = path211.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
+  const expectedDir = path211.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const resolvedPath = path211.resolve(evidencePath);
+  const resolvedDir = path211.resolve(expectedDir);
+  if (!resolvedPath.startsWith(resolvedDir + path211.sep) && resolvedPath !== resolvedDir) {
     return {
       ok: false,
       reason: `Lane ID causes path traversal: ${lane.laneId}`,
@@ -152253,7 +152745,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
       }
     };
   }
-  const activeLocks = _internals120.listActiveLocks(directory);
+  const activeLocks = _internals121.listActiveLocks(directory);
   const laneLocks = activeLocks.filter((lock) => lock.laneId === lane.laneId);
   if (laneLocks.length > 0) {
     return {
@@ -152269,7 +152761,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   }
   let filesTouched = [];
   try {
-    const planPath = path209.join(directory, ".swarm", "plan.json");
+    const planPath = path211.join(directory, ".swarm", "plan.json");
     const planRaw = fs136.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(planRaw);
     for (const planPhase of plan.phases ?? []) {
@@ -152320,7 +152812,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
 init_task_id();
 init_create_tool();
 init_resolve_working_directory();
-var _internals121 = {
+var _internals122 = {
   tryAcquireLock,
   updateTaskStatus,
   resolveWorkingDirectory
@@ -152358,7 +152850,7 @@ var TIER_3_PATTERNS2 = [
 ];
 function matchesTier3Pattern2(files) {
   for (const file3 of files) {
-    const fileName = path210.basename(file3);
+    const fileName = path212.basename(file3);
     for (const pattern of TIER_3_PATTERNS2) {
       if (pattern.test(fileName)) {
         return true;
@@ -152397,7 +152889,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     if (!skipStandardTurboBypass && hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path210.join(resolvedDir2, ".swarm", "plan.json");
+        const planPath = path212.join(resolvedDir2, ".swarm", "plan.json");
         const planRaw = fs137.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -152417,7 +152909,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     let resolvedDir;
     if (fallbackDir) {
-      const resolveResult = _internals121.resolveWorkingDirectory(workingDirectory, fallbackDir);
+      const resolveResult = _internals122.resolveWorkingDirectory(workingDirectory, fallbackDir);
       if (resolveResult.success) {
         resolvedDir = resolveResult.directory;
       } else {
@@ -152475,7 +152967,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     if (resolvedDir) {
       try {
-        const planPath = path210.join(resolvedDir, ".swarm", "plan.json");
+        const planPath = path212.join(resolvedDir, ".swarm", "plan.json");
         const planRaw = fs137.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -152686,7 +153178,7 @@ function checkCouncilGate(workingDirectory, taskId) {
     return { blocked: false, reason: "", active: false };
   }
   try {
-    const planPath = path210.join(workingDirectory, ".swarm", "plan.json");
+    const planPath = path212.join(workingDirectory, ".swarm", "plan.json");
     const planRaw = fs137.readFileSync(planPath, "utf-8");
     const planObj = JSON.parse(planRaw);
     if (planObj.swarm && planObj.title) {
@@ -152764,7 +153256,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     }
   }
   let directory;
-  const resolveResult = _internals121.resolveWorkingDirectory(args2.working_directory, fallbackDir);
+  const resolveResult = _internals122.resolveWorkingDirectory(args2.working_directory, fallbackDir);
   if (!resolveResult.success) {
     return {
       success: false,
@@ -152773,7 +153265,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   directory = resolveResult.directory;
-  const planPath = path210.join(directory, ".swarm", "plan.json");
+  const planPath = path212.join(directory, ".swarm", "plan.json");
   if (!fs137.existsSync(planPath)) {
     return {
       success: false,
@@ -152782,9 +153274,9 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   if (fallbackDir && directory !== fallbackDir) {
-    const canonicalDir = fs137.realpathSync(path210.resolve(directory));
-    const canonicalRoot = fs137.realpathSync(path210.resolve(fallbackDir));
-    if (canonicalDir.startsWith(canonicalRoot + path210.sep)) {
+    const canonicalDir = fs137.realpathSync(path212.resolve(directory));
+    const canonicalRoot = fs137.realpathSync(path212.resolve(fallbackDir));
+    if (canonicalDir.startsWith(canonicalRoot + path212.sep)) {
       return {
         success: false,
         message: `Invalid working_directory: "${directory}" is a subdirectory of ` + `the project root "${fallbackDir}". Pass the project root path or ` + `omit working_directory entirely.`,
@@ -152796,8 +153288,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
   }
   if (args2.status === "in_progress") {
     try {
-      const evidencePath = path210.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
-      fs137.mkdirSync(path210.dirname(evidencePath), { recursive: true });
+      const evidencePath = path212.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
+      fs137.mkdirSync(path212.dirname(evidencePath), { recursive: true });
       const fd = fs137.openSync(evidencePath, "wx");
       let writeOk = false;
       try {
@@ -152821,7 +153313,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     recoverTaskStateFromDelegations(args2.task_id, directory);
     let phaseRequiresReviewer = true;
     try {
-      const planPath2 = path210.join(directory, ".swarm", "plan.json");
+      const planPath2 = path212.join(directory, ".swarm", "plan.json");
       const planRaw = fs137.readFileSync(planPath2, "utf-8");
       const plan = JSON.parse(planRaw);
       const taskPhase = plan.phases.find((p) => p.tasks.some((t) => t.id === args2.task_id));
@@ -152857,7 +153349,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
   }
   let lockResult;
   try {
-    lockResult = await _internals121.tryAcquireLock(directory, planFilePath, agentName, lockTaskId);
+    lockResult = await _internals122.tryAcquireLock(directory, planFilePath, agentName, lockTaskId);
   } catch (error93) {
     return {
       success: false,
@@ -152876,7 +153368,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   try {
-    const updatedPlan = await _internals121.updateTaskStatus(directory, args2.task_id, args2.status);
+    const updatedPlan = await _internals122.updateTaskStatus(directory, args2.task_id, args2.status);
     if (args2.status === "completed") {
       for (const [_sessionId, session] of swarmState.agentSessions) {
         if (!(session.taskWorkflowStates instanceof Map)) {
@@ -152940,7 +153432,7 @@ init_utils2();
 init_redaction();
 import { createHash as createHash26 } from "node:crypto";
 import { appendFile as appendFile18, mkdir as mkdir35 } from "node:fs/promises";
-import * as path211 from "node:path";
+import * as path213 from "node:path";
 var EVIDENCE_CACHE_FILE = "evidence-cache/documents.jsonl";
 var MAX_EVIDENCE_TEXT_LENGTH = 4000;
 async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
@@ -152948,7 +153440,7 @@ async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
   const capturedAt = now().toISOString();
   const records = inputs.map((input) => createEvidenceDocumentRecord(input, capturedAt)).filter((record3) => record3 !== null);
   if (records.length > 0) {
-    await mkdir35(path211.dirname(filePath), { recursive: true });
+    await mkdir35(path213.dirname(filePath), { recursive: true });
     await appendFile18(filePath, `${records.map((record3) => JSON.stringify(record3)).join(`
 `)}
 `, "utf-8");
@@ -153531,7 +154023,7 @@ var web_fetch = createSwarmTool({
       };
       return JSON.stringify(fail, null, 2);
     }
-    const config3 = _internals122.loadPluginConfig(dirResult.directory);
+    const config3 = _internals123.loadPluginConfig(dirResult.directory);
     const generalConfig = config3.council?.general;
     if (!generalConfig || generalConfig.enabled !== true) {
       const fail = {
@@ -153541,7 +154033,7 @@ var web_fetch = createSwarmTool({
       };
       return JSON.stringify(fail, null, 2);
     }
-    const validated = await validateFetchUrl(parsed.data.url, _internals122.dnsLookup);
+    const validated = await validateFetchUrl(parsed.data.url, _internals123.dnsLookup);
     if (!validated.ok) {
       const fail = {
         success: false,
@@ -153552,7 +154044,7 @@ var web_fetch = createSwarmTool({
     }
     const maxBytes = parsed.data.max_bytes ?? DEFAULT_MAX_BYTES;
     const timeoutMs = parsed.data.timeout_ms ?? DEFAULT_TIMEOUT_MS5;
-    const result = await boundedFetch({ url: validated.url, address: validated.address }, maxBytes, timeoutMs, _internals122);
+    const result = await boundedFetch({ url: validated.url, address: validated.address }, maxBytes, timeoutMs, _internals123);
     if (!result.ok) {
       const fail = {
         success: false,
@@ -153587,7 +154079,7 @@ var web_fetch = createSwarmTool({
 });
 async function captureFetchEvidence(directory, url3, title, text) {
   try {
-    const written = await _internals122.writeEvidenceDocuments(directory, [
+    const written = await _internals123.writeEvidenceDocuments(directory, [
       {
         sourceType: "crawl",
         url: url3,
@@ -153608,7 +154100,7 @@ async function captureFetchEvidence(directory, url3, title, text) {
     };
   }
 }
-var _internals122 = {
+var _internals123 = {
   httpRequest: performHttpRequest,
   dnsLookup: lookup,
   loadPluginConfig,
@@ -153922,7 +154414,7 @@ var web_search = createSwarmTool({
 });
 async function captureSearchEvidence(directory, query, results) {
   try {
-    const written = await _internals123.writeEvidenceDocuments(directory, results.map((result) => ({
+    const written = await _internals124.writeEvidenceDocuments(directory, results.map((result) => ({
       sourceType: "web_search",
       query,
       title: result.title,
@@ -153950,7 +154442,7 @@ async function captureSearchEvidence(directory, query, results) {
     };
   }
 }
-var _internals123 = {
+var _internals124 = {
   writeEvidenceDocuments
 };
 
@@ -153965,7 +154457,7 @@ init_schema3();
 init_store();
 init_create_tool();
 init_resolve_working_directory();
-import * as path212 from "node:path";
+import * as path214 from "node:path";
 var FindingSchema2 = exports_external.object({
   severity: exports_external.enum(["low", "medium", "high", "critical"]),
   category: exports_external.string().min(1),
@@ -154041,7 +154533,7 @@ var write_architecture_supervisor_evidence = createSwarmTool({
       if (config3.architectural_supervision?.persist_knowledge_recommendations && args2.knowledge_recommendations.length > 0) {
         const knowledgeConfig = KnowledgeConfigSchema.parse(config3.knowledge ?? {});
         const lessons = args2.knowledge_recommendations.map((r) => r.lesson);
-        const result = await curateAndStoreSwarm(lessons, path212.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, {
+        const result = await curateAndStoreSwarm(lessons, path214.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, {
           skipAutoPromotion: true,
           llmDelegate: createCuratorLLMDelegate(dirResult.directory, "phase"),
           enrichmentQuota: {
@@ -154088,7 +154580,7 @@ init_ledger();
 init_manager();
 init_create_tool();
 import fs138 from "node:fs";
-import path213 from "node:path";
+import path215 from "node:path";
 function normalizeVerdict(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -154142,7 +154634,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "drift-verifier.json";
-  const relativePath = path213.join("evidence", String(phase), filename);
+  const relativePath = path215.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -154153,10 +154645,10 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path213.dirname(validatedPath);
+  const evidenceDir = path215.dirname(validatedPath);
   try {
     await fs138.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path213.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path215.join(evidenceDir, `.${filename}.tmp`);
     await fs138.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs138.promises.rename(tempPath, validatedPath);
     let snapshotInfo;
@@ -154257,7 +154749,7 @@ var write_drift_evidence = createSwarmTool({
 init_zod();
 init_loader();
 import fs139 from "node:fs";
-import path214 from "node:path";
+import path216 from "node:path";
 init_utils2();
 init_manager();
 init_create_tool();
@@ -154371,7 +154863,7 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
     timestamp: synthesis.timestamp
   };
   const filename = "final-council.json";
-  const relativePath = path214.join("evidence", filename);
+  const relativePath = path216.join("evidence", filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -154385,10 +154877,10 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
   const evidenceContent = {
     entries: [evidenceEntry]
   };
-  const evidenceDir = path214.dirname(validatedPath);
+  const evidenceDir = path216.dirname(validatedPath);
   try {
     await fs139.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path214.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path216.join(evidenceDir, `.${filename}.tmp`);
     await fs139.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs139.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -154448,7 +154940,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs140 from "node:fs";
-import path215 from "node:path";
+import path217 from "node:path";
 function normalizeVerdict2(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -154496,7 +154988,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "hallucination-guard.json";
-  const relativePath = path215.join("evidence", String(phase), filename);
+  const relativePath = path217.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -154507,10 +154999,10 @@ async function executeWriteHallucinationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path215.dirname(validatedPath);
+  const evidenceDir = path217.dirname(validatedPath);
   try {
     await fs140.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path215.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path217.join(evidenceDir, `.${filename}.tmp`);
     await fs140.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs140.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -154560,7 +155052,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs141 from "node:fs";
-import path216 from "node:path";
+import path218 from "node:path";
 function normalizeVerdict3(verdict) {
   switch (verdict) {
     case "PASS":
@@ -154634,7 +155126,7 @@ async function executeWriteMutationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "mutation-gate.json";
-  const relativePath = path216.join("evidence", String(phase), filename);
+  const relativePath = path218.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -154645,10 +155137,10 @@ async function executeWriteMutationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path216.dirname(validatedPath);
+  const evidenceDir = path218.dirname(validatedPath);
   try {
     await fs141.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path216.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path218.join(evidenceDir, `.${filename}.tmp`);
     await fs141.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs141.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -154771,6 +155263,7 @@ var TOOL_MANIFEST = defineHandlers({
   skill_list: () => skill_list,
   skill_apply: () => skill_apply,
   skill_inspect: () => skill_inspect,
+  run_stale_reconciliation: () => run_stale_reconciliation,
   skill_regenerate: () => skill_regenerate,
   skill_retire: () => skill_retire,
   skill_improve: () => skill_improve,
@@ -154863,7 +155356,7 @@ ${footerLines.join(`
 init_warning_buffer();
 var _heartbeatTimers = new Map;
 var SWARM_COMMAND_SYSTEM_RULE_TAG = "[opencode-swarm:swarm-command-rule]";
-var PACKAGE_ROOT2 = path218.resolve(path218.dirname(fileURLToPath5(import.meta.url)), "..");
+var PACKAGE_ROOT2 = path220.resolve(path220.dirname(fileURLToPath5(import.meta.url)), "..");
 var SYNC_BUNDLED_SKILLS_TIMEOUT_MS = 2000;
 function createSwarmCommandSystemRuleHook(agentDefinitions, registeredAgents) {
   return async (input, output) => {
@@ -155185,7 +155678,7 @@ async function initializeOpenCodeSwarm(ctx) {
     const { PreflightTriggerManager: PTM } = await Promise.resolve().then(() => (init_trigger(), exports_trigger));
     preflightTriggerManager = new PTM(automationConfig);
     const { AutomationStatusArtifact: ASA } = await Promise.resolve().then(() => (init_status_artifact(), exports_status_artifact));
-    const swarmDir = path218.resolve(ctx.directory, ".swarm");
+    const swarmDir = path220.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -155857,7 +156350,7 @@ ${promptRaw}`;
                   const meta3 = readSkillMetadata(s.skillPath, ctx.directory);
                   let desc = meta3.description || "";
                   if (!desc || desc === "No description provided") {
-                    desc = path218.basename(path218.dirname(s.skillPath));
+                    desc = path220.basename(path220.dirname(s.skillPath));
                   }
                   desc = desc.replace(/,/g, ";");
                   return `file:${s.skillPath} (-- ${desc})`;
@@ -155867,7 +156360,7 @@ ${promptRaw}`;
 
 ${promptRaw}`;
                 argsRecord.prompt = newPrompt;
-                const skillNames = topSkills.map((s) => `${path218.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
+                const skillNames = topSkills.map((s) => `${path220.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
                 console.warn(`[skill-propagation-gate] Injected skills: ${skillNames}`);
                 for (const skill of topSkills) {
                   try {