opencode-swarm-plugin 0.46.0 → 0.48.0

package/dist/bin/swarm.js

@@ -1,4 +1,5 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
+// @bun
 import { createRequire } from "node:module";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
@@ -12698,13 +12699,13 @@ __export(exports_eval_capture3, {
   readSessionEvents: () => readSessionEvents3,
   readPartialRecords: () => readPartialRecords3,
   readEvalRecords: () => readEvalRecords3,
-  getSessionPath: () => getSessionPath3,
-  getSessionDir: () => getSessionDir3,
+  getSessionPath: () => getSessionPath4,
+  getSessionDir: () => getSessionDir4,
   getEvalDataStats: () => getEvalDataStats3,
   getEvalDataPath: () => getEvalDataPath3,
   finalizeEvalRecord: () => finalizeEvalRecord3,
   exportForEvalite: () => exportForEvalite3,
-  ensureSessionDir: () => ensureSessionDir3,
+  ensureSessionDir: () => ensureSessionDir4,
   ensureEvalDataDir: () => ensureEvalDataDir3,
   captureSubtaskOutcome: () => captureSubtaskOutcome3,
   captureSkillLoaded: () => captureSkillLoaded3,
@@ -12713,29 +12714,29 @@ __export(exports_eval_capture3, {
   captureInboxChecked: () => captureInboxChecked3,
   captureHumanFeedback: () => captureHumanFeedback3,
   captureDecomposition: () => captureDecomposition3,
-  captureCoordinatorEvent: () => captureCoordinatorEvent3,
-  captureCompactionEvent: () => captureCompactionEvent3,
+  captureCoordinatorEvent: () => captureCoordinatorEvent4,
+  captureCompactionEvent: () => captureCompactionEvent4,
   captureBlockerResolved: () => captureBlockerResolved3,
   captureBlockerDetected: () => captureBlockerDetected3,
   appendEvalRecord: () => appendEvalRecord3,
-  SubtaskOutcomeSchema: () => SubtaskOutcomeSchema3,
-  EvalRecordSchema: () => EvalRecordSchema3,
+  SubtaskOutcomeSchema: () => SubtaskOutcomeSchema4,
+  EvalRecordSchema: () => EvalRecordSchema4,
   DEFAULT_EVAL_DATA_PATH: () => DEFAULT_EVAL_DATA_PATH3,
-  CoordinatorSessionSchema: () => CoordinatorSessionSchema3,
-  CoordinatorEventSchema: () => CoordinatorEventSchema3
+  CoordinatorSessionSchema: () => CoordinatorSessionSchema4,
+  CoordinatorEventSchema: () => CoordinatorEventSchema4
 });
-import * as fs5 from "node:fs";
-import * as os3 from "node:os";
-import * as path6 from "node:path";
-import { getSwarmMailLibSQL as getSwarmMailLibSQL10 } from "swarm-mail";
+import * as fs8 from "node:fs";
+import * as os4 from "node:os";
+import * as path8 from "node:path";
+import { getSwarmMailLibSQL as getSwarmMailLibSQL11 } from "swarm-mail";
 function getEvalDataPath3(projectPath) {
-  return path6.join(projectPath, DEFAULT_EVAL_DATA_PATH3);
+  return path8.join(projectPath, DEFAULT_EVAL_DATA_PATH3);
 }
 function ensureEvalDataDir3(projectPath) {
   const evalPath = getEvalDataPath3(projectPath);
-  const dir = path6.dirname(evalPath);
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
+  const dir = path8.dirname(evalPath);
+  if (!fs8.existsSync(dir)) {
+    fs8.mkdirSync(dir, { recursive: true });
   }
 }
 function appendEvalRecord3(projectPath, record4) {
@@ -12743,27 +12744,27 @@ function appendEvalRecord3(projectPath, record4) {
   const evalPath = getEvalDataPath3(projectPath);
   const line = `${JSON.stringify(record4)}
 `;
-  fs5.appendFileSync(evalPath, line, "utf-8");
+  fs8.appendFileSync(evalPath, line, "utf-8");
 }
 function readEvalRecords3(projectPath) {
   const evalPath = getEvalDataPath3(projectPath);
-  if (!fs5.existsSync(evalPath)) {
+  if (!fs8.existsSync(evalPath)) {
     return [];
   }
-  const content = fs5.readFileSync(evalPath, "utf-8");
+  const content = fs8.readFileSync(evalPath, "utf-8");
   const lines = content.trim().split(`
 `).filter(Boolean);
   return lines.map((line) => {
     const parsed = JSON.parse(line);
-    return EvalRecordSchema3.parse(parsed);
+    return EvalRecordSchema4.parse(parsed);
   });
 }
 function readPartialRecords3(projectPath) {
   const evalPath = getEvalDataPath3(projectPath);
-  if (!fs5.existsSync(evalPath)) {
+  if (!fs8.existsSync(evalPath)) {
     return [];
   }
-  const content = fs5.readFileSync(evalPath, "utf-8");
+  const content = fs8.readFileSync(evalPath, "utf-8");
   const lines = content.trim().split(`
 `).filter(Boolean);
   return lines.map((line) => JSON.parse(line));
@@ -12779,7 +12780,7 @@ function updateEvalRecord3(projectPath, id, updates) {
   const content = `${records.map((r) => JSON.stringify(r)).join(`
 `)}
 `;
-  fs5.writeFileSync(evalPath, content, "utf-8");
+  fs8.writeFileSync(evalPath, content, "utf-8");
   return true;
 }
 function captureDecomposition3(params) {
@@ -12796,7 +12797,7 @@ function captureDecomposition3(params) {
     subtasks: params.subtasks,
     outcomes: []
   };
-  inProgressRecords3.set(params.epicId, record4);
+  inProgressRecords4.set(params.epicId, record4);
   appendEvalRecord3(params.projectPath, record4);
   return record4;
 }
@@ -12812,7 +12813,7 @@ function captureSubtaskOutcome3(params) {
     success: params.success,
     failure_mode: params.failureMode
   };
-  const record4 = inProgressRecords3.get(params.epicId);
+  const record4 = inProgressRecords4.get(params.epicId);
   if (record4) {
     record4.outcomes = record4.outcomes || [];
     record4.outcomes.push(outcome);
@@ -12822,7 +12823,7 @@ function captureSubtaskOutcome3(params) {
   });
 }
 function finalizeEvalRecord3(params) {
-  const record4 = inProgressRecords3.get(params.epicId);
+  const record4 = inProgressRecords4.get(params.epicId);
   if (!record4 || !record4.outcomes || record4.outcomes.length === 0) {
     return null;
   }
@@ -12851,7 +12852,7 @@ function finalizeEvalRecord3(params) {
     time_balance_ratio: timeBalanceRatio
   };
   updateEvalRecord3(params.projectPath, params.epicId, finalRecord);
-  inProgressRecords3.delete(params.epicId);
+  inProgressRecords4.delete(params.epicId);
   return finalRecord;
 }
 function captureHumanFeedback3(params) {
@@ -12906,23 +12907,23 @@ function getEvalDataStats3(projectPath) {
     avgTimeBalance
   };
 }
-function getSessionDir3() {
-  return process.env.SWARM_SESSIONS_DIR || path6.join(os3.homedir(), ".config", "swarm-tools", "sessions");
+function getSessionDir4() {
+  return process.env.SWARM_SESSIONS_DIR || path8.join(os4.homedir(), ".config", "swarm-tools", "sessions");
 }
-function getSessionPath3(sessionId) {
-  return path6.join(getSessionDir3(), `${sessionId}.jsonl`);
+function getSessionPath4(sessionId) {
+  return path8.join(getSessionDir4(), `${sessionId}.jsonl`);
 }
-function ensureSessionDir3() {
-  const sessionDir = getSessionDir3();
-  if (!fs5.existsSync(sessionDir)) {
-    fs5.mkdirSync(sessionDir, { recursive: true });
+function ensureSessionDir4() {
+  const sessionDir = getSessionDir4();
+  if (!fs8.existsSync(sessionDir)) {
+    fs8.mkdirSync(sessionDir, { recursive: true });
   }
 }
-async function captureCoordinatorEvent3(event) {
-  CoordinatorEventSchema3.parse(event);
+async function captureCoordinatorEvent4(event) {
+  CoordinatorEventSchema4.parse(event);
   try {
     const projectPath = process.cwd();
-    const swarmMail = await getSwarmMailLibSQL10(projectPath);
+    const swarmMail = await getSwarmMailLibSQL11(projectPath);
     const eventType = `coordinator_${event.event_type.toLowerCase()}`;
     const eventData = {
       type: eventType,
@@ -12943,21 +12944,21 @@ async function captureCoordinatorEvent3(event) {
       eventData.compaction_type = event.compaction_type;
     }
     await swarmMail.appendEvent(eventData);
-    ensureSessionDir3();
-    const sessionPath = getSessionPath3(event.session_id);
+    ensureSessionDir4();
+    const sessionPath = getSessionPath4(event.session_id);
     const line = `${JSON.stringify(event)}
 `;
-    fs5.appendFileSync(sessionPath, line, "utf-8");
+    fs8.appendFileSync(sessionPath, line, "utf-8");
   } catch (error54) {
     console.warn("Failed to append event to libSQL, using JSONL fallback:", error54);
-    ensureSessionDir3();
-    const sessionPath = getSessionPath3(event.session_id);
+    ensureSessionDir4();
+    const sessionPath = getSessionPath4(event.session_id);
     const line = `${JSON.stringify(event)}
 `;
-    fs5.appendFileSync(sessionPath, line, "utf-8");
+    fs8.appendFileSync(sessionPath, line, "utf-8");
   }
 }
-async function captureCompactionEvent3(params) {
+async function captureCompactionEvent4(params) {
   const event = {
     session_id: params.session_id,
     epic_id: params.epic_id,
@@ -12966,7 +12967,7 @@ async function captureCompactionEvent3(params) {
     compaction_type: params.compaction_type,
     payload: params.payload
   };
-  await captureCoordinatorEvent3(event);
+  await captureCoordinatorEvent4(event);
 }
 async function captureResearcherSpawned3(params) {
   const event = {
@@ -12981,7 +12982,7 @@ async function captureResearcherSpawned3(params) {
       tools_used: params.tools_used || []
     }
   };
-  await captureCoordinatorEvent3(event);
+  await captureCoordinatorEvent4(event);
 }
 async function captureSkillLoaded3(params) {
   const event = {
@@ -12995,7 +12996,7 @@ async function captureSkillLoaded3(params) {
       context: params.context
     }
   };
-  await captureCoordinatorEvent3(event);
+  await captureCoordinatorEvent4(event);
 }
 async function captureInboxChecked3(params) {
   const event = {
@@ -13009,7 +13010,7 @@ async function captureInboxChecked3(params) {
       urgent_count: params.urgent_count
     }
   };
-  await captureCoordinatorEvent3(event);
+  await captureCoordinatorEvent4(event);
 }
 async function captureBlockerResolved3(params) {
   const event = {
@@ -13025,7 +13026,7 @@ async function captureBlockerResolved3(params) {
       resolution: params.resolution
     }
   };
-  await captureCoordinatorEvent3(event);
+  await captureCoordinatorEvent4(event);
 }
 async function captureScopeChangeDecision3(params) {
   const event = {
@@ -13047,7 +13048,7 @@ async function captureScopeChangeDecision3(params) {
       rejection_reason: params.rejection_reason
     }
   };
-  await captureCoordinatorEvent3(event);
+  await captureCoordinatorEvent4(event);
 }
 async function captureBlockerDetected3(params) {
   const event = {
@@ -13064,19 +13065,19 @@ async function captureBlockerDetected3(params) {
       reported_at: new Date().toISOString()
     }
   };
-  await captureCoordinatorEvent3(event);
+  await captureCoordinatorEvent4(event);
 }
 function readSessionEvents3(sessionId) {
-  const sessionPath = getSessionPath3(sessionId);
-  if (!fs5.existsSync(sessionPath)) {
+  const sessionPath = getSessionPath4(sessionId);
+  if (!fs8.existsSync(sessionPath)) {
     return [];
   }
-  const content = fs5.readFileSync(sessionPath, "utf-8");
+  const content = fs8.readFileSync(sessionPath, "utf-8");
   const lines = content.trim().split(`
 `).filter(Boolean);
   return lines.map((line) => {
     const parsed = JSON.parse(line);
-    return CoordinatorEventSchema3.parse(parsed);
+    return CoordinatorEventSchema4.parse(parsed);
   });
 }
 function saveSession3(params) {
@@ -13096,10 +13097,10 @@ function saveSession3(params) {
   };
   return session;
 }
-var SubtaskOutcomeSchema3, EvalRecordSchema3, CoordinatorEventSchema3, CoordinatorSessionSchema3, DEFAULT_EVAL_DATA_PATH3 = ".opencode/eval-data.jsonl", inProgressRecords3;
+var SubtaskOutcomeSchema4, EvalRecordSchema4, CoordinatorEventSchema4, CoordinatorSessionSchema4, DEFAULT_EVAL_DATA_PATH3 = ".opencode/eval-data.jsonl", inProgressRecords4;
 var init_eval_capture3 = __esm(() => {
   init_zod3();
-  SubtaskOutcomeSchema3 = exports_external3.object({
+  SubtaskOutcomeSchema4 = exports_external3.object({
     bead_id: exports_external3.string(),
     title: exports_external3.string(),
     planned_files: exports_external3.array(exports_external3.string()),
@@ -13110,7 +13111,7 @@ var init_eval_capture3 = __esm(() => {
     success: exports_external3.boolean(),
     failure_mode: exports_external3.string().optional()
   });
-  EvalRecordSchema3 = exports_external3.object({
+  EvalRecordSchema4 = exports_external3.object({
     id: exports_external3.string(),
     timestamp: exports_external3.string(),
     project_path: exports_external3.string(),
@@ -13127,7 +13128,7 @@ var init_eval_capture3 = __esm(() => {
       dependencies: exports_external3.array(exports_external3.number()).optional(),
       estimated_complexity: exports_external3.number().int().min(1).max(5).optional()
     })),
-    outcomes: exports_external3.array(SubtaskOutcomeSchema3).optional(),
+    outcomes: exports_external3.array(SubtaskOutcomeSchema4).optional(),
     overall_success: exports_external3.boolean().optional(),
     total_duration_ms: exports_external3.number().int().min(0).optional(),
     total_errors: exports_external3.number().int().min(0).optional(),
@@ -13138,7 +13139,7 @@ var init_eval_capture3 = __esm(() => {
     scope_accuracy: exports_external3.number().min(0).max(2).optional(),
     time_balance_ratio: exports_external3.number().min(1).optional()
   });
-  CoordinatorEventSchema3 = exports_external3.discriminatedUnion("event_type", [
+  CoordinatorEventSchema4 = exports_external3.discriminatedUnion("event_type", [
     exports_external3.object({
       session_id: exports_external3.string(),
       epic_id: exports_external3.string(),
@@ -13201,14 +13202,14 @@ var init_eval_capture3 = __esm(() => {
       payload: exports_external3.any()
     })
   ]);
-  CoordinatorSessionSchema3 = exports_external3.object({
+  CoordinatorSessionSchema4 = exports_external3.object({
     session_id: exports_external3.string(),
     epic_id: exports_external3.string(),
     start_time: exports_external3.string(),
     end_time: exports_external3.string().optional(),
-    events: exports_external3.array(CoordinatorEventSchema3)
+    events: exports_external3.array(CoordinatorEventSchema4)
   });
-  inProgressRecords3 = new Map;
+  inProgressRecords4 = new Map;
 });
 
 // src/swarm-validation.ts
@@ -17161,7 +17162,7 @@ var require_has_flag = __commonJS((exports2, module2) => {
 
 // ../../node_modules/.bun/supports-color@7.2.0/node_modules/supports-color/index.js
 var require_supports_color = __commonJS((exports2, module2) => {
-  var os4 = __require("os");
+  var os5 = __require("os");
   var tty = __require("tty");
   var hasFlag = require_has_flag();
   var { env } = process;
@@ -17209,7 +17210,7 @@ var require_supports_color = __commonJS((exports2, module2) => {
       return min;
     }
     if (process.platform === "win32") {
-      const osRelease = os4.release().split(".");
+      const osRelease = os5.release().split(".");
       if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
         return Number(osRelease[2]) >= 14931 ? 3 : 2;
       }
@@ -26790,7 +26791,7 @@ var require_parse2 = __commonJS((exports2, module2) => {
 
 // ../../node_modules/.bun/gray-matter@4.0.3/node_modules/gray-matter/index.js
 var require_gray_matter2 = __commonJS((exports2, module2) => {
-  var fs6 = __require("fs");
+  var fs9 = __require("fs");
   var sections = require_section_matter2();
   var defaults2 = require_defaults2();
   var stringify = require_stringify2();
@@ -26877,7 +26878,7 @@ var require_gray_matter2 = __commonJS((exports2, module2) => {
     return stringify(file4, data, options2);
   };
   matter.read = function(filepath, options2) {
-    const str2 = fs6.readFileSync(filepath, "utf8");
+    const str2 = fs9.readFileSync(filepath, "utf8");
     const file4 = matter(str2, options2);
     file4.path = filepath;
     return file4;
@@ -26929,20 +26930,20 @@ __export(exports_skills2, {
 });
 import { readdir as readdir2, readFile as readFile2, stat as stat2, mkdir as mkdir2, writeFile as writeFile2, rm as rm2 } from "fs/promises";
 import {
-  join as join16,
+  join as join18,
   basename as basename2,
-  dirname as dirname6,
+  dirname as dirname8,
   resolve as resolve2,
   relative as relative2,
   isAbsolute as isAbsolute2,
   sep as sep3
 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { getSwarmMailLibSQL as getSwarmMailLibSQL12, createEvent as createEvent7 } from "swarm-mail";
+import { getSwarmMailLibSQL as getSwarmMailLibSQL13, createEvent as createEvent7 } from "swarm-mail";
 async function emitSkillLoadedEvent2(data) {
   try {
     const projectPath = skillsProjectDirectory2;
-    const swarmMail = await getSwarmMailLibSQL12(projectPath);
+    const swarmMail = await getSwarmMailLibSQL13(projectPath);
     const event = createEvent7("skill_loaded", {
       project_key: projectPath,
       skill_name: data.skill_name,
@@ -26956,7 +26957,7 @@ async function emitSkillLoadedEvent2(data) {
 async function emitSkillCreatedEvent2(data) {
   try {
     const projectPath = skillsProjectDirectory2;
-    const swarmMail = await getSwarmMailLibSQL12(projectPath);
+    const swarmMail = await getSwarmMailLibSQL13(projectPath);
     const event = createEvent7("skill_created", {
       project_key: projectPath,
       skill_name: data.skill_name,
@@ -27005,19 +27006,19 @@ function validateSkillMetadata2(raw, filePath) {
 }
 function getGlobalSkillsDir2() {
   const home = process.env.HOME || process.env.USERPROFILE || "~";
-  return join16(home, ".config", "opencode", "skill");
+  return join18(home, ".config", "opencode", "skill");
 }
 function getClaudeGlobalSkillsDir2() {
   const home = process.env.HOME || process.env.USERPROFILE || "~";
-  return join16(home, ".claude", "skills");
+  return join18(home, ".claude", "skills");
 }
 function getPackageSkillsDir2() {
   try {
     const currentFilePath = fileURLToPath2(import.meta.url);
-    return join16(dirname6(currentFilePath), "..", "global-skills");
+    return join18(dirname8(currentFilePath), "..", "global-skills");
   } catch {
     const currentDir = decodeURIComponent(new URL(".", import.meta.url).pathname);
-    return join16(currentDir, "..", "global-skills");
+    return join18(currentDir, "..", "global-skills");
   }
 }
 async function findSkillFiles2(baseDir) {
@@ -27026,7 +27027,7 @@ async function findSkillFiles2(baseDir) {
     const entries = await readdir2(baseDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const skillPath = join16(baseDir, entry.name, "SKILL.md");
+        const skillPath = join18(baseDir, entry.name, "SKILL.md");
         try {
           const s = await stat2(skillPath);
           if (s.isFile()) {
@@ -27040,7 +27041,7 @@ async function findSkillFiles2(baseDir) {
 }
 async function findSkillScripts2(skillDir) {
   const scripts = [];
-  const scriptsDir = join16(skillDir, "scripts");
+  const scriptsDir = join18(skillDir, "scripts");
   try {
     const entries = await readdir2(scriptsDir, { withFileTypes: true });
     for (const entry of entries) {
@@ -27055,7 +27056,7 @@ async function loadSkill2(skillPath) {
   const content = await readFile2(skillPath, "utf-8");
   const { metadata: rawMetadata, body } = parseFrontmatter2(content);
   const metadata = validateSkillMetadata2(rawMetadata, skillPath);
-  const directory = dirname6(skillPath);
+  const directory = dirname8(skillPath);
   const scripts = await findSkillScripts2(directory);
   return {
     metadata,
@@ -27088,7 +27089,7 @@ async function discoverSkills2(projectDir) {
     }
   }
   for (const relPath of PROJECT_SKILL_DIRECTORIES2) {
-    await loadSkillsFromDir(join16(dir, relPath));
+    await loadSkillsFromDir(join18(dir, relPath));
   }
   await loadSkillsFromDir(getGlobalSkillsDir2());
   await loadSkillsFromDir(getClaudeGlobalSkillsDir2());
@@ -27459,7 +27460,7 @@ Scripts run in the skill's directory with the project directory as an argument.`
       if (!skill.scripts.includes(args2.script)) {
         return `Script '${args2.script}' not found in skill '${args2.skill}'. Available: ${skill.scripts.join(", ") || "none"}`;
       }
-      const scriptPath = join16(skill.directory, "scripts", args2.script);
+      const scriptPath = join18(skill.directory, "scripts", args2.script);
       const scriptArgs = args2.args || [];
       try {
         const TIMEOUT_MS = 60000;
@@ -27568,14 +27569,14 @@ Good skills have:
       const csoWarnings = validateCSOCompliance2(args2.name, args2.description);
       let skillDir;
       if (args2.directory === "global") {
-        skillDir = join16(getGlobalSkillsDir2(), args2.name);
+        skillDir = join18(getGlobalSkillsDir2(), args2.name);
       } else if (args2.directory === "global-claude") {
-        skillDir = join16(getClaudeGlobalSkillsDir2(), args2.name);
+        skillDir = join18(getClaudeGlobalSkillsDir2(), args2.name);
       } else {
         const baseDir = args2.directory || DEFAULT_SKILLS_DIR2;
-        skillDir = join16(skillsProjectDirectory2, baseDir, args2.name);
+        skillDir = join18(skillsProjectDirectory2, baseDir, args2.name);
       }
-      const skillPath = join16(skillDir, "SKILL.md");
+      const skillPath = join18(skillDir, "SKILL.md");
       try {
         await mkdir2(skillDir, { recursive: true });
         const content = generateSkillContent2(args2.name, args2.description, args2.body, { tags: args2.tags, tools: args2.tools });
@@ -27732,8 +27733,8 @@ executed with skills_execute. Use for:
       if (isAbsolute2(args2.script_name) || args2.script_name.includes("..") || args2.script_name.includes("/") || args2.script_name.includes("\\") || basename2(args2.script_name) !== args2.script_name) {
         return "Invalid script name. Use simple filenames without paths.";
       }
-      const scriptsDir = join16(skill.directory, "scripts");
-      const scriptPath = join16(scriptsDir, args2.script_name);
+      const scriptsDir = join18(skill.directory, "scripts");
+      const scriptPath = join18(scriptsDir, args2.script_name);
       try {
         await mkdir2(scriptsDir, { recursive: true });
         await writeFile2(scriptPath, args2.content, {
@@ -27782,20 +27783,20 @@ Perfect for learning to create effective skills.`,
       }
       let skillDir;
       if (args2.directory === "global") {
-        skillDir = join16(getGlobalSkillsDir2(), args2.name);
+        skillDir = join18(getGlobalSkillsDir2(), args2.name);
       } else {
         const baseDir = args2.directory || DEFAULT_SKILLS_DIR2;
-        skillDir = join16(skillsProjectDirectory2, baseDir, args2.name);
+        skillDir = join18(skillsProjectDirectory2, baseDir, args2.name);
       }
       const createdFiles = [];
       try {
         await mkdir2(skillDir, { recursive: true });
-        const skillPath = join16(skillDir, "SKILL.md");
+        const skillPath = join18(skillDir, "SKILL.md");
         const skillContent = generateSkillTemplate2(args2.name, args2.description);
         await writeFile2(skillPath, skillContent, "utf-8");
         createdFiles.push("SKILL.md");
         if (args2.include_example_script !== false) {
-          const scriptsDir = join16(skillDir, "scripts");
+          const scriptsDir = join18(skillDir, "scripts");
           await mkdir2(scriptsDir, { recursive: true });
           const exampleScript = `#!/usr/bin/env bash
 # Example helper script for ${args2.name}
@@ -27809,15 +27810,15 @@ echo "Project directory: $1"
 
 # TODO: Add actual script logic
 `;
-          const scriptPath = join16(scriptsDir, "example.sh");
+          const scriptPath = join18(scriptsDir, "example.sh");
           await writeFile2(scriptPath, exampleScript, { mode: 493 });
           createdFiles.push("scripts/example.sh");
         }
         if (args2.include_reference !== false) {
-          const refsDir = join16(skillDir, "references");
+          const refsDir = join18(skillDir, "references");
           await mkdir2(refsDir, { recursive: true });
           const refContent = generateReferenceTemplate2(args2.name);
-          const refPath = join16(refsDir, "guide.md");
+          const refPath = join18(refsDir, "guide.md");
           await writeFile2(refPath, refContent, "utf-8");
           createdFiles.push("references/guide.md");
         }
@@ -34576,14 +34577,14 @@ var require_parser2 = __commonJS((exports2) => {
           case "scalar":
           case "single-quoted-scalar":
           case "double-quoted-scalar": {
-            const fs6 = this.flowScalar(this.type);
+            const fs9 = this.flowScalar(this.type);
             if (atNextItem || it.value) {
-              map13.items.push({ start: start4, key: fs6, sep: [] });
+              map13.items.push({ start: start4, key: fs9, sep: [] });
               this.onKeyLine = true;
             } else if (it.sep) {
-              this.stack.push(fs6);
+              this.stack.push(fs9);
             } else {
-              Object.assign(it, { key: fs6, sep: [] });
+              Object.assign(it, { key: fs9, sep: [] });
               this.onKeyLine = true;
             }
             return;
@@ -34711,13 +34712,13 @@ var require_parser2 = __commonJS((exports2) => {
           case "scalar":
           case "single-quoted-scalar":
           case "double-quoted-scalar": {
-            const fs6 = this.flowScalar(this.type);
+            const fs9 = this.flowScalar(this.type);
             if (!it || it.value)
-              fc.items.push({ start: [], key: fs6, sep: [] });
+              fc.items.push({ start: [], key: fs9, sep: [] });
             else if (it.sep)
-              this.stack.push(fs6);
+              this.stack.push(fs9);
             else
-              Object.assign(it, { key: fs6, sep: [] });
+              Object.assign(it, { key: fs9, sep: [] });
             return;
           }
           case "flow-map-end":
@@ -36115,7 +36116,7 @@ var require_atomic_sleep = __commonJS((exports2, module2) => {
 
 // ../../node_modules/.bun/sonic-boom@4.2.0/node_modules/sonic-boom/index.js
 var require_sonic_boom = __commonJS((exports2, module2) => {
-  var fs6 = __require("fs");
+  var fs9 = __require("fs");
   var EventEmitter = __require("events");
   var inherits = __require("util").inherits;
   var path4 = __require("path");
@@ -36173,21 +36174,21 @@ var require_sonic_boom = __commonJS((exports2, module2) => {
     if (sonic.sync) {
       try {
         if (sonic.mkdir)
-          fs6.mkdirSync(path4.dirname(file4), { recursive: true });
-        const fd = fs6.openSync(file4, flags, mode);
+          fs9.mkdirSync(path4.dirname(file4), { recursive: true });
+        const fd = fs9.openSync(file4, flags, mode);
         fileOpened(null, fd);
       } catch (err) {
         fileOpened(err);
         throw err;
       }
     } else if (sonic.mkdir) {
-      fs6.mkdir(path4.dirname(file4), { recursive: true }, (err) => {
+      fs9.mkdir(path4.dirname(file4), { recursive: true }, (err) => {
         if (err)
           return fileOpened(err);
-        fs6.open(file4, flags, mode, fileOpened);
+        fs9.open(file4, flags, mode, fileOpened);
       });
     } else {
-      fs6.open(file4, flags, mode, fileOpened);
+      fs9.open(file4, flags, mode, fileOpened);
     }
   }
   function SonicBoom(opts) {
@@ -36228,16 +36229,16 @@ var require_sonic_boom = __commonJS((exports2, module2) => {
       this.flush = flushBuffer;
       this.flushSync = flushBufferSync;
       this._actualWrite = actualWriteBuffer;
-      fsWriteSync = () => fs6.writeSync(this.fd, this._writingBuf);
-      fsWrite = () => fs6.write(this.fd, this._writingBuf, this.release);
+      fsWriteSync = () => fs9.writeSync(this.fd, this._writingBuf);
+      fsWrite = () => fs9.write(this.fd, this._writingBuf, this.release);
     } else if (contentMode === undefined || contentMode === kContentModeUtf8) {
       this._writingBuf = "";
       this.write = write;
       this.flush = flush;
       this.flushSync = flushSync;
       this._actualWrite = actualWrite;
-      fsWriteSync = () => fs6.writeSync(this.fd, this._writingBuf, "utf8");
-      fsWrite = () => fs6.write(this.fd, this._writingBuf, "utf8", this.release);
+      fsWriteSync = () => fs9.writeSync(this.fd, this._writingBuf, "utf8");
+      fsWrite = () => fs9.write(this.fd, this._writingBuf, "utf8", this.release);
     } else {
       throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`);
     }
@@ -36293,7 +36294,7 @@ var require_sonic_boom = __commonJS((exports2, module2) => {
         }
       }
       if (this._fsync) {
-        fs6.fsyncSync(this.fd);
+        fs9.fsyncSync(this.fd);
       }
       const len = this._len;
       if (this._reopening) {
@@ -36406,7 +36407,7 @@ var require_sonic_boom = __commonJS((exports2, module2) => {
     const onDrain = () => {
       if (!this._fsync) {
         try {
-          fs6.fsync(this.fd, (err) => {
+          fs9.fsync(this.fd, (err) => {
             this._flushPending = false;
             cb(err);
           });
@@ -36508,7 +36509,7 @@ var require_sonic_boom = __commonJS((exports2, module2) => {
     const fd = this.fd;
     this.once("ready", () => {
       if (fd !== this.fd) {
-        fs6.close(fd, (err) => {
+        fs9.close(fd, (err) => {
           if (err) {
             return this.emit("error", err);
           }
@@ -36557,7 +36558,7 @@ var require_sonic_boom = __commonJS((exports2, module2) => {
         buf = this._bufs[0];
       }
       try {
-        const n = fs6.writeSync(this.fd, buf, "utf8");
+        const n = fs9.writeSync(this.fd, buf, "utf8");
         const releasedBufObj = releaseWritingBuf(buf, this._len, n);
         buf = releasedBufObj.writingBuf;
         this._len = releasedBufObj.len;
@@ -36573,7 +36574,7 @@ var require_sonic_boom = __commonJS((exports2, module2) => {
       }
     }
     try {
-      fs6.fsyncSync(this.fd);
+      fs9.fsyncSync(this.fd);
     } catch {}
   }
   function flushBufferSync() {
@@ -36593,7 +36594,7 @@ var require_sonic_boom = __commonJS((exports2, module2) => {
         buf = mergeBuf(this._bufs[0], this._lens[0]);
       }
       try {
-        const n = fs6.writeSync(this.fd, buf);
+        const n = fs9.writeSync(this.fd, buf);
         buf = buf.subarray(n);
         this._len = Math.max(this._len - n, 0);
         if (buf.length <= 0) {
@@ -36621,13 +36622,13 @@ var require_sonic_boom = __commonJS((exports2, module2) => {
     this._writingBuf = this._writingBuf || this._bufs.shift() || "";
     if (this.sync) {
       try {
-        const written = fs6.writeSync(this.fd, this._writingBuf, "utf8");
+        const written = fs9.writeSync(this.fd, this._writingBuf, "utf8");
         release(null, written);
       } catch (err) {
         release(err);
       }
     } else {
-      fs6.write(this.fd, this._writingBuf, "utf8", release);
+      fs9.write(this.fd, this._writingBuf, "utf8", release);
     }
   }
   function actualWriteBuffer() {
@@ -36636,7 +36637,7 @@ var require_sonic_boom = __commonJS((exports2, module2) => {
     this._writingBuf = this._writingBuf.length ? this._writingBuf : mergeBuf(this._bufs.shift(), this._lens.shift());
     if (this.sync) {
       try {
-        const written = fs6.writeSync(this.fd, this._writingBuf);
+        const written = fs9.writeSync(this.fd, this._writingBuf);
         release(null, written);
       } catch (err) {
         release(err);
@@ -36645,7 +36646,7 @@ var require_sonic_boom = __commonJS((exports2, module2) => {
       if (kCopyBuffer) {
         this._writingBuf = Buffer.from(this._writingBuf);
       }
-      fs6.write(this.fd, this._writingBuf, release);
+      fs9.write(this.fd, this._writingBuf, release);
     }
   }
   function actualClose(sonic) {
@@ -36661,11 +36662,11 @@ var require_sonic_boom = __commonJS((exports2, module2) => {
     sonic._lens = [];
     assert4(typeof sonic.fd === "number", `sonic.fd must be a number, got ${typeof sonic.fd}`);
     try {
-      fs6.fsync(sonic.fd, closeWrapped);
+      fs9.fsync(sonic.fd, closeWrapped);
     } catch {}
     function closeWrapped() {
       if (sonic.fd !== 1 && sonic.fd !== 2) {
-        fs6.close(sonic.fd, done8);
+        fs9.close(sonic.fd, done8);
       } else {
         done8();
       }
@@ -38953,7 +38954,7 @@ var require_multistream = __commonJS((exports2, module2) => {
 
 // ../../node_modules/.bun/pino@9.14.0/node_modules/pino/pino.js
 var require_pino = __commonJS((exports2, module2) => {
-  var os5 = __require("node:os");
+  var os6 = __require("node:os");
   var stdSerializers = require_pino_std_serializers();
   var caller = require_caller();
   var redaction = require_redaction();
@@ -39000,7 +39001,7 @@ var require_pino = __commonJS((exports2, module2) => {
   } = symbols;
   var { epochTime, nullTime } = time4;
   var { pid } = process;
-  var hostname4 = os5.hostname();
+  var hostname4 = os6.hostname();
   var defaultErrorSerializer = stdSerializers.err;
   var defaultOptions = {
     level: "info",
@@ -39164,18 +39165,18 @@ import * as p from "@clack/prompts";
 import {
   chmodSync,
   copyFileSync,
-  existsSync as existsSync17,
-  mkdirSync as mkdirSync9,
-  readFileSync as readFileSync13,
+  existsSync as existsSync20,
+  mkdirSync as mkdirSync11,
+  readFileSync as readFileSync16,
   readdirSync as readdirSync2,
   renameSync,
   rmdirSync,
   rmSync,
   statSync as statSync2,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "fs";
-import { homedir as homedir10 } from "os";
-import { basename as basename3, dirname as dirname7, join as join27 } from "path";
+import { homedir as homedir11 } from "os";
+import { basename as basename3, dirname as dirname9, join as join29 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // dist/hive.js
@@ -93817,13 +93818,13 @@ import {
   getLibSQLProjectTempDirName,
   getLibSQLDatabasePath,
   hashLibSQLProjectPath,
-  getSwarmMailLibSQL as getSwarmMailLibSQL17,
+  getSwarmMailLibSQL as getSwarmMailLibSQL19,
   createHiveAdapter as createHiveAdapter4,
   resolvePartialId as resolvePartialId4,
   createDurableStreamAdapter,
   createDurableStreamServer
 } from "swarm-mail";
-import { execSync } from "child_process";
+import { execSync, spawn } from "child_process";
 import { tmpdir as tmpdir3 } from "os";
 
 // src/query-tools.ts
@@ -95082,12 +95083,6 @@ function formatSwarmHistory(records) {
   return lines.join(`
 `);
 }
-var observabilityTools = {
-  swarm_analytics,
-  swarm_query,
-  swarm_diagnose,
-  swarm_insights
-};
 
 // src/observability-health.ts
 import { getSwarmMailLibSQL as getSwarmMailLibSQL9 } from "swarm-mail";
@@ -95105,20 +95100,6 @@ var STABILIZATION_THRESHOLD = 50;
 function getEvalHistoryPath(projectPath) {
   return path5.join(projectPath, DEFAULT_EVAL_HISTORY_PATH);
 }
-function ensureEvalHistoryDir(projectPath) {
-  const historyPath = getEvalHistoryPath(projectPath);
-  const dir = path5.dirname(historyPath);
-  if (!fs3.existsSync(dir)) {
-    fs3.mkdirSync(dir, { recursive: true });
-  }
-}
-function recordEvalRun(projectPath, run) {
-  ensureEvalHistoryDir(projectPath);
-  const historyPath = getEvalHistoryPath(projectPath);
-  const line = `${JSON.stringify(run)}
-`;
-  fs3.appendFileSync(historyPath, line, "utf-8");
-}
 function readAllRecords(projectPath) {
   const historyPath = getEvalHistoryPath(projectPath);
   if (!fs3.existsSync(historyPath)) {
@@ -95428,6 +95409,70 @@ async function getObservabilityHealth(projectPath, options2 = {}) {
   };
 }
 
+// src/eval-history.ts
+import * as fs5 from "node:fs";
+import * as path6 from "node:path";
+var DEFAULT_EVAL_HISTORY_PATH2 = ".opencode/eval-history.jsonl";
+var VARIANCE_THRESHOLD2 = 0.1;
+var BOOTSTRAP_THRESHOLD2 = 10;
+var STABILIZATION_THRESHOLD2 = 50;
+function getEvalHistoryPath2(projectPath) {
+  return path6.join(projectPath, DEFAULT_EVAL_HISTORY_PATH2);
+}
+function ensureEvalHistoryDir(projectPath) {
+  const historyPath = getEvalHistoryPath2(projectPath);
+  const dir = path6.dirname(historyPath);
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
+  }
+}
+function recordEvalRun(projectPath, run) {
+  ensureEvalHistoryDir(projectPath);
+  const historyPath = getEvalHistoryPath2(projectPath);
+  const line = `${JSON.stringify(run)}
+`;
+  fs5.appendFileSync(historyPath, line, "utf-8");
+}
+function readAllRecords3(projectPath) {
+  const historyPath = getEvalHistoryPath2(projectPath);
+  if (!fs5.existsSync(historyPath)) {
+    return [];
+  }
+  const content = fs5.readFileSync(historyPath, "utf-8");
+  const lines = content.trim().split(`
+`).filter(Boolean);
+  return lines.map((line) => JSON.parse(line));
+}
+function getScoreHistory2(projectPath, evalName) {
+  return readAllRecords3(projectPath).filter((run) => run.eval_name === evalName);
+}
+function calculateVariance2(scores) {
+  if (scores.length <= 1) {
+    return 0;
+  }
+  const mean = scores.reduce((sum, score) => sum + score, 0) / scores.length;
+  const variance5 = scores.reduce((sum, score) => {
+    const deviation = score - mean;
+    return sum + deviation * deviation;
+  }, 0) / scores.length;
+  return variance5;
+}
+function getPhase2(projectPath, evalName) {
+  const history = getScoreHistory2(projectPath, evalName);
+  if (history.length < BOOTSTRAP_THRESHOLD2) {
+    return "bootstrap";
+  }
+  if (history.length <= STABILIZATION_THRESHOLD2) {
+    return "stabilization";
+  }
+  const scores = history.map((run) => run.score);
+  const variance5 = calculateVariance2(scores);
+  if (variance5 < VARIANCE_THRESHOLD2) {
+    return "production";
+  }
+  return "stabilization";
+}
+
 // src/eval-gates.ts
 var DEFAULT_THRESHOLDS = {
   stabilization: 0.1,
@@ -95518,8 +95563,236 @@ function checkGate(projectPath, evalName, currentScore, config4) {
   };
 }
 
-// bin/swarm.ts
-init_eval_capture3();
+// src/eval-capture.ts
+init_zod3();
+import * as fs6 from "node:fs";
+import * as os3 from "node:os";
+import * as path7 from "node:path";
+import { getSwarmMailLibSQL as getSwarmMailLibSQL10 } from "swarm-mail";
+var SubtaskOutcomeSchema3 = exports_external3.object({
+  bead_id: exports_external3.string(),
+  title: exports_external3.string(),
+  planned_files: exports_external3.array(exports_external3.string()),
+  actual_files: exports_external3.array(exports_external3.string()),
+  duration_ms: exports_external3.number().int().min(0),
+  error_count: exports_external3.number().int().min(0),
+  retry_count: exports_external3.number().int().min(0),
+  success: exports_external3.boolean(),
+  failure_mode: exports_external3.string().optional()
+});
+var EvalRecordSchema3 = exports_external3.object({
+  id: exports_external3.string(),
+  timestamp: exports_external3.string(),
+  project_path: exports_external3.string(),
+  task: exports_external3.string(),
+  context: exports_external3.string().optional(),
+  strategy: exports_external3.enum(["file-based", "feature-based", "risk-based", "auto"]),
+  subtask_count: exports_external3.number().int().min(1),
+  epic_title: exports_external3.string(),
+  epic_description: exports_external3.string().optional(),
+  subtasks: exports_external3.array(exports_external3.object({
+    title: exports_external3.string(),
+    description: exports_external3.string().optional(),
+    files: exports_external3.array(exports_external3.string()),
+    dependencies: exports_external3.array(exports_external3.number()).optional(),
+    estimated_complexity: exports_external3.number().int().min(1).max(5).optional()
+  })),
+  outcomes: exports_external3.array(SubtaskOutcomeSchema3).optional(),
+  overall_success: exports_external3.boolean().optional(),
+  total_duration_ms: exports_external3.number().int().min(0).optional(),
+  total_errors: exports_external3.number().int().min(0).optional(),
+  human_accepted: exports_external3.boolean().optional(),
+  human_modified: exports_external3.boolean().optional(),
+  human_notes: exports_external3.string().optional(),
+  file_overlap_count: exports_external3.number().int().min(0).optional(),
+  scope_accuracy: exports_external3.number().min(0).max(2).optional(),
+  time_balance_ratio: exports_external3.number().min(1).optional()
+});
+var CoordinatorEventSchema3 = exports_external3.discriminatedUnion("event_type", [
+  exports_external3.object({
+    session_id: exports_external3.string(),
+    epic_id: exports_external3.string(),
+    timestamp: exports_external3.string(),
+    event_type: exports_external3.literal("DECISION"),
+    decision_type: exports_external3.enum([
+      "strategy_selected",
+      "worker_spawned",
+      "review_completed",
+      "decomposition_complete",
+      "researcher_spawned",
+      "skill_loaded",
+      "inbox_checked",
+      "blocker_resolved",
+      "scope_change_approved",
+      "scope_change_rejected"
+    ]),
+    payload: exports_external3.any()
+  }),
+  exports_external3.object({
+    session_id: exports_external3.string(),
+    epic_id: exports_external3.string(),
+    timestamp: exports_external3.string(),
+    event_type: exports_external3.literal("VIOLATION"),
+    violation_type: exports_external3.enum([
+      "coordinator_edited_file",
+      "coordinator_ran_tests",
+      "coordinator_reserved_files",
+      "no_worker_spawned",
+      "worker_completed_without_review"
+    ]),
+    payload: exports_external3.any()
+  }),
+  exports_external3.object({
+    session_id: exports_external3.string(),
+    epic_id: exports_external3.string(),
+    timestamp: exports_external3.string(),
+    event_type: exports_external3.literal("OUTCOME"),
+    outcome_type: exports_external3.enum([
+      "subtask_success",
+      "subtask_retry",
+      "subtask_failed",
+      "epic_complete",
+      "blocker_detected"
+    ]),
+    payload: exports_external3.any()
+  }),
+  exports_external3.object({
+    session_id: exports_external3.string(),
+    epic_id: exports_external3.string(),
+    timestamp: exports_external3.string(),
+    event_type: exports_external3.literal("COMPACTION"),
+    compaction_type: exports_external3.enum([
+      "detection_complete",
+      "prompt_generated",
+      "context_injected",
+      "resumption_started",
+      "tool_call_tracked"
+    ]),
+    payload: exports_external3.any()
+  })
+]);
+var CoordinatorSessionSchema3 = exports_external3.object({
+  session_id: exports_external3.string(),
+  epic_id: exports_external3.string(),
+  start_time: exports_external3.string(),
+  end_time: exports_external3.string().optional(),
+  events: exports_external3.array(CoordinatorEventSchema3)
+});
+var inProgressRecords3 = new Map;
+function getSessionDir3() {
+  return process.env.SWARM_SESSIONS_DIR || path7.join(os3.homedir(), ".config", "swarm-tools", "sessions");
+}
+function getSessionPath3(sessionId) {
+  return path7.join(getSessionDir3(), `${sessionId}.jsonl`);
+}
+function ensureSessionDir3() {
+  const sessionDir = getSessionDir3();
+  if (!fs6.existsSync(sessionDir)) {
+    fs6.mkdirSync(sessionDir, { recursive: true });
+  }
+}
+async function captureCoordinatorEvent3(event) {
+  CoordinatorEventSchema3.parse(event);
+  try {
+    const projectPath = process.cwd();
+    const swarmMail = await getSwarmMailLibSQL10(projectPath);
+    const eventType = `coordinator_${event.event_type.toLowerCase()}`;
+    const eventData = {
+      type: eventType,
+      project_key: projectPath,
+      timestamp: new Date(event.timestamp).getTime(),
+      session_id: event.session_id,
+      epic_id: event.epic_id,
+      event_type: event.event_type,
+      payload: event.payload
+    };
+    if (event.event_type === "DECISION") {
+      eventData.decision_type = event.decision_type;
+    } else if (event.event_type === "VIOLATION") {
+      eventData.violation_type = event.violation_type;
+    } else if (event.event_type === "OUTCOME") {
+      eventData.outcome_type = event.outcome_type;
+    } else if (event.event_type === "COMPACTION") {
+      eventData.compaction_type = event.compaction_type;
+    }
+    await swarmMail.appendEvent(eventData);
+    ensureSessionDir3();
+    const sessionPath = getSessionPath3(event.session_id);
+    const line = `${JSON.stringify(event)}
+`;
+    fs6.appendFileSync(sessionPath, line, "utf-8");
+  } catch (error54) {
+    console.warn("Failed to append event to libSQL, using JSONL fallback:", error54);
+    ensureSessionDir3();
+    const sessionPath = getSessionPath3(event.session_id);
+    const line = `${JSON.stringify(event)}
+`;
+    fs6.appendFileSync(sessionPath, line, "utf-8");
+  }
+}
+async function captureCompactionEvent3(params) {
+  const event = {
+    session_id: params.session_id,
+    epic_id: params.epic_id,
+    timestamp: new Date().toISOString(),
+    event_type: "COMPACTION",
+    compaction_type: params.compaction_type,
+    payload: params.payload
+  };
+  await captureCoordinatorEvent3(event);
+}
+
+// src/regression-detection.ts
+import * as fs7 from "node:fs";
+function readAllRecords4(projectPath) {
+  const historyPath = getEvalHistoryPath(projectPath);
+  if (!fs7.existsSync(historyPath)) {
+    return [];
+  }
+  const content = fs7.readFileSync(historyPath, "utf-8");
+  const lines = content.trim().split(`
+`).filter(Boolean);
+  return lines.map((line) => JSON.parse(line));
+}
+function getEvalNames2(records) {
+  const names = new Set;
+  for (const record4 of records) {
+    names.add(record4.eval_name);
+  }
+  return Array.from(names);
+}
+function getLastNRuns2(records, evalName, n) {
+  const evalRecords = records.filter((r) => r.eval_name === evalName);
+  return evalRecords.sort((a, b) => b.run_count - a.run_count).slice(0, n);
+}
+function detectRegressions2(projectPath, threshold = 0.1) {
+  const records = readAllRecords4(projectPath);
+  if (records.length === 0) {
+    return [];
+  }
+  const evalNames = getEvalNames2(records);
+  const regressions = [];
+  for (const evalName of evalNames) {
+    const lastTwoRuns = getLastNRuns2(records, evalName, 2);
+    if (lastTwoRuns.length < 2) {
+      continue;
+    }
+    const latest = lastTwoRuns[0];
+    const previous = lastTwoRuns[1];
+    const delta = previous.score - latest.score;
+    const deltaPercent = (latest.score - previous.score) / previous.score * 100;
+    if (delta > 0 && delta >= threshold) {
+      regressions.push({
+        evalName,
+        oldScore: previous.score,
+        newScore: latest.score,
+        delta,
+        deltaPercent
+      });
+    }
+  }
+  return regressions.sort((a, b) => b.delta - a.delta);
+}
 
 // src/hive.ts
 init_dist2();
@@ -95528,12 +95801,12 @@ import {
   FlushManager as FlushManager3,
   importFromJSONL as importFromJSONL3,
   syncMemories as syncMemories3,
-  getSwarmMailLibSQL as getSwarmMailLibSQL11,
+  getSwarmMailLibSQL as getSwarmMailLibSQL12,
   resolvePartialId as resolvePartialId3,
   findCellsByPartialId as findCellsByPartialId3
 } from "swarm-mail";
-import { existsSync as existsSync10, readFileSync as readFileSync10 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync13 } from "node:fs";
+import { join as join14 } from "node:path";
 
 // src/schemas/cell.ts
 init_zod3();
@@ -96131,10 +96404,10 @@ class HiveError3 extends Error {
   }
 }
 function ensureHiveDirectory3(projectPath) {
-  const hiveDir = join12(projectPath, ".hive");
-  if (!existsSync10(hiveDir)) {
-    const { mkdirSync: mkdirSync5 } = __require("node:fs");
-    mkdirSync5(hiveDir, { recursive: true });
+  const hiveDir = join14(projectPath, ".hive");
+  if (!existsSync13(hiveDir)) {
+    const { mkdirSync: mkdirSync7 } = __require("node:fs");
+    mkdirSync7(hiveDir, { recursive: true });
   }
 }
 var adapterCache3 = new Map;
@@ -96179,7 +96452,7 @@ async function getHiveAdapter3(projectKey) {
   if (adapterCache3.has(projectKey)) {
     return adapterCache3.get(projectKey);
   }
-  const swarmMail = await getSwarmMailLibSQL11(projectKey);
+  const swarmMail = await getSwarmMailLibSQL12(projectKey);
   const db = await swarmMail.getDatabase();
   const adapter = createHiveAdapter3(db, projectKey);
   await adapter.runMigrations();
@@ -96188,8 +96461,8 @@ async function getHiveAdapter3(projectKey) {
   return adapter;
 }
 async function autoMigrateFromJSONL3(adapter, projectKey) {
-  const jsonlPath = join12(projectKey, ".hive", "issues.jsonl");
-  if (!existsSync10(jsonlPath)) {
+  const jsonlPath = join14(projectKey, ".hive", "issues.jsonl");
+  if (!existsSync13(jsonlPath)) {
     return;
   }
   const existingCells = await adapter.queryCells(projectKey, { limit: 1 });
@@ -96197,7 +96470,7 @@ async function autoMigrateFromJSONL3(adapter, projectKey) {
     return;
   }
   try {
-    const jsonlContent = readFileSync10(jsonlPath, "utf-8");
+    const jsonlContent = readFileSync13(jsonlPath, "utf-8");
     const result = await importFromJSONL3(adapter, projectKey, jsonlContent, {
       skipExisting: true
     });
@@ -96370,14 +96643,14 @@ var hive_create_epic3 = tool3({
         console.warn("[hive_create_epic] Failed to emit SwarmStartedEvent:", error54);
       }
       try {
-        const { captureCoordinatorEvent: captureCoordinatorEvent4 } = await Promise.resolve().then(() => (init_eval_capture3(), exports_eval_capture3));
+        const { captureCoordinatorEvent: captureCoordinatorEvent5 } = await Promise.resolve().then(() => (init_eval_capture3(), exports_eval_capture3));
         const filesPerSubtask = {};
         validated.subtasks.forEach((subtask, index) => {
           if (subtask.files && subtask.files.length > 0) {
             filesPerSubtask[index] = subtask.files;
           }
         });
-        captureCoordinatorEvent4({
+        captureCoordinatorEvent5({
           session_id: ctx.sessionID || "unknown",
           epic_id: epic.id,
           timestamp: new Date().toISOString(),
@@ -96807,9 +97080,9 @@ var hive_sync3 = tool3({
       outputPath: `${projectKey}/.hive/issues.jsonl`
     });
     const flushResult = await withTimeout(flushManager.flush(), TIMEOUT_MS, "flush hive");
-    const swarmMail = await getSwarmMailLibSQL11(projectKey);
+    const swarmMail = await getSwarmMailLibSQL12(projectKey);
     const db = await swarmMail.getDatabase();
-    const hivePath = join12(projectKey, ".hive");
+    const hivePath = join14(projectKey, ".hive");
     let memoriesSynced = 0;
     try {
       const memoryResult = await syncMemories3(db, hivePath);
@@ -97312,9 +97585,9 @@ function formatToolAvailability2(availability) {
 
 // src/rate-limiter.ts
 var import_ioredis = __toESM(require_built3(), 1);
-import { mkdirSync as mkdirSync5, existsSync as existsSync11 } from "node:fs";
-import { dirname as dirname5, join as join13 } from "node:path";
-import { homedir as homedir6 } from "node:os";
+import { mkdirSync as mkdirSync7, existsSync as existsSync14 } from "node:fs";
+import { dirname as dirname7, join as join15 } from "node:path";
+import { homedir as homedir7 } from "node:os";
 var sqliteAvailable = false;
 var createDatabase = null;
 try {
@@ -97428,9 +97701,9 @@ class SqliteRateLimiter {
     if (!sqliteAvailable || !createDatabase) {
       throw new Error("SQLite is not available in this runtime (requires Bun)");
     }
-    const dir = dirname5(dbPath);
-    if (!existsSync11(dir)) {
-      mkdirSync5(dir, { recursive: true });
+    const dir = dirname7(dbPath);
+    if (!existsSync14(dir)) {
+      mkdirSync7(dir, { recursive: true });
     }
     this.db = createDatabase(dbPath);
     this.initialize();
@@ -97574,7 +97847,7 @@ async function createRateLimiter(options2) {
   const {
     backend,
     redisUrl = process.env.OPENCODE_RATE_LIMIT_REDIS_URL || "redis://localhost:6379",
-    sqlitePath = process.env.OPENCODE_RATE_LIMIT_SQLITE_PATH || join13(homedir6(), ".config", "opencode", "rate-limits.db")
+    sqlitePath = process.env.OPENCODE_RATE_LIMIT_SQLITE_PATH || join15(homedir7(), ".config", "opencode", "rate-limits.db")
   } = options2 || {};
   if (backend === "memory") {
     return new InMemoryRateLimiter;
@@ -97634,13 +97907,13 @@ async function getRateLimiter() {
 
 // src/agent-mail.ts
 import {
-  existsSync as existsSync12,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync11,
-  writeFileSync as writeFileSync4,
+  existsSync as existsSync15,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync14,
+  writeFileSync as writeFileSync5,
   unlinkSync
 } from "fs";
-import { join as join14 } from "path";
+import { join as join16 } from "path";
 import { tmpdir } from "os";
 var AGENT_MAIL_URL = "http://127.0.0.1:8765";
 var DEFAULT_TTL_SECONDS = 3600;
@@ -97661,16 +97934,16 @@ var RECOVERY_CONFIG = {
   restartCooldownMs: 1e4,
   enabled: process.env.OPENCODE_AGENT_MAIL_AUTO_RESTART !== "false"
 };
-var SESSION_STATE_DIR = process.env.SWARM_STATE_DIR || join14(tmpdir(), "swarm-sessions");
+var SESSION_STATE_DIR = process.env.SWARM_STATE_DIR || join16(tmpdir(), "swarm-sessions");
 function getSessionStatePath(sessionID) {
   const safeID = sessionID.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join14(SESSION_STATE_DIR, `${safeID}.json`);
+  return join16(SESSION_STATE_DIR, `${safeID}.json`);
 }
 function loadSessionState(sessionID) {
   const path4 = getSessionStatePath(sessionID);
   try {
-    if (existsSync12(path4)) {
-      const data = readFileSync11(path4, "utf-8");
+    if (existsSync15(path4)) {
+      const data = readFileSync14(path4, "utf-8");
       return JSON.parse(data);
     }
   } catch (error54) {
@@ -97680,11 +97953,11 @@ function loadSessionState(sessionID) {
 }
 function saveSessionState(sessionID, state) {
   try {
-    if (!existsSync12(SESSION_STATE_DIR)) {
-      mkdirSync6(SESSION_STATE_DIR, { recursive: true });
+    if (!existsSync15(SESSION_STATE_DIR)) {
+      mkdirSync8(SESSION_STATE_DIR, { recursive: true });
     }
     const path4 = getSessionStatePath(sessionID);
-    writeFileSync4(path4, JSON.stringify(state, null, 2));
+    writeFileSync5(path4, JSON.stringify(state, null, 2));
     return true;
   } catch (error54) {
     console.error(`[agent-mail] CRITICAL: Could not save session state: ${error54}`);
@@ -98368,29 +98641,29 @@ import {
   getActiveReservations
 } from "swarm-mail";
 import {
-  existsSync as existsSync13,
-  mkdirSync as mkdirSync7,
-  readFileSync as readFileSync12,
-  writeFileSync as writeFileSync5,
+  existsSync as existsSync16,
+  mkdirSync as mkdirSync9,
+  readFileSync as readFileSync15,
+  writeFileSync as writeFileSync6,
   unlinkSync as unlinkSync2
 } from "node:fs";
-import { join as join15 } from "node:path";
+import { join as join17 } from "node:path";
 import { tmpdir as tmpdir2 } from "node:os";
 var MAX_INBOX_LIMIT2 = 5;
 var swarmMailProjectDirectory = null;
 function getSwarmMailProjectDirectory() {
   return swarmMailProjectDirectory ?? undefined;
 }
-var SESSION_STATE_DIR2 = process.env.SWARM_STATE_DIR || join15(tmpdir2(), "swarm-sessions");
+var SESSION_STATE_DIR2 = process.env.SWARM_STATE_DIR || join17(tmpdir2(), "swarm-sessions");
 function getSessionStatePath2(sessionID) {
   const safeID = sessionID.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join15(SESSION_STATE_DIR2, `${safeID}.json`);
+  return join17(SESSION_STATE_DIR2, `${safeID}.json`);
 }
 function loadSessionState2(sessionID) {
   const path4 = getSessionStatePath2(sessionID);
   try {
-    if (existsSync13(path4)) {
-      const data = readFileSync12(path4, "utf-8");
+    if (existsSync16(path4)) {
+      const data = readFileSync15(path4, "utf-8");
       return JSON.parse(data);
     }
   } catch (error54) {
@@ -98400,11 +98673,11 @@ function loadSessionState2(sessionID) {
 }
 function saveSessionState2(sessionID, state) {
   try {
-    if (!existsSync13(SESSION_STATE_DIR2)) {
-      mkdirSync7(SESSION_STATE_DIR2, { recursive: true });
+    if (!existsSync16(SESSION_STATE_DIR2)) {
+      mkdirSync9(SESSION_STATE_DIR2, { recursive: true });
     }
     const path4 = getSessionStatePath2(sessionID);
-    writeFileSync5(path4, JSON.stringify(state, null, 2));
+    writeFileSync6(path4, JSON.stringify(state, null, 2));
     return true;
   } catch (error54) {
     console.warn(`[swarm-mail] Could not save session state: ${error54}`);
@@ -99713,7 +99986,7 @@ var swarm_delegate_planning = tool3({
       strategyReasoning = selection.reasoning;
     }
     try {
-      captureCoordinatorEvent3({
+      captureCoordinatorEvent4({
         session_id: _ctx.sessionID || "unknown",
         epic_id: "planning",
         timestamp: new Date().toISOString(),
@@ -100882,11 +101155,11 @@ var qmarksTestNoExtDot2 = ([$0]) => {
   return (f) => f.length === len && f !== "." && f !== "..";
 };
 var defaultPlatform2 = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-var path7 = {
+var path9 = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep5 = defaultPlatform2 === "win32" ? path7.win32.sep : path7.posix.sep;
+var sep5 = defaultPlatform2 === "win32" ? path9.win32.sep : path9.posix.sep;
 minimatch2.sep = sep5;
 var GLOBSTAR2 = Symbol("globstar **");
 minimatch2.GLOBSTAR = GLOBSTAR2;
@@ -101524,19 +101797,19 @@ import {
   getAgent as getAgent2,
   createEvent as createEvent8,
   appendEvent as appendEvent6,
-  getSwarmMailLibSQL as getSwarmMailLibSQL13
+  getSwarmMailLibSQL as getSwarmMailLibSQL14
 } from "swarm-mail";
 init_skills2();
 
 // src/swarm-worktree.ts
 init_dist2();
 init_zod3();
-import { join as join17 } from "node:path";
-import { existsSync as existsSync14 } from "node:fs";
+import { join as join19 } from "node:path";
+import { existsSync as existsSync17 } from "node:fs";
 var WORKTREE_DIR2 = ".swarm/worktrees";
 function getWorktreePath2(projectPath, taskId) {
   const safeTaskId = taskId.replace(/[^a-zA-Z0-9.-]/g, "_");
-  return join17(projectPath, WORKTREE_DIR2, safeTaskId);
+  return join19(projectPath, WORKTREE_DIR2, safeTaskId);
 }
 function parseTaskIdFromPath2(worktreePath) {
   const parts2 = worktreePath.split("/");
@@ -101570,7 +101843,7 @@ async function getWorktreeCommits2(worktreePath, startCommit) {
 `).filter((c) => c.length > 0);
 }
 async function ensureWorktreeDir2(projectPath) {
-  const worktreeDir = join17(projectPath, WORKTREE_DIR2);
+  const worktreeDir = join19(projectPath, WORKTREE_DIR2);
   await Bun.$`mkdir -p ${worktreeDir}`.quiet().nothrow();
 }
 var swarm_worktree_create2 = tool3({
@@ -101589,7 +101862,7 @@ var swarm_worktree_create2 = tool3({
       return JSON.stringify(result2, null, 2);
     }
     const worktreePath = getWorktreePath2(args2.project_path, args2.task_id);
-    const exists3 = existsSync14(worktreePath);
+    const exists3 = existsSync17(worktreePath);
     if (exists3) {
       const result2 = {
         success: false,
@@ -101625,7 +101898,7 @@ var swarm_worktree_merge2 = tool3({
   },
   async execute(args2) {
     const worktreePath = getWorktreePath2(args2.project_path, args2.task_id);
-    const exists3 = existsSync14(worktreePath);
+    const exists3 = existsSync17(worktreePath);
     if (!exists3) {
       const result2 = {
         success: false,
@@ -101707,7 +101980,7 @@ var swarm_worktree_cleanup2 = tool3({
         return JSON.stringify(result3, null, 2);
       }
       const output = listResult.stdout.toString();
-      const worktreeDir = join17(args2.project_path, WORKTREE_DIR2);
+      const worktreeDir = join19(args2.project_path, WORKTREE_DIR2);
       const worktrees = output.split(`
 
 `).filter((block) => block.includes(worktreeDir)).map((block) => {
@@ -101735,7 +102008,7 @@ var swarm_worktree_cleanup2 = tool3({
       return JSON.stringify(result2, null, 2);
     }
     const worktreePath = getWorktreePath2(args2.project_path, args2.task_id);
-    const exists3 = existsSync14(worktreePath);
+    const exists3 = existsSync17(worktreePath);
     if (!exists3) {
       const result2 = {
         success: true,
@@ -101772,7 +102045,7 @@ var swarm_worktree_list2 = tool3({
       }, null, 2);
     }
     const output = listResult.stdout.toString();
-    const worktreeDir = join17(args2.project_path, WORKTREE_DIR2);
+    const worktreeDir = join19(args2.project_path, WORKTREE_DIR2);
     const worktrees = [];
     const blocks = output.split(`
 
@@ -102086,7 +102359,7 @@ var swarm_review_feedback2 = tool3({
     if (args2.status === "approved") {
       markReviewApproved2(args2.task_id);
       try {
-        captureCoordinatorEvent3({
+        captureCoordinatorEvent4({
           session_id: _ctx.sessionID || "unknown",
           epic_id: epicId,
           timestamp: new Date().toISOString(),
@@ -102154,7 +102427,7 @@ You may now complete the task with \`swarm_complete\`.`,
     const attemptNumber = incrementAttempt2(args2.task_id);
     const remaining = MAX_REVIEW_ATTEMPTS2 - attemptNumber;
     try {
-      captureCoordinatorEvent3({
+      captureCoordinatorEvent4({
         session_id: _ctx.sessionID || "unknown",
         epic_id: epicId,
         timestamp: new Date().toISOString(),
@@ -103008,7 +103281,7 @@ This will be recorded as a negative learning signal.`;
       let deferredResolved = false;
       let deferredError;
       try {
-        const swarmMail = await getSwarmMailLibSQL13(args2.project_key);
+        const swarmMail = await getSwarmMailLibSQL14(args2.project_key);
         const db = await swarmMail.getDatabase();
         const deferredUrl = `deferred:${args2.bead_id}`;
         const checkResult = await db.query(`SELECT url, resolved FROM deferred WHERE url = ? AND resolved = 0`, [deferredUrl]);
@@ -103207,7 +103480,7 @@ Files touched: ${args2.files_touched?.join(", ") || "none recorded"}`,
       }
       try {
         const durationMs = args2.start_time ? Date.now() - args2.start_time : 0;
-        captureCoordinatorEvent3({
+        captureCoordinatorEvent4({
           session_id: _ctx.sessionID || "unknown",
           epic_id: epicId2,
           timestamp: new Date().toISOString(),
@@ -103289,7 +103562,7 @@ ${errorStack.slice(0, 1000)}
       }
       try {
         const durationMs = args2.start_time ? Date.now() - args2.start_time : 0;
-        captureCoordinatorEvent3({
+        captureCoordinatorEvent4({
           session_id: _ctx.sessionID || "unknown",
           epic_id: epicId,
           timestamp: new Date().toISOString(),
@@ -103934,7 +104207,7 @@ init_eval_capture3();
 
 // src/memory-tools.ts
 init_dist2();
-import { getSwarmMailLibSQL as getSwarmMailLibSQL14, createEvent as createEvent9, appendEvent as appendEvent7 } from "swarm-mail";
+import { getSwarmMailLibSQL as getSwarmMailLibSQL15, createEvent as createEvent9, appendEvent as appendEvent7 } from "swarm-mail";
 
 // ../../node_modules/.bun/effect@3.19.12/node_modules/effect/dist/esm/Function.js
 var isFunction3 = (input) => typeof input === "function";
@@ -104965,7 +105238,7 @@ var dedupeWith2 = /* @__PURE__ */ dual2(2, (self, isEquivalent) => {
   return [];
 });
 var dedupe2 = (self) => dedupeWith2(self, equivalence2());
-var join18 = /* @__PURE__ */ dual2(2, (self, sep4) => fromIterable8(self).join(sep4));
+var join20 = /* @__PURE__ */ dual2(2, (self, sep4) => fromIterable8(self).join(sep4));
 
 // ../../node_modules/.bun/effect@3.19.12/node_modules/effect/dist/esm/Number.js
 var Order3 = number10;
@@ -109516,8 +109789,8 @@ var InvalidData2 = (path4, message, options2 = {
   Object.defineProperty(error54, "toString", {
     enumerable: false,
     value() {
-      const path8 = pipe4(this.path, join18(options2.pathDelim));
-      return `(Invalid data at ${path8}: "${this.message}")`;
+      const path10 = pipe4(this.path, join20(options2.pathDelim));
+      return `(Invalid data at ${path10}: "${this.message}")`;
     }
   });
   return error54;
@@ -109532,8 +109805,8 @@ var MissingData2 = (path4, message, options2 = {
   Object.defineProperty(error54, "toString", {
     enumerable: false,
     value() {
-      const path8 = pipe4(this.path, join18(options2.pathDelim));
-      return `(Missing data at ${path8}: "${this.message}")`;
+      const path10 = pipe4(this.path, join20(options2.pathDelim));
+      return `(Missing data at ${path10}: "${this.message}")`;
     }
   });
   return error54;
@@ -109549,8 +109822,8 @@ var SourceUnavailable2 = (path4, message, cause3, options2 = {
   Object.defineProperty(error54, "toString", {
     enumerable: false,
     value() {
-      const path8 = pipe4(this.path, join18(options2.pathDelim));
-      return `(Source unavailable at ${path8}: "${this.message}")`;
+      const path10 = pipe4(this.path, join20(options2.pathDelim));
+      return `(Source unavailable at ${path10}: "${this.message}")`;
     }
   });
   return error54;
@@ -109565,8 +109838,8 @@ var Unsupported2 = (path4, message, options2 = {
   Object.defineProperty(error54, "toString", {
     enumerable: false,
     value() {
-      const path8 = pipe4(this.path, join18(options2.pathDelim));
-      return `(Unsupported operation at ${path8}: "${this.message}")`;
+      const path10 = pipe4(this.path, join20(options2.pathDelim));
+      return `(Unsupported operation at ${path10}: "${this.message}")`;
     }
   });
   return error54;
@@ -109685,7 +109958,7 @@ var fromEnv2 = (options2) => {
     pathDelim: "_",
     seqDelim: ","
   }, options2);
-  const makePathString = (path4) => pipe4(path4, join18(pathDelim));
+  const makePathString = (path4) => pipe4(path4, join20(pathDelim));
   const unmakePathString = (pathString) => pathString.split(pathDelim);
   const getEnv = () => typeof process !== "undefined" && ("env" in process) && typeof process.env === "object" ? process.env : {};
   const load = (path4, primitive, split = true) => {
@@ -109809,7 +110082,7 @@ var fromFlatLoop2 = (flat, prefix, config4, split) => {
           return fail5(right4.left);
         }
         if (isRight5(left4) && isRight5(right4)) {
-          const path4 = pipe4(prefix, join18("."));
+          const path4 = pipe4(prefix, join20("."));
           const fail6 = fromFlatLoopFail2(prefix, path4);
           const [lefts, rights] = extend4(fail6, fail6, pipe4(left4.right, map8(right5)), pipe4(right4.right, map8(right5)));
           return pipe4(lefts, zip3(rights), forEachSequential2(([left6, right6]) => pipe4(zip5(left6, right6), map18(([left7, right7]) => op.zip(left7, right7)))));
@@ -111983,11 +112256,11 @@ var interruptAllAs2 = /* @__PURE__ */ dual2(2, /* @__PURE__ */ fnUntraced3(funct
   }
 }));
 var interruptAsFork2 = /* @__PURE__ */ dual2(2, (self, fiberId4) => self.interruptAsFork(fiberId4));
-var join19 = (self) => zipLeft3(flatten11(self.await), self.inheritAll);
+var join21 = (self) => zipLeft3(flatten11(self.await), self.inheritAll);
 var _never4 = {
   ...CommitPrototype3,
   commit() {
-    return join19(this);
+    return join21(this);
   },
   ...fiberProto2,
   id: () => none14,
@@ -113234,7 +113507,7 @@ class FiberRuntime2 extends Class4 {
     this.refreshRefCache();
   }
   commit() {
-    return join19(this);
+    return join21(this);
   }
   id() {
     return this._fiberId;
@@ -114249,7 +114522,7 @@ var forEachConcurrentDiscard2 = (self, f, batching, processAll, n) => uninterrup
       next();
     }
   }));
-  return asVoid4(onExit4(flatten11(restore(join19(processingFiber))), exitMatch2({
+  return asVoid4(onExit4(flatten11(restore(join21(processingFiber))), exitMatch2({
     onFailure: (cause4) => {
       onInterruptSignal();
       const target2 = residual.length + 1;
@@ -114571,7 +114844,7 @@ var fiberAll2 = (fibers) => {
   const _fiberAll = {
     ...CommitPrototype5,
     commit() {
-      return join19(this);
+      return join21(this);
     },
     [FiberTypeId2]: fiberVariance5,
     id: () => fromIterable8(fibers).reduce((id, fiber) => combine12(id, fiber.id()), none14),
@@ -114624,14 +114897,14 @@ var raceWith3 = /* @__PURE__ */ dual2(3, (self, other, options2) => raceFibersWi
     }
   })
 }));
-var disconnect3 = (self) => uninterruptibleMask4((restore) => fiberIdWith3((fiberId4) => flatMap15(forkDaemon3(restore(self)), (fiber) => pipe4(restore(join19(fiber)), onInterrupt3(() => pipe4(fiber, interruptAsFork2(fiberId4)))))));
+var disconnect3 = (self) => uninterruptibleMask4((restore) => fiberIdWith3((fiberId4) => flatMap15(forkDaemon3(restore(self)), (fiber) => pipe4(restore(join21(fiber)), onInterrupt3(() => pipe4(fiber, interruptAsFork2(fiberId4)))))));
 var race3 = /* @__PURE__ */ dual2(2, (self, that) => fiberIdWith3((parentFiberId) => raceWith3(self, that, {
   onSelfDone: (exit4, right4) => exitMatchEffect2(exit4, {
-    onFailure: (cause4) => pipe4(join19(right4), mapErrorCause3((cause22) => parallel4(cause4, cause22))),
+    onFailure: (cause4) => pipe4(join21(right4), mapErrorCause3((cause22) => parallel4(cause4, cause22))),
     onSuccess: (value) => pipe4(right4, interruptAsFiber2(parentFiberId), as3(value))
   }),
   onOtherDone: (exit4, left4) => exitMatchEffect2(exit4, {
-    onFailure: (cause4) => pipe4(join19(left4), mapErrorCause3((cause22) => parallel4(cause22, cause4))),
+    onFailure: (cause4) => pipe4(join21(left4), mapErrorCause3((cause22) => parallel4(cause22, cause4))),
     onSuccess: (value) => pipe4(left4, interruptAsFiber2(parentFiberId), as3(value))
   })
 })));
@@ -115785,8 +116058,8 @@ var forkIn3 = /* @__PURE__ */ dual2(2, (self, scope4) => withFiberRuntime3((pare
   return succeed5(fiber);
 }));
 var forkScoped3 = (self) => scopeWith3((scope4) => forkIn3(self, scope4));
-var fromFiber3 = (fiber) => join19(fiber);
-var fromFiberEffect3 = (fiber) => suspend4(() => flatMap15(fiber, join19));
+var fromFiber3 = (fiber) => join21(fiber);
+var fromFiberEffect3 = (fiber) => suspend4(() => flatMap15(fiber, join21));
 var memoKeySymbol2 = /* @__PURE__ */ Symbol.for("effect/Effect/memoizeFunction.key");
 
 class Key2 {
@@ -117551,7 +117824,7 @@ async function getMemoryAdapter2(projectPath) {
   if (cachedAdapter2 && cachedProjectPath2 === path4) {
     return cachedAdapter2;
   }
-  const swarmMail = await getSwarmMailLibSQL14(path4);
+  const swarmMail = await getSwarmMailLibSQL15(path4);
   const dbAdapter = await swarmMail.getDatabase();
   cachedAdapter2 = await createMemoryAdapter2(dbAdapter);
   cachedProjectPath2 = path4;
@@ -118676,7 +118949,7 @@ var swarm_spawn_subtask2 = tool3({
     const filesJoined = args3.files.map((f) => `"${f}"`).join(", ");
     const postCompletionInstructions = COORDINATOR_POST_WORKER_CHECKLIST2.replace(/{project_key}/g, args3.project_path || "$PWD").replace(/{epic_id}/g, args3.epic_id).replace(/{task_id}/g, args3.bead_id).replace(/{files_touched}/g, filesJoined).replace(/{worker_id}/g, "worker");
     try {
-      captureCoordinatorEvent3({
+      captureCoordinatorEvent4({
         session_id: _ctx.sessionID || "unknown",
         epic_id: args3.epic_id,
         timestamp: new Date().toISOString(),
@@ -119010,9 +119283,9 @@ var promptTools2 = {
 };
 // src/swarm-research.ts
 init_dist2();
-import { existsSync as existsSync15 } from "node:fs";
+import { existsSync as existsSync18 } from "node:fs";
 import { readFile as readFile3 } from "node:fs/promises";
-import { join as join20 } from "node:path";
+import { join as join23 } from "node:path";
 
 // ../../node_modules/.bun/yaml@2.8.2/node_modules/yaml/dist/index.js
 var composer = require_composer();
@@ -119190,21 +119463,21 @@ async function parsePackageJson(packageJsonPath, packages) {
   }
 }
 async function getInstalledVersions(projectPath, packages, checkUpgrades = false) {
-  const npmLock = join20(projectPath, "package-lock.json");
+  const npmLock = join23(projectPath, "package-lock.json");
   let versions2 = [];
-  if (existsSync15(npmLock)) {
+  if (existsSync18(npmLock)) {
     versions2 = await parseNpmLockfile(npmLock, packages);
   } else {
-    const pnpmLock = join20(projectPath, "pnpm-lock.yaml");
-    if (existsSync15(pnpmLock)) {
+    const pnpmLock = join23(projectPath, "pnpm-lock.yaml");
+    if (existsSync18(pnpmLock)) {
       versions2 = await parsePnpmLockfile(pnpmLock, packages);
     } else {
-      const yarnLock = join20(projectPath, "yarn.lock");
-      if (existsSync15(yarnLock)) {
+      const yarnLock = join23(projectPath, "yarn.lock");
+      if (existsSync18(yarnLock)) {
         versions2 = await parseYarnLockfile(yarnLock, packages);
       } else {
-        const packageJson = join20(projectPath, "package.json");
-        if (existsSync15(packageJson)) {
+        const packageJson = join23(projectPath, "package.json");
+        if (existsSync18(packageJson)) {
           versions2 = await parsePackageJson(packageJson, packages);
         }
       }
@@ -120346,16 +120619,16 @@ var mandateTools = {
 // src/hivemind-tools.ts
 init_dist2();
 import {
-  getSwarmMailLibSQL as getSwarmMailLibSQL15,
+  getSwarmMailLibSQL as getSwarmMailLibSQL16,
   createEvent as createEvent10,
   SessionIndexer,
   syncMemories as syncMemories4,
   toSwarmDb as toSwarmDb3,
   makeOllamaLive as makeOllamaLive3
 } from "swarm-mail";
-import * as os4 from "node:os";
-import * as path8 from "node:path";
-import { join as join23 } from "node:path";
+import * as os5 from "node:os";
+import * as path10 from "node:path";
+import { join as join26 } from "node:path";
 var cachedAdapter3 = null;
 var cachedIndexer = null;
 var cachedProjectPath3 = null;
@@ -120364,7 +120637,7 @@ async function getMemoryAdapter3(projectPath) {
   if (cachedAdapter3 && cachedProjectPath3 === path4) {
     return cachedAdapter3;
   }
-  const swarmMail = await getSwarmMailLibSQL15(path4);
+  const swarmMail = await getSwarmMailLibSQL16(path4);
   const dbAdapter = await swarmMail.getDatabase();
   cachedAdapter3 = await createMemoryAdapter2(dbAdapter);
   cachedProjectPath3 = path4;
@@ -120375,7 +120648,7 @@ async function getSessionIndexer(projectPath) {
   if (cachedIndexer && cachedProjectPath3 === path4) {
     return cachedIndexer;
   }
-  const swarmMail = await getSwarmMailLibSQL15(path4);
+  const swarmMail = await getSwarmMailLibSQL16(path4);
   const dbAdapter = await swarmMail.getDatabase();
   const db = toSwarmDb3(dbAdapter);
   const ollamaLayer = makeOllamaLive3({
@@ -120390,7 +120663,7 @@ var getHivemindAdapter = getMemoryAdapter3;
 async function emitEvent(eventType, data) {
   try {
     const projectPath = cachedProjectPath3 || process.cwd();
-    const swarmMail = await getSwarmMailLibSQL15(projectPath);
+    const swarmMail = await getSwarmMailLibSQL16(projectPath);
     const event = createEvent10(eventType, {
       project_key: projectPath,
       ...data
@@ -120399,11 +120672,11 @@ async function emitEvent(eventType, data) {
   } catch {}
 }
 var AGENT_DIRECTORIES = [
-  path8.join(os4.homedir(), ".config", "swarm-tools", "sessions"),
-  path8.join(os4.homedir(), ".opencode"),
-  path8.join(os4.homedir(), "Cursor", "User", "History"),
-  path8.join(os4.homedir(), ".local", "share", "Claude"),
-  path8.join(os4.homedir(), ".aider")
+  path10.join(os5.homedir(), ".config", "swarm-tools", "sessions"),
+  path10.join(os5.homedir(), ".opencode"),
+  path10.join(os5.homedir(), "Cursor", "User", "History"),
+  path10.join(os5.homedir(), ".local", "share", "Claude"),
+  path10.join(os5.homedir(), ".aider")
 ];
 var hivemind_store = tool3({
   description: "Store a memory (learning, decision, pattern) with semantic embedding. Memories are searchable by semantic similarity and organized into collections. Use collection='default' for manual learnings.",
@@ -120560,9 +120833,9 @@ var hivemind_sync = tool3({
   async execute(args3, ctx) {
     try {
       const projectPath = cachedProjectPath3 || process.cwd();
-      const swarmMail = await getSwarmMailLibSQL15(projectPath);
+      const swarmMail = await getSwarmMailLibSQL16(projectPath);
       const dbAdapter = await swarmMail.getDatabase();
-      const hiveDir = join23(projectPath, ".hive");
+      const hiveDir = join26(projectPath, ".hive");
       const result = await syncMemories4(dbAdapter, hiveDir);
       await emitEvent("memories_synced", {
         imported: result.imported.created,
@@ -120632,6 +120905,370 @@ var hivemindTools = {
   cass_stats
 };
 
+// src/observability-tools.ts
+init_dist2();
+import {
+  agentActivity as agentActivity2,
+  checkpointFrequency as checkpointFrequency2,
+  failedDecompositions as failedDecompositions2,
+  getSwarmMailLibSQL as getSwarmMailLibSQL17,
+  humanFeedback as humanFeedback2,
+  lockContention as lockContention2,
+  messageLatency as messageLatency2,
+  recoverySuccess as recoverySuccess2,
+  scopeViolations as scopeViolations2,
+  strategySuccessRates as strategySuccessRates2,
+  taskDuration as taskDuration2
+} from "swarm-mail";
+function parseSince2(since) {
+  const now = Date.now();
+  const match12 = since.match(/^(\d+)([dhm])$/);
+  if (!match12) {
+    throw new Error(`Invalid since format: ${since}. Use "7d", "24h", or "1h"`);
+  }
+  const [, value, unit] = match12;
+  const num = Number.parseInt(value, 10);
+  switch (unit) {
+    case "d":
+      return now - num * 24 * 60 * 60 * 1000;
+    case "h":
+      return now - num * 60 * 60 * 1000;
+    case "m":
+      return now - num * 60 * 1000;
+    default:
+      throw new Error(`Unknown unit: ${unit}`);
+  }
+}
+async function executeQuery3(swarmMail, query) {
+  const db = await swarmMail.getDatabase();
+  const result = await db.query(query.sql, Object.values(query.parameters || {}));
+  return result.rows;
+}
+function formatSummary2(queryType, results) {
+  if (results.length === 0) {
+    return `No ${queryType} data found.`;
+  }
+  const count = results.length;
+  const preview = results.slice(0, 3);
+  return `${queryType}: ${count} result(s). Top 3: ${JSON.stringify(preview, null, 2).slice(0, 400)}`;
+}
+function capResults2(results) {
+  return results.slice(0, 50);
+}
+var swarm_analytics2 = tool3({
+  description: "Query pre-built analytics for swarm coordination. Returns structured data about failed decompositions, strategy success rates, lock contention, agent activity, message latency, scope violations, task duration, checkpoint frequency, recovery success, and human feedback.",
+  args: {
+    query: tool3.schema.enum([
+      "failed-decompositions",
+      "strategy-success-rates",
+      "lock-contention",
+      "agent-activity",
+      "message-latency",
+      "scope-violations",
+      "task-duration",
+      "checkpoint-frequency",
+      "recovery-success",
+      "human-feedback"
+    ]).describe("Type of analytics query to run"),
+    since: tool3.schema.string().optional().describe("Time filter: '7d', '24h', '1h' (optional)"),
+    format: tool3.schema.enum(["json", "summary"]).optional().describe("Output format: 'json' (default) or 'summary' (context-efficient)")
+  },
+  async execute(args3) {
+    try {
+      const projectPath = process.cwd();
+      const db = await getSwarmMailLibSQL17(projectPath);
+      const filters = {
+        project_key: projectPath
+      };
+      if (args3.since) {
+        filters.since = parseSince2(args3.since);
+      }
+      let query;
+      switch (args3.query) {
+        case "failed-decompositions":
+          query = failedDecompositions2(filters);
+          break;
+        case "strategy-success-rates":
+          query = strategySuccessRates2(filters);
+          break;
+        case "lock-contention":
+          query = lockContention2(filters);
+          break;
+        case "agent-activity":
+          query = agentActivity2(filters);
+          break;
+        case "message-latency":
+          query = messageLatency2(filters);
+          break;
+        case "scope-violations":
+          query = scopeViolations2.buildQuery ? scopeViolations2.buildQuery(filters) : scopeViolations2;
+          break;
+        case "task-duration":
+          query = taskDuration2.buildQuery ? taskDuration2.buildQuery(filters) : taskDuration2;
+          break;
+        case "checkpoint-frequency":
+          query = checkpointFrequency2.buildQuery ? checkpointFrequency2.buildQuery(filters) : checkpointFrequency2;
+          break;
+        case "recovery-success":
+          query = recoverySuccess2.buildQuery ? recoverySuccess2.buildQuery(filters) : recoverySuccess2;
+          break;
+        case "human-feedback":
+          query = humanFeedback2.buildQuery ? humanFeedback2.buildQuery(filters) : humanFeedback2;
+          break;
+        default:
+          return JSON.stringify({
+            error: `Unknown query type: ${args3.query}`
+          });
+      }
+      const results = await executeQuery3(db, query);
+      if (args3.format === "summary") {
+        return formatSummary2(args3.query, results);
+      }
+      return JSON.stringify({
+        query: args3.query,
+        filters,
+        count: results.length,
+        results
+      }, null, 2);
+    } catch (error54) {
+      return JSON.stringify({
+        error: error54 instanceof Error ? error54.message : String(error54)
+      });
+    }
+  }
+});
+var swarm_query2 = tool3({
+  description: "Execute raw SQL queries against the swarm event store. Context-safe: results capped at 50 rows. Useful for custom analytics and debugging.",
+  args: {
+    sql: tool3.schema.string().describe("SQL query to execute (SELECT only for safety)"),
+    format: tool3.schema.enum(["json", "table"]).optional().describe("Output format: 'json' (default) or 'table' (visual)")
+  },
+  async execute(args3) {
+    try {
+      const projectPath = process.cwd();
+      const swarmMail = await getSwarmMailLibSQL17(projectPath);
+      const db = await swarmMail.getDatabase();
+      if (!args3.sql.trim().toLowerCase().startsWith("select")) {
+        return JSON.stringify({
+          error: "Only SELECT queries are allowed for safety"
+        });
+      }
+      const result = await db.query(args3.sql, []);
+      const rows = result.rows;
+      const cappedRows = capResults2(rows);
+      if (args3.format === "table") {
+        if (cappedRows.length === 0) {
+          return "No results";
+        }
+        const headers = Object.keys(cappedRows[0]);
+        const headerRow = headers.join(" | ");
+        const separator = headers.map(() => "---").join(" | ");
+        const dataRows = cappedRows.map((row) => headers.map((h) => row[h]).join(" | "));
+        return [headerRow, separator, ...dataRows].join(`
+`);
+      }
+      return JSON.stringify({
+        count: cappedRows.length,
+        total: rows.length,
+        capped: rows.length > 50,
+        results: cappedRows
+      }, null, 2);
+    } catch (error54) {
+      return JSON.stringify({
+        error: error54 instanceof Error ? error54.message : String(error54)
+      });
+    }
+  }
+});
+var swarm_diagnose2 = tool3({
+  description: "Auto-diagnose issues for a specific epic or task. Returns structured diagnosis with blockers, conflicts, slow tasks, errors, and timeline.",
+  args: {
+    epic_id: tool3.schema.string().optional().describe("Epic ID to diagnose"),
+    bead_id: tool3.schema.string().optional().describe("Task ID to diagnose"),
+    include: tool3.schema.array(tool3.schema.enum([
+      "blockers",
+      "conflicts",
+      "slow_tasks",
+      "errors",
+      "timeline"
+    ])).optional().describe("What to include in diagnosis (default: all)")
+  },
+  async execute(args3) {
+    try {
+      const projectPath = process.cwd();
+      const swarmMail = await getSwarmMailLibSQL17(projectPath);
+      const db = await swarmMail.getDatabase();
+      const diagnosis = [];
+      const include = args3.include || [
+        "blockers",
+        "conflicts",
+        "slow_tasks",
+        "errors",
+        "timeline"
+      ];
+      if (include.includes("blockers")) {
+        const blockerQuery = `
+					SELECT json_extract(data, '$.agent_name') as agent,
+					       json_extract(data, '$.bead_id') as bead_id,
+					       timestamp
+					FROM events
+					WHERE type = 'task_blocked'
+					${args3.epic_id ? "AND json_extract(data, '$.epic_id') = ?" : ""}
+					${args3.bead_id ? "AND json_extract(data, '$.bead_id') = ?" : ""}
+					ORDER BY timestamp DESC
+					LIMIT 10
+				`;
+        const params = [];
+        if (args3.epic_id)
+          params.push(args3.epic_id);
+        if (args3.bead_id)
+          params.push(args3.bead_id);
+        const blockers = await db.query(blockerQuery, params);
+        if (blockers.rows.length > 0) {
+          diagnosis.push({
+            type: "blockers",
+            message: `Found ${blockers.rows.length} blocked task(s)`,
+            severity: "high"
+          });
+        }
+      }
+      if (include.includes("errors")) {
+        const errorQuery = `
+					SELECT type, json_extract(data, '$.success') as success
+					FROM events
+					WHERE type = 'subtask_outcome'
+					AND json_extract(data, '$.success') = 0
+					${args3.epic_id ? "AND json_extract(data, '$.epic_id') = ?" : ""}
+					${args3.bead_id ? "AND json_extract(data, '$.bead_id') = ?" : ""}
+					LIMIT 10
+				`;
+        const params = [];
+        if (args3.epic_id)
+          params.push(args3.epic_id);
+        if (args3.bead_id)
+          params.push(args3.bead_id);
+        const errors4 = await db.query(errorQuery, params);
+        if (errors4.rows.length > 0) {
+          diagnosis.push({
+            type: "errors",
+            message: `Found ${errors4.rows.length} failed task(s)`,
+            severity: "high"
+          });
+        }
+      }
+      let timeline = [];
+      if (include.includes("timeline")) {
+        const timelineQuery = `
+					SELECT timestamp, type, json_extract(data, '$.agent_name') as agent
+					FROM events
+					${args3.epic_id ? "WHERE json_extract(data, '$.epic_id') = ?" : ""}
+					${args3.bead_id ? (args3.epic_id ? "AND" : "WHERE") + " json_extract(data, '$.bead_id') = ?" : ""}
+					ORDER BY timestamp DESC
+					LIMIT 20
+				`;
+        const params = [];
+        if (args3.epic_id)
+          params.push(args3.epic_id);
+        if (args3.bead_id)
+          params.push(args3.bead_id);
+        const events = await db.query(timelineQuery, params);
+        timeline = events.rows;
+      }
+      return JSON.stringify({
+        epic_id: args3.epic_id,
+        bead_id: args3.bead_id,
+        diagnosis,
+        timeline: include.includes("timeline") ? timeline : undefined
+      }, null, 2);
+    } catch (error54) {
+      return JSON.stringify({
+        error: error54 instanceof Error ? error54.message : String(error54)
+      });
+    }
+  }
+});
+var swarm_insights2 = tool3({
+  description: "Generate learning insights from swarm coordination metrics. Analyzes success rates, duration, conflicts, and retries to provide actionable recommendations.",
+  args: {
+    scope: tool3.schema.enum(["epic", "project", "recent"]).describe("Scope of analysis: 'epic', 'project', or 'recent'"),
+    epic_id: tool3.schema.string().optional().describe("Epic ID (required if scope='epic')"),
+    metrics: tool3.schema.array(tool3.schema.enum([
+      "success_rate",
+      "avg_duration",
+      "conflict_rate",
+      "retry_rate"
+    ])).describe("Metrics to analyze")
+  },
+  async execute(args3) {
+    try {
+      if (args3.scope === "epic" && !args3.epic_id) {
+        return JSON.stringify({
+          error: "epic_id is required when scope='epic'"
+        });
+      }
+      const projectPath = process.cwd();
+      const swarmMail = await getSwarmMailLibSQL17(projectPath);
+      const db = await swarmMail.getDatabase();
+      const insights = [];
+      if (args3.metrics.includes("success_rate")) {
+        const query = `
+					SELECT
+						SUM(CASE WHEN json_extract(data, '$.success') = 1 THEN 1 ELSE 0 END) as successes,
+						COUNT(*) as total
+					FROM events
+					WHERE type = 'subtask_outcome'
+					${args3.epic_id ? "AND json_extract(data, '$.epic_id') = ?" : ""}
+				`;
+        const result = await db.query(query, args3.epic_id ? [args3.epic_id] : []);
+        const row = result.rows[0];
+        if (row && row.total > 0) {
+          const rate = row.successes / row.total * 100;
+          insights.push({
+            metric: "success_rate",
+            value: `${rate.toFixed(1)}%`,
+            insight: rate < 50 ? "Low success rate - review decomposition strategy" : rate < 80 ? "Moderate success rate - monitor for patterns" : "Good success rate - maintain current approach"
+          });
+        }
+      }
+      if (args3.metrics.includes("avg_duration")) {
+        const query = `
+					SELECT AVG(CAST(json_extract(data, '$.duration_ms') AS REAL)) as avg_duration
+					FROM events
+					WHERE type = 'subtask_outcome'
+					AND json_extract(data, '$.success') = 1
+					AND json_extract(data, '$.duration_ms') IS NOT NULL
+					${args3.epic_id ? "AND json_extract(data, '$.epic_id') = ?" : ""}
+				`;
+        const result = await db.query(query, args3.epic_id ? [args3.epic_id] : []);
+        const row = result.rows[0];
+        if (row?.avg_duration) {
+          const avgMinutes = (row.avg_duration / 60000).toFixed(1);
+          insights.push({
+            metric: "avg_duration",
+            value: `${avgMinutes} min`,
+            insight: row.avg_duration > 600000 ? "Tasks taking >10min - consider smaller decomposition" : "Task duration is reasonable"
+          });
+        }
+      }
+      return JSON.stringify({
+        scope: args3.scope,
+        epic_id: args3.epic_id,
+        insights
+      }, null, 2);
+    } catch (error54) {
+      return JSON.stringify({
+        error: error54 instanceof Error ? error54.message : String(error54)
+      });
+    }
+  }
+});
+var observabilityTools = {
+  swarm_analytics: swarm_analytics2,
+  swarm_query: swarm_query2,
+  swarm_diagnose: swarm_diagnose2,
+  swarm_insights: swarm_insights2
+};
+
 // src/contributor-tools.ts
 init_dist2();
 init_zod3();
@@ -120732,13 +121369,13 @@ import { checkSwarmHealth as checkSwarmHealth4 } from "swarm-mail";
 
 // src/logger.ts
 var import_pino = __toESM(require_pino(), 1);
-import { mkdirSync as mkdirSync8, existsSync as existsSync16 } from "node:fs";
-import { join as join25 } from "node:path";
-import { homedir as homedir8 } from "node:os";
-var DEFAULT_LOG_DIR = join25(homedir8(), ".config", "swarm-tools", "logs");
+import { mkdirSync as mkdirSync10, existsSync as existsSync19 } from "node:fs";
+import { join as join27 } from "node:path";
+import { homedir as homedir9 } from "node:os";
+var DEFAULT_LOG_DIR = join27(homedir9(), ".config", "swarm-tools", "logs");
 function ensureLogDir(logDir) {
-  if (!existsSync16(logDir)) {
-    mkdirSync8(logDir, { recursive: true });
+  if (!existsSync19(logDir)) {
+    mkdirSync10(logDir, { recursive: true });
   }
 }
 var loggerCache = new Map;
@@ -120754,7 +121391,7 @@ function getLogger(logDir = DEFAULT_LOG_DIR) {
   let logger;
   if (process.env.SWARM_LOG_FILE === "1") {
     ensureLogDir(logDir);
-    const logPath = join25(logDir, "swarm.log");
+    const logPath = join27(logDir, "swarm.log");
     logger = import_pino.default(baseConfig, import_pino.default.destination({ dest: logPath, sync: false }));
   } else {
     logger = import_pino.default(baseConfig);
@@ -120911,16 +121548,16 @@ import {
   viewSessionLine,
   SessionIndexer as SessionIndexer2,
   createEvent as createEvent11,
-  getSwarmMailLibSQL as getSwarmMailLibSQL16
+  getSwarmMailLibSQL as getSwarmMailLibSQL18
 } from "swarm-mail";
-import * as os5 from "node:os";
-import * as path9 from "node:path";
+import * as os6 from "node:os";
+import * as path11 from "node:path";
 var AGENT_DIRECTORIES2 = [
-  path9.join(os5.homedir(), ".config", "swarm-tools", "sessions"),
-  path9.join(os5.homedir(), ".opencode"),
-  path9.join(os5.homedir(), "Cursor", "User", "History"),
-  path9.join(os5.homedir(), ".local", "share", "Claude"),
-  path9.join(os5.homedir(), ".aider")
+  path11.join(os6.homedir(), ".config", "swarm-tools", "sessions"),
+  path11.join(os6.homedir(), ".opencode"),
+  path11.join(os6.homedir(), "Cursor", "User", "History"),
+  path11.join(os6.homedir(), ".local", "share", "Claude"),
+  path11.join(os6.homedir(), ".aider")
 ];
 async function getSessionIndexer2() {
   const db = await getDb();
@@ -120933,7 +121570,7 @@ async function getSessionIndexer2() {
 async function emitEvent2(eventType, data) {
   try {
     const projectPath = process.cwd();
-    const swarmMail = await getSwarmMailLibSQL16(projectPath);
+    const swarmMail = await getSwarmMailLibSQL18(projectPath);
     const event = createEvent11(eventType, {
       project_key: projectPath,
       ...data
@@ -121157,9 +121794,9 @@ var allTools = {
 };
 
 // bin/swarm.ts
-var __dirname2 = dirname7(fileURLToPath3(import.meta.url));
-var pkgPath = join27(__dirname2, "..", "..", "package.json");
-var pkg = JSON.parse(readFileSync13(pkgPath, "utf-8"));
+var __dirname2 = dirname9(fileURLToPath3(import.meta.url));
+var pkgPath = join29(__dirname2, "..", "..", "package.json");
+var pkg = JSON.parse(readFileSync16(pkgPath, "utf-8"));
 var VERSION = pkg.version;
 var BEE = `
     \\ \` - ' /
@@ -121169,12 +121806,12 @@ var BEE = `
     (_|   |_)  bzzzz...
 `;
 var BANNER = `
- ███████╗██╗    ██╗ █████╗ ██████╗ ███╗   ███╗
- ██╔════╝██║    ██║██╔══██╗██╔══██╗████╗ ████║
- ███████╗██║ █╗ ██║███████║██████╔╝██╔████╔██║
- ╚════██║██║███╗██║██╔══██║██╔══██╗██║╚██╔╝██║
- ███████║╚███╔███╔╝██║  ██║██║  ██║██║ ╚═╝ ██║
- ╚══════╝ ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝     ╚═╝
+ \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557    \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557
+ \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551    \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551
+ \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551 \u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551
+ \u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551
+ \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2554\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551
+ \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D
 `;
 var TAGLINE = "Multi-agent coordination for OpenCode";
 var dim = (s) => `\x1B[2m${s}\x1B[0m`;
@@ -121186,29 +121823,29 @@ var red = (s) => `\x1B[31m${s}\x1B[0m`;
 var bold = (s) => `\x1B[1m${s}\x1B[0m`;
 var PACKAGE_NAME = "opencode-swarm-plugin";
 function writeFileWithStatus(path4, content, label) {
-  const exists4 = existsSync17(path4);
+  const exists4 = existsSync20(path4);
   if (exists4) {
-    const current = readFileSync13(path4, "utf-8");
+    const current = readFileSync16(path4, "utf-8");
     if (current === content) {
       p.log.message(dim(`  ${label}: ${path4} (unchanged)`));
       return "unchanged";
     }
   }
-  writeFileSync6(path4, content);
+  writeFileSync7(path4, content);
   const status = exists4 ? "updated" : "created";
   p.log.success(`${label}: ${path4} (${status})`);
   return status;
 }
 function mkdirWithStatus(path4) {
-  if (!existsSync17(path4)) {
-    mkdirSync9(path4, { recursive: true });
+  if (!existsSync20(path4)) {
+    mkdirSync11(path4, { recursive: true });
     p.log.message(dim(`  Created directory: ${path4}`));
     return true;
   }
   return false;
 }
 function rmWithStatus(path4, label) {
-  if (existsSync17(path4)) {
+  if (existsSync20(path4)) {
     rmSync(path4);
     p.log.message(dim(`  Removed ${label}: ${path4}`));
   }
@@ -121239,7 +121876,7 @@ function getSeasonalBee() {
           `Kicking off ${year} with coordinated chaos!`,
           `Happy ${year}! Time to orchestrate some magic.`
         ],
-        decorations: ["\uD83C\uDF89", "\uD83C\uDF8A", "✨"]
+        decorations: ["\uD83C\uDF89", "\uD83C\uDF8A", "\u2728"]
       };
     case "spooky":
       return {
@@ -121250,7 +121887,7 @@ function getSeasonalBee() {
           `Let's conjure up a swarm of worker bees!`,
           `Something wicked this way computes...`
         ],
-        decorations: ["\uD83C\uDF83", "\uD83D\uDC7B", "\uD83D\uDD77️", "\uD83E\uDD87"]
+        decorations: ["\uD83C\uDF83", "\uD83D\uDC7B", "\uD83D\uDD77\uFE0F", "\uD83E\uDD87"]
       };
     case "holiday":
       return {
@@ -121261,7 +121898,7 @@ function getSeasonalBee() {
           `Jingle bells, agents swell, tasks get done today!`,
           `The best gift? A well-coordinated swarm.`
         ],
-        decorations: ["\uD83C\uDF84", "\uD83C\uDF81", "❄️", "⭐"]
+        decorations: ["\uD83C\uDF84", "\uD83C\uDF81", "\u2744\uFE0F", "\u2B50"]
       };
     case "summer":
       return {
@@ -121271,7 +121908,7 @@ function getSeasonalBee() {
           `Hot code, cool agents. Let's go!`,
           `Beach day? Nah, build day!`
         ],
-        decorations: ["☀️", "\uD83C\uDF3B", "\uD83C\uDF34"]
+        decorations: ["\u2600\uFE0F", "\uD83C\uDF3B", "\uD83C\uDF34"]
       };
     default:
       return {
@@ -121377,15 +122014,24 @@ function compareVersions(a, b) {
 function showUpdateNotification(info) {
   if (info.updateAvailable) {
     console.log();
-    console.log(yellow("  ╭─────────────────────────────────────────────────────╮"));
-    console.log(yellow("  │") + "  Update available! " + dim(info.current) + " → " + green(info.latest) + "                " + yellow("│"));
-    console.log(yellow("  │") + "  Run: " + cyan("npm install -g " + PACKAGE_NAME + "@latest") + "  " + yellow("│"));
-    console.log(yellow("  │") + "  Or:  " + cyan("swarm update") + "                                " + yellow("│"));
-    console.log(yellow("  ╰─────────────────────────────────────────────────────╯"));
+    console.log(yellow("  \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E"));
+    console.log(yellow("  \u2502") + "  Update available! " + dim(info.current) + " \u2192 " + green(info.latest) + "                " + yellow("\u2502"));
+    console.log(yellow("  \u2502") + "  Run: " + cyan("npm install -g " + PACKAGE_NAME + "@latest") + "  " + yellow("\u2502"));
+    console.log(yellow("  \u2502") + "  Or:  " + cyan("swarm update") + "                                " + yellow("\u2502"));
+    console.log(yellow("  \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F"));
     console.log();
   }
 }
 var DEPENDENCIES = [
+  {
+    name: "Bun",
+    command: "bun",
+    checkArgs: ["--version"],
+    required: true,
+    install: "curl -fsSL https://bun.sh/install | bash",
+    installType: "manual",
+    description: "JavaScript runtime (required for CLI)"
+  },
   {
     name: "OpenCode",
     command: "opencode",
@@ -121424,33 +122070,47 @@ var DEPENDENCIES = [
   }
 ];
 async function checkCommand(cmd, args3) {
-  try {
-    const proc = Bun.spawn([cmd, ...args3], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const exitCode = await proc.exited;
-    if (exitCode === 0) {
-      const output = await new Response(proc.stdout).text();
-      const versionMatch = output.match(/v?(\d+\.\d+\.\d+)/);
-      return { available: true, version: versionMatch?.[1] };
+  return new Promise((resolve3) => {
+    try {
+      const proc = spawn(cmd, args3, {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      proc.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.on("error", () => {
+        resolve3({ available: false });
+      });
+      proc.on("close", (exitCode) => {
+        if (exitCode === 0) {
+          const versionMatch = stdout.match(/v?(\d+\.\d+\.\d+)/);
+          resolve3({ available: true, version: versionMatch?.[1] });
+        } else {
+          resolve3({ available: false });
+        }
+      });
+    } catch {
+      resolve3({ available: false });
     }
-    return { available: false };
-  } catch {
-    return { available: false };
-  }
+  });
 }
 async function runInstall(command) {
-  try {
-    const proc = Bun.spawn(["bash", "-c", command], {
-      stdout: "inherit",
-      stderr: "inherit"
-    });
-    const exitCode = await proc.exited;
-    return exitCode === 0;
-  } catch {
-    return false;
-  }
+  return new Promise((resolve3) => {
+    try {
+      const proc = spawn("bash", ["-c", command], {
+        stdio: "inherit"
+      });
+      proc.on("error", () => {
+        resolve3(false);
+      });
+      proc.on("close", (exitCode) => {
+        resolve3(exitCode === 0);
+      });
+    } catch {
+      resolve3(false);
+    }
+  });
 }
 async function checkAllDependencies() {
   const results = [];
@@ -121462,7 +122122,7 @@ async function checkAllDependencies() {
 }
 var BUNDLED_SKILL_MARKER_FILENAME = ".swarm-bundled-skill.json";
 function listDirectoryNames(dirPath) {
-  if (!existsSync17(dirPath))
+  if (!existsSync20(dirPath))
     return [];
   try {
     return readdirSync2(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
@@ -121471,11 +122131,11 @@ function listDirectoryNames(dirPath) {
   }
 }
 function copyDirRecursiveSync(srcDir, destDir) {
-  mkdirSync9(destDir, { recursive: true });
+  mkdirSync11(destDir, { recursive: true });
   const entries2 = readdirSync2(srcDir, { withFileTypes: true });
   for (const entry of entries2) {
-    const srcPath = join27(srcDir, entry.name);
-    const destPath = join27(destDir, entry.name);
+    const srcPath = join29(srcDir, entry.name);
+    const destPath = join29(destDir, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursiveSync(srcPath, destPath);
       continue;
@@ -121489,8 +122149,8 @@ function copyDirRecursiveSync(srcDir, destDir) {
   }
 }
 function writeBundledSkillMarker(skillDir, info) {
-  const markerPath = join27(skillDir, BUNDLED_SKILL_MARKER_FILENAME);
-  writeFileSync6(markerPath, JSON.stringify({
+  const markerPath = join29(skillDir, BUNDLED_SKILL_MARKER_FILENAME);
+  writeFileSync7(markerPath, JSON.stringify({
     managed_by: "opencode-swarm-plugin",
     version: info.version,
     synced_at: new Date().toISOString()
@@ -121506,16 +122166,16 @@ function syncBundledSkillsToGlobal({
   const updated = [];
   const skipped = [];
   for (const name of bundledSkills) {
-    const srcSkillDir = join27(bundledSkillsPath, name);
-    const destSkillDir = join27(globalSkillsPath, name);
-    const markerPath = join27(destSkillDir, BUNDLED_SKILL_MARKER_FILENAME);
-    if (!existsSync17(destSkillDir)) {
+    const srcSkillDir = join29(bundledSkillsPath, name);
+    const destSkillDir = join29(globalSkillsPath, name);
+    const markerPath = join29(destSkillDir, BUNDLED_SKILL_MARKER_FILENAME);
+    if (!existsSync20(destSkillDir)) {
       copyDirRecursiveSync(srcSkillDir, destSkillDir);
       writeBundledSkillMarker(destSkillDir, { version: version4 });
       installed.push(name);
       continue;
     }
-    if (existsSync17(markerPath)) {
+    if (existsSync20(markerPath)) {
       rmSync(destSkillDir, { recursive: true, force: true });
       copyDirRecursiveSync(srcSkillDir, destSkillDir);
       writeBundledSkillMarker(destSkillDir, { version: version4 });
@@ -121534,10 +122194,10 @@ function detectNewline(content) {
 }
 function backupFileWithTimestamp(filePath) {
   try {
-    const dir = dirname7(filePath);
+    const dir = dirname9(filePath);
     const base = basename3(filePath);
     const timestamp = new Date().toISOString().replace(/[:.]/g, "").replace(/Z$/, "Z");
-    const backupPath = join27(dir, `${base}.swarm-backup-${timestamp}`);
+    const backupPath = join29(dir, `${base}.swarm-backup-${timestamp}`);
     copyFileSync(filePath, backupPath);
     return backupPath;
   } catch {
@@ -121567,64 +122227,155 @@ function buildAgentsSkillsSection(bundledSkillsCsv, newline) {
     `**Bundled Skills:** ${bundledSkillsCsv}`
   ].join(newline);
 }
-function buildAgentsCassSection(newline) {
+function buildAgentsHivemindSection(newline) {
   return [
-    "## CASS - Cross-Agent Session Search",
+    "## Hivemind - Unified Memory System",
+    "",
+    "The hive remembers everything. Learnings, sessions, patterns\u2014all searchable.",
     "",
-    "Search across ALL your AI coding agent histories before solving problems from scratch.",
+    "**Unified storage:** Manual learnings and AI agent session histories stored in the same database, searchable together. Powered by libSQL vectors + Ollama embeddings.",
+    "",
+    "**Indexed agents:** Claude Code, Codex, Cursor, Gemini, Aider, ChatGPT, Cline, OpenCode, Amp, Pi-Agent",
     "",
     "### When to Use",
     "",
-    "- **BEFORE implementing anything**: check if any agent solved it before",
-    '- **Debugging**: "what did I try last time this error happened?"',
-    '- **Learning patterns**: "how did Cursor handle this API?"',
+    "- **BEFORE implementing** - check if you or any agent solved it before",
+    "- **After solving hard problems** - store learnings for future sessions",
+    "- **Debugging** - search past sessions for similar errors",
+    "- **Architecture decisions** - record reasoning, alternatives, tradeoffs",
+    "- **Project-specific patterns** - capture domain rules and gotchas",
+    "",
+    "### Tools",
+    "",
+    "| Tool | Purpose |",
+    "|------|---------|",
+    "| `hivemind_store` | Store a memory (learnings, decisions, patterns) |",
+    "| `hivemind_find` | Search all memories (learnings + sessions, semantic + FTS fallback) |",
+    "| `hivemind_get` | Get specific memory by ID |",
+    "| `hivemind_remove` | Delete outdated/incorrect memory |",
+    "| `hivemind_validate` | Confirm memory still accurate (resets 90-day decay timer) |",
+    "| `hivemind_stats` | Memory statistics and health check |",
+    "| `hivemind_index` | Index AI session directories |",
+    "| `hivemind_sync` | Sync to .hive/memories.jsonl (git-backed, team-shared) |",
     "",
     "### Usage",
     "",
+    "**Store a learning** (include WHY, not just WHAT):",
+    "",
+    "```typescript",
+    "hivemind_store({",
+    '  information: "OAuth refresh tokens need 5min buffer before expiry to avoid race conditions. Without buffer, token refresh can fail mid-request if expiry happens between check and use.",',
+    '  tags: "auth,oauth,tokens,race-conditions"',
+    "})",
+    "```",
+    "",
+    "**Search all memories** (learnings + sessions):",
+    "",
+    "```typescript",
+    "// Search everything",
+    'hivemind_find({ query: "token refresh", limit: 5 })',
+    "",
+    "// Search only learnings (manual entries)",
+    'hivemind_find({ query: "authentication", collection: "default" })',
+    "",
+    "// Search only Claude sessions",
+    'hivemind_find({ query: "Next.js caching", collection: "claude" })',
+    "",
+    "// Search only Cursor sessions",
+    'hivemind_find({ query: "API design", collection: "cursor" })',
+    "```",
+    "",
+    "**Get specific memory**:",
+    "",
+    "```typescript",
+    'hivemind_get({ id: "mem_xyz123" })',
+    "```",
+    "",
+    "**Delete outdated memory**:",
+    "",
+    "```typescript",
+    'hivemind_remove({ id: "mem_old456" })',
+    "```",
+    "",
+    "**Validate memory is still accurate** (resets decay):",
+    "",
+    "```typescript",
+    "// Confirmed this memory is still relevant",
+    'hivemind_validate({ id: "mem_xyz123" })',
+    "```",
+    "",
+    "**Index new sessions**:",
+    "",
+    "```typescript",
+    "// Automatically indexes ~/.config/opencode/sessions, ~/.cursor-tutor, etc.",
+    "hivemind_index()",
+    "```",
+    "",
+    "**Sync to git**:",
+    "",
+    "```typescript",
+    "// Writes learnings to .hive/memories.jsonl for git sync",
+    "hivemind_sync()",
+    "```",
+    "",
+    "**Check stats**:",
+    "",
+    "```typescript",
+    "hivemind_stats()",
+    "```",
+    "",
+    "### Usage Pattern",
+    "",
     "```bash",
-    "# Search all agents",
-    'cass_search(query="authentication token refresh", limit=5)',
+    "# 1. Before starting work - query for relevant learnings",
+    'hivemind_find({ query: "<task keywords>", limit: 5 })',
     "",
-    "# Filter by agent/time",
-    'cass_search(query="useEffect cleanup", agent="claude", days=7)',
+    "# 2. Do the work...",
     "",
-    "# View specific result",
-    'cass_view(path="/path/from/search", line=42)',
+    "# 3. After solving hard problem - store learning",
+    "hivemind_store({",
+    '  information: "<what you learned, WHY it matters>",',
+    '  tags: "<relevant,tags>"',
+    "})",
     "",
-    "# Expand context around match",
-    'cass_expand(path="/path", line=42, context=10)',
+    "# 4. Validate memories when you confirm they're still accurate",
+    'hivemind_validate({ id: "<memory-id>" })',
     "```",
     "",
-    "**Pro tip:** Query CASS at the START of complex tasks. Past solutions save time."
-  ].join(newline);
-}
-function buildAgentsSemanticMemorySection(newline) {
-  return [
-    "## Semantic Memory - Persistent Learning",
+    "### Integration with Workflow",
     "",
-    "Store and retrieve learnings across sessions. Memories persist and are searchable.",
+    "**At task start** (query BEFORE implementing):",
     "",
-    "### When to Use",
+    "```bash",
+    "# Check if you or any agent solved similar problems",
+    'hivemind_find({ query: "OAuth token refresh buffer", limit: 5 })',
+    "```",
     "",
-    "- After solving a tricky problem - store the solution",
-    "- After making architectural decisions - store the reasoning",
-    "- Before starting work - search for relevant past learnings",
-    "- When you discover project-specific patterns",
+    "**During debugging** (search past sessions):",
     "",
-    "### Usage",
+    "```bash",
+    "# Find similar errors from past sessions",
+    'hivemind_find({ query: "cannot read property of undefined", collection: "claude" })',
+    "```",
+    "",
+    "**After solving problems** (store learnings):",
     "",
     "```bash",
-    "# Store a learning",
-    'semantic-memory_store(information="OAuth refresh tokens need 5min buffer before expiry", metadata="auth, tokens")',
+    '# Store root cause + solution, not just "fixed it"',
+    "hivemind_store({",
+    '  information: "Next.js searchParams causes dynamic rendering. Workaround: destructure in parent, pass as props to cached child.",',
+    '  tags: "nextjs,cache-components,dynamic-rendering,searchparams"',
+    "})",
+    "```",
     "",
-    "# Search for relevant memories",
-    'semantic-memory_find(query="token refresh", limit=5)',
+    "**Learning from other agents**:",
     "",
-    "# Validate a memory is still accurate (resets decay timer)",
-    'semantic-memory_validate(id="mem_123")',
+    "```bash",
+    "# See how Cursor handled similar feature",
+    'hivemind_find({ query: "implement authentication", collection: "cursor" })',
     "```",
     "",
-    "**Pro tip:** Store the WHY, not just the WHAT. Future you needs context."
+    "**Pro tip:** Query Hivemind at the START of complex tasks. Past solutions (yours or other agents') save time and prevent reinventing wheels."
   ].join(newline);
 }
 function buildAgentsSwarmCoordinatorSection(newline) {
@@ -121636,35 +122387,35 @@ function buildAgentsSwarmCoordinatorSection(newline) {
     "### Monitor Loop",
     "",
     "```",
-    "┌─────────────────────────────────────────────────────────────┐",
-    "│                 COORDINATOR MONITOR LOOP                    │",
-    "├─────────────────────────────────────────────────────────────┤",
-    "│                                                             │",
-    "│  1. CHECK INBOX                                             │",
-    "│     swarmmail_inbox()                                       │",
-    "│     swarmmail_read_message(message_id=N)                    │",
-    "│                                                             │",
-    "│  2. CHECK STATUS                                            │",
-    "│     swarm_status(epic_id, project_key)                      │",
-    "│                                                             │",
-    "│  3. REVIEW COMPLETED WORK                                   │",
-    "│     swarm_review(project_key, epic_id, task_id, files)      │",
-    "│     → Generates review prompt with epic context + diff      │",
-    "│                                                             │",
-    "│  4. SEND FEEDBACK                                           │",
-    "│     swarm_review_feedback(                                  │",
-    "│       project_key, task_id, worker_id,                      │",
-    '│       status="approved|needs_changes",                      │',
-    '│       issues="[{file, line, issue, suggestion}]"            │',
-    "│     )                                                       │",
-    "│                                                             │",
-    "│  5. INTERVENE IF NEEDED                                     │",
-    "│     - Blocked >5min → unblock or reassign                   │",
-    "│     - File conflicts → mediate                              │",
-    "│     - Scope creep → approve or reject                       │",
-    "│     - 3 review failures → escalate to human                 │",
-    "│                                                             │",
-    "└─────────────────────────────────────────────────────────────┘",
+    "\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510",
+    "\u2502                 COORDINATOR MONITOR LOOP                    \u2502",
+    "\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524",
+    "\u2502                                                             \u2502",
+    "\u2502  1. CHECK INBOX                                             \u2502",
+    "\u2502     swarmmail_inbox()                                       \u2502",
+    "\u2502     swarmmail_read_message(message_id=N)                    \u2502",
+    "\u2502                                                             \u2502",
+    "\u2502  2. CHECK STATUS                                            \u2502",
+    "\u2502     swarm_status(epic_id, project_key)                      \u2502",
+    "\u2502                                                             \u2502",
+    "\u2502  3. REVIEW COMPLETED WORK                                   \u2502",
+    "\u2502     swarm_review(project_key, epic_id, task_id, files)      \u2502",
+    "\u2502     \u2192 Generates review prompt with epic context + diff      \u2502",
+    "\u2502                                                             \u2502",
+    "\u2502  4. SEND FEEDBACK                                           \u2502",
+    "\u2502     swarm_review_feedback(                                  \u2502",
+    "\u2502       project_key, task_id, worker_id,                      \u2502",
+    '\u2502       status="approved|needs_changes",                      \u2502',
+    '\u2502       issues="[{file, line, issue, suggestion}]"            \u2502',
+    "\u2502     )                                                       \u2502",
+    "\u2502                                                             \u2502",
+    "\u2502  5. INTERVENE IF NEEDED                                     \u2502",
+    "\u2502     - Blocked >5min \u2192 unblock or reassign                   \u2502",
+    "\u2502     - File conflicts \u2192 mediate                              \u2502",
+    "\u2502     - Scope creep \u2192 approve or reject                       \u2502",
+    "\u2502     - 3 review failures \u2192 escalate to human                 \u2502",
+    "\u2502                                                             \u2502",
+    "\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518",
     "```",
     "",
     "### Review Tools",
@@ -121748,27 +122499,59 @@ function updateAgentsMdContent({
   if (updated !== beforeBundled) {
     changes.push("Updated bundled skills list");
   }
+  const hasOldCassTools = /cass_search\(|cass_view\(|cass_expand\(/i.test(updated);
+  const hasOldSemanticTools = /semantic-memory_store\(|semantic-memory_find\(/i.test(updated);
+  const hasHivemindTools = /hivemind_store\(|hivemind_find\(/i.test(updated);
+  if ((hasOldCassTools || hasOldSemanticTools) && !hasHivemindTools) {
+    const beforeMigration = updated;
+    updated = updated.replace(/semantic-memory_store\(/g, "hivemind_store(");
+    updated = updated.replace(/semantic-memory_find\(/g, "hivemind_find(");
+    updated = updated.replace(/semantic-memory_get\(/g, "hivemind_get(");
+    updated = updated.replace(/semantic-memory_remove\(/g, "hivemind_remove(");
+    updated = updated.replace(/semantic-memory_validate\(/g, "hivemind_validate(");
+    updated = updated.replace(/semantic-memory_list\(/g, "hivemind_find(");
+    updated = updated.replace(/semantic-memory_stats\(/g, "hivemind_stats(");
+    updated = updated.replace(/cass_search\(/g, "hivemind_find(");
+    updated = updated.replace(/cass_view\(/g, "hivemind_get(");
+    updated = updated.replace(/cass_expand\(/g, "hivemind_get(");
+    updated = updated.replace(/cass_health\(/g, "hivemind_stats(");
+    updated = updated.replace(/cass_index\(/g, "hivemind_index(");
+    updated = updated.replace(/cass_stats\(/g, "hivemind_stats(");
+    updated = updated.replace(/\| `semantic-memory_store` \|/g, "| `hivemind_store` |");
+    updated = updated.replace(/\| `semantic-memory_find` \|/g, "| `hivemind_find` |");
+    updated = updated.replace(/\| `semantic-memory_get` \|/g, "| `hivemind_get` |");
+    updated = updated.replace(/\| `semantic-memory_remove` \|/g, "| `hivemind_remove` |");
+    updated = updated.replace(/\| `semantic-memory_validate` \|/g, "| `hivemind_validate` |");
+    updated = updated.replace(/\| `semantic-memory_list` \|/g, "| `hivemind_find` |");
+    updated = updated.replace(/\| `semantic-memory_stats` \|/g, "| `hivemind_stats` |");
+    updated = updated.replace(/\| `semantic-memory_migrate` \|/g, "| `hivemind_stats` |");
+    updated = updated.replace(/\| `semantic-memory_check` \|/g, "| `hivemind_stats` |");
+    updated = updated.replace(/\| `cass_search` \|/g, "| `hivemind_find` |");
+    updated = updated.replace(/\| `cass_view` \|/g, "| `hivemind_get` |");
+    updated = updated.replace(/\| `cass_expand` \|/g, "| `hivemind_get` |");
+    updated = updated.replace(/\| `cass_health` \|/g, "| `hivemind_stats` |");
+    updated = updated.replace(/\| `cass_index` \|/g, "| `hivemind_index` |");
+    updated = updated.replace(/\| `cass_stats` \|/g, "| `hivemind_stats` |");
+    if (updated !== beforeMigration) {
+      changes.push("Migrated cass_*/semantic-memory_* to hivemind_* (ADR-011)");
+    }
+  }
   const toolPrefsResult = updateAgentsToolPreferencesBlock(updated, newline);
   if (toolPrefsResult.changed) {
     updated = toolPrefsResult.content;
     changes.push("Updated tool_preferences tool list");
   }
   const hasSkillsSection = /^#{1,6}\s+Skills\b/im.test(updated) || /skills_list\(\)/.test(updated);
-  const hasCassSection = /^#{1,6}\s+.*CASS\b/im.test(updated) || /cass_search\(/.test(updated);
-  const hasSemanticMemorySection = /^#{1,6}\s+Semantic Memory\b/im.test(updated) || /semantic-memory_store\(/.test(updated);
+  const hasHivemindSection = /^#{1,6}\s+Hivemind\b/im.test(updated) || /hivemind_store\(/.test(updated);
   const hasSwarmCoordinatorSection = /^#{1,6}\s+Swarm Coordinator\b/im.test(updated) || /swarm_review\(/.test(updated) || /COORDINATOR MONITOR LOOP/i.test(updated);
   const sectionsToAppend = [];
   if (!hasSkillsSection) {
     sectionsToAppend.push(buildAgentsSkillsSection(bundledSkillsCsv, newline));
     changes.push("Added Skills section");
   }
-  if (!hasCassSection) {
-    sectionsToAppend.push(buildAgentsCassSection(newline));
-    changes.push("Added CASS section");
-  }
-  if (!hasSemanticMemorySection) {
-    sectionsToAppend.push(buildAgentsSemanticMemorySection(newline));
-    changes.push("Added Semantic Memory section");
+  if (!hasHivemindSection) {
+    sectionsToAppend.push(buildAgentsHivemindSection(newline));
+    changes.push("Added Hivemind section (unified memory)");
   }
   if (!hasSwarmCoordinatorSection) {
     sectionsToAppend.push(buildAgentsSwarmCoordinatorSection(newline));
@@ -121788,7 +122571,7 @@ function updateAgentsMdFile({
   agentsPath,
   bundledSkillsCsv
 }) {
-  const original = readFileSync13(agentsPath, "utf-8");
+  const original = readFileSync16(agentsPath, "utf-8");
   const { updated, changed, changes } = updateAgentsMdContent({
     content: original,
     bundledSkillsCsv
@@ -121797,13 +122580,13 @@ function updateAgentsMdFile({
     return { changed: false, changes: ["No changes needed"] };
   }
   const backupPath = backupFileWithTimestamp(agentsPath) || undefined;
-  writeFileSync6(agentsPath, updated, "utf-8");
+  writeFileSync7(agentsPath, updated, "utf-8");
   return { changed: true, backupPath, changes };
 }
 function getPluginWrapper() {
-  const templatePath = join27(__dirname2, "..", "examples", "plugin-wrapper-template.ts");
+  const templatePath = join29(__dirname2, "..", "examples", "plugin-wrapper-template.ts");
   try {
-    return readFileSync13(templatePath, "utf-8");
+    return readFileSync16(templatePath, "utf-8");
   } catch (error54) {
     console.warn(`[swarm] Could not read plugin template from ${templatePath}, using minimal wrapper`);
     return `// Minimal fallback - install opencode-swarm-plugin globally for full functionality
@@ -122124,10 +122907,10 @@ bash("ollama --version", description="Check Ollama availability")
 
 **NEVER dump raw documentation.** Always summarize.
 
-| ❌ Bad (Context Bomb) | ✅ Good (Condensed) |
+| \u274C Bad (Context Bomb) | \u2705 Good (Condensed) |
 |---------------------|-------------------|
 | Paste entire API reference | "Library uses hooks API. Key hooks: useQuery, useMutation. Breaking change in v2: callbacks removed." |
-| Copy full changelog | "v2.0 breaking changes: renamed auth() → authenticate(), dropped IE11 support" |
+| Copy full changelog | "v2.0 breaking changes: renamed auth() \u2192 authenticate(), dropped IE11 support" |
 | Include all examples | "Common pattern: async/await with error boundaries (stored full example in semantic-memory)" |
 
 **Storage Strategy:**
@@ -122152,7 +122935,7 @@ bash("ollama --version", description="Check Ollama availability")
 
 **"Research Next.js 16 caching APIs"**
 
-1. Read package.json → extract Next.js version
+1. Read package.json \u2192 extract Next.js version
 2. Use context7 or fetch to get Next.js 16 cache docs
 3. Store findings: unstable_cache, revalidatePath, cache patterns
 4. Broadcast: "Next.js 16 uses native fetch caching + unstable_cache for functions"
@@ -122185,12 +122968,28 @@ function getFixCommand(dep) {
       return dep.installType !== "manual" ? dep.install : null;
   }
 }
-async function doctor() {
+async function doctor(debug = false) {
   p.intro("swarm doctor v" + VERSION);
+  if (debug) {
+    p.log.step("Debug info:");
+    p.log.message(dim(`  Runtime: ${typeof Bun !== "undefined" ? "Bun" : "Node.js"}`));
+    p.log.message(dim(`  Node version: ${process.version}`));
+    p.log.message(dim(`  Platform: ${process.platform}`));
+    p.log.message(dim(`  Arch: ${process.arch}`));
+    p.log.message(dim(`  CWD: ${process.cwd()}`));
+    p.log.message(dim(`  PATH entries: ${(process.env.PATH || "").split(":").length}`));
+  }
   const s = p.spinner();
   s.start("Checking dependencies...");
   const results = await checkAllDependencies();
   s.stop("Dependencies checked");
+  if (debug) {
+    p.log.step("Dependency check details:");
+    for (const { dep, available, version: version4 } of results) {
+      const status = available ? green("\u2713") : red("\u2717");
+      p.log.message(dim(`  ${status} ${dep.command} ${dep.checkArgs.join(" ")} \u2192 ${available ? `v${version4 || "unknown"}` : "not found"}`));
+    }
+  }
   const required4 = results.filter((r) => r.dep.required);
   const optional4 = results.filter((r) => !r.dep.required);
   p.log.step("Required dependencies:");
@@ -122201,7 +123000,7 @@ async function doctor() {
       p.log.error(dep.name + " - not found");
       const fixCmd = getFixCommand(dep);
       if (fixCmd) {
-        p.log.message(dim("   └─ Fix: " + fixCmd));
+        p.log.message(dim("   \u2514\u2500 Fix: " + fixCmd));
       }
     }
   }
@@ -122213,17 +123012,17 @@ async function doctor() {
       p.log.warn(dep.name + " - not found (" + dep.description + ")");
       const fixCmd = getFixCommand(dep);
       if (fixCmd) {
-        p.log.message(dim("   └─ Fix: " + fixCmd));
+        p.log.message(dim("   \u2514\u2500 Fix: " + fixCmd));
       }
     }
   }
   const requiredMissing = required4.filter((r) => !r.available);
   const optionalMissing = optional4.filter((r) => !r.available);
   p.log.step("Skills:");
-  const configDir = join27(homedir10(), ".config", "opencode");
-  const globalSkillsPath = join27(configDir, "skills");
-  const bundledSkillsPath = join27(__dirname2, "..", "global-skills");
-  if (existsSync17(globalSkillsPath)) {
+  const configDir = join29(homedir11(), ".config", "opencode");
+  const globalSkillsPath = join29(configDir, "skills");
+  const bundledSkillsPath = join29(__dirname2, "..", "global-skills");
+  if (existsSync20(globalSkillsPath)) {
     try {
       const { readdirSync: readdirSync3 } = __require("fs");
       const skills = readdirSync3(globalSkillsPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
@@ -122238,7 +123037,7 @@ async function doctor() {
   } else {
     p.log.warn("No global skills directory (run 'swarm setup' to create)");
   }
-  if (existsSync17(bundledSkillsPath)) {
+  if (existsSync20(bundledSkillsPath)) {
     try {
       const { readdirSync: readdirSync3 } = __require("fs");
       const bundled = readdirSync3(bundledSkillsPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
@@ -122249,7 +123048,7 @@ async function doctor() {
   }
   const projectSkillsDirs = [".opencode/skill", ".claude/skills", "skill"];
   for (const dir of projectSkillsDirs) {
-    if (existsSync17(dir)) {
+    if (existsSync20(dir)) {
       try {
         const { readdirSync: readdirSync3 } = __require("fs");
         const skills = readdirSync3(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
@@ -122279,11 +123078,26 @@ async function setup(forceReinstall = false, nonInteractive = false) {
   console.log(magenta("  " + getRandomMessage()));
   console.log();
   p.intro("opencode-swarm-plugin v" + VERSION);
+  const bunCheck = await checkCommand("bun", ["--version"]);
+  if (!bunCheck.available) {
+    p.log.error("Bun is required but not installed!");
+    console.log();
+    console.log(dim("  The swarm CLI requires Bun runtime for Bun-specific APIs."));
+    console.log();
+    console.log("  Install Bun:");
+    console.log(cyan("    curl -fsSL https://bun.sh/install | bash"));
+    console.log();
+    console.log(dim("  Or via Homebrew:"));
+    console.log(cyan("    brew install oven-sh/bun/bun"));
+    console.log();
+    process.exit(1);
+  }
+  p.log.success(`Bun v${bunCheck.version} detected`);
   const cwd = process.cwd();
   const tempDirName = getLibSQLProjectTempDirName(cwd);
-  const tempDir = join27(tmpdir3(), tempDirName);
-  const pglitePath = join27(tempDir, "streams");
-  const libsqlPath = join27(tempDir, "streams.db");
+  const tempDir = join29(tmpdir3(), tempDirName);
+  const pglitePath = join29(tempDir, "streams");
+  const libsqlPath = join29(tempDir, "streams.db");
   if (pgliteExists(pglitePath)) {
     const migrateSpinner = p.spinner();
     migrateSpinner.start("Migrating...");
@@ -122310,19 +123124,19 @@ async function setup(forceReinstall = false, nonInteractive = false) {
   }
   let isReinstall = false;
   p.log.step("Checking existing configuration...");
-  const configDir = join27(homedir10(), ".config", "opencode");
-  const pluginDir = join27(configDir, "plugin");
-  const commandDir = join27(configDir, "command");
-  const agentDir = join27(configDir, "agent");
-  const pluginPath = join27(pluginDir, "swarm.ts");
-  const commandPath = join27(commandDir, "swarm.md");
-  const plannerAgentPath = join27(agentDir, "swarm-planner.md");
-  const workerAgentPath = join27(agentDir, "swarm-worker.md");
-  const researcherAgentPath = join27(agentDir, "swarm-researcher.md");
-  const swarmAgentDir = join27(agentDir, "swarm");
-  const legacyPlannerPath = join27(swarmAgentDir, "planner.md");
-  const legacyWorkerPath = join27(swarmAgentDir, "worker.md");
-  const legacyResearcherPath = join27(swarmAgentDir, "researcher.md");
+  const configDir = join29(homedir11(), ".config", "opencode");
+  const pluginDir = join29(configDir, "plugin");
+  const commandDir = join29(configDir, "command");
+  const agentDir = join29(configDir, "agent");
+  const pluginPath = join29(pluginDir, "swarm.ts");
+  const commandPath = join29(commandDir, "swarm.md");
+  const plannerAgentPath = join29(agentDir, "swarm-planner.md");
+  const workerAgentPath = join29(agentDir, "swarm-worker.md");
+  const researcherAgentPath = join29(agentDir, "swarm-researcher.md");
+  const swarmAgentDir = join29(agentDir, "swarm");
+  const legacyPlannerPath = join29(swarmAgentDir, "planner.md");
+  const legacyWorkerPath = join29(swarmAgentDir, "worker.md");
+  const legacyResearcherPath = join29(swarmAgentDir, "researcher.md");
   const existingFiles = [
     pluginPath,
     commandPath,
@@ -122332,7 +123146,7 @@ async function setup(forceReinstall = false, nonInteractive = false) {
     legacyPlannerPath,
     legacyWorkerPath,
     legacyResearcherPath
-  ].filter((f) => existsSync17(f));
+  ].filter((f) => existsSync20(f));
   if (existingFiles.length > 0 && !forceReinstall) {
     p.log.success("Swarm is already configured!");
     p.log.message(dim("  Found " + existingFiles.length + "/5 config files"));
@@ -122379,20 +123193,20 @@ async function setup(forceReinstall = false, nonInteractive = false) {
         p.cancel("Setup cancelled");
         process.exit(0);
       }
-      const plannerPaths = [plannerAgentPath, legacyPlannerPath].filter(existsSync17);
-      const workerPaths = [workerAgentPath, legacyWorkerPath].filter(existsSync17);
+      const plannerPaths = [plannerAgentPath, legacyPlannerPath].filter(existsSync20);
+      const workerPaths = [workerAgentPath, legacyWorkerPath].filter(existsSync20);
       for (const path4 of plannerPaths) {
-        const content = readFileSync13(path4, "utf-8");
+        const content = readFileSync16(path4, "utf-8");
         const updated = content.replace(/^model: .+$/m, `model: ${coordinatorModel2}`);
-        writeFileSync6(path4, updated);
+        writeFileSync7(path4, updated);
       }
       if (plannerPaths.length > 0) {
         p.log.success("Planner: " + coordinatorModel2);
       }
       for (const path4 of workerPaths) {
-        const content = readFileSync13(path4, "utf-8");
+        const content = readFileSync16(path4, "utf-8");
         const updated = content.replace(/^model: .+$/m, `model: ${workerModel2}`);
-        writeFileSync6(path4, updated);
+        writeFileSync7(path4, updated);
       }
       if (workerPaths.length > 0) {
         p.log.success("Worker: " + workerModel2);
@@ -122525,7 +123339,7 @@ async function setup(forceReinstall = false, nonInteractive = false) {
       try {
         const result = await migrateBeadsToHive(cwd);
         if (result.migrated) {
-          migrateSpinner.stop("Renamed .beads/ → .hive/");
+          migrateSpinner.stop("Renamed .beads/ \u2192 .hive/");
           p.log.success("Directory migration complete");
           migrateSpinner.start("Merging historic cells...");
           const mergeResult = await mergeHistoricBeads(cwd);
@@ -122556,10 +123370,10 @@ async function setup(forceReinstall = false, nonInteractive = false) {
     p.log.message(dim("  No legacy .beads directory found"));
   }
   p.log.step("Checking for legacy MCP servers...");
-  const opencodeConfigPath = join27(configDir, "config.json");
-  if (existsSync17(opencodeConfigPath)) {
+  const opencodeConfigPath = join29(configDir, "config.json");
+  if (existsSync20(opencodeConfigPath)) {
     try {
-      const opencodeConfig = JSON.parse(readFileSync13(opencodeConfigPath, "utf-8"));
+      const opencodeConfig = JSON.parse(readFileSync16(opencodeConfigPath, "utf-8"));
       if (opencodeConfig.mcpServers?.["semantic-memory"]) {
         p.log.warn("Found legacy semantic-memory MCP server");
         p.log.message(dim("  Semantic memory is now embedded in the plugin"));
@@ -122573,7 +123387,7 @@ async function setup(forceReinstall = false, nonInteractive = false) {
         }
         if (removeMcp) {
           delete opencodeConfig.mcpServers["semantic-memory"];
-          writeFileSync6(opencodeConfigPath, JSON.stringify(opencodeConfig, null, 2));
+          writeFileSync7(opencodeConfigPath, JSON.stringify(opencodeConfig, null, 2));
           p.log.success("Removed semantic-memory from MCP servers");
           p.log.message(dim(`  Updated: ${opencodeConfigPath}`));
         } else {
@@ -122735,13 +123549,13 @@ async function setup(forceReinstall = false, nonInteractive = false) {
   p.log.message(dim(`  Lite: ${liteModel}`));
   p.log.step("Setting up OpenCode integration...");
   const stats = { created: 0, updated: 0, unchanged: 0 };
-  const legacySkillsDir = join27(configDir, "skills");
-  const skillsDir = join27(configDir, "skill");
-  if (existsSync17(legacySkillsDir) && !existsSync17(skillsDir)) {
+  const legacySkillsDir = join29(configDir, "skills");
+  const skillsDir = join29(configDir, "skill");
+  if (existsSync20(legacySkillsDir) && !existsSync20(skillsDir)) {
     p.log.step("Migrating skills directory...");
     try {
       renameSync(legacySkillsDir, skillsDir);
-      p.log.message(dim(`  Renamed: ${legacySkillsDir} → ${skillsDir}`));
+      p.log.message(dim(`  Renamed: ${legacySkillsDir} \u2192 ${skillsDir}`));
     } catch (err) {
       p.log.warn(`Could not migrate skills directory: ${err}`);
     }
@@ -122758,28 +123572,28 @@ async function setup(forceReinstall = false, nonInteractive = false) {
   stats[writeFileWithStatus(plannerAgentPath, getPlannerAgent(coordinatorModel), "Planner agent")]++;
   stats[writeFileWithStatus(workerAgentPath, getWorkerAgent(workerModel), "Worker agent")]++;
   stats[writeFileWithStatus(researcherAgentPath, getResearcherAgent(workerModel), "Researcher agent")]++;
-  if (existsSync17(legacyPlannerPath) || existsSync17(legacyWorkerPath) || existsSync17(legacyResearcherPath)) {
+  if (existsSync20(legacyPlannerPath) || existsSync20(legacyWorkerPath) || existsSync20(legacyResearcherPath)) {
     p.log.step("Cleaning up legacy nested agent files...");
   }
   rmWithStatus(legacyPlannerPath, "legacy swarm/planner");
   rmWithStatus(legacyWorkerPath, "legacy swarm/worker");
   rmWithStatus(legacyResearcherPath, "legacy swarm/researcher");
-  if (existsSync17(swarmAgentDir)) {
+  if (existsSync20(swarmAgentDir)) {
     try {
       rmdirSync(swarmAgentDir);
     } catch {}
   }
   p.log.message(dim(`  Skills directory: ${skillsDir}`));
-  const bundledSkillsPath = join27(__dirname2, "..", "global-skills");
+  const bundledSkillsPath = join29(__dirname2, "..", "global-skills");
   const bundledSkills = listDirectoryNames(bundledSkillsPath);
-  if (existsSync17(bundledSkillsPath)) {
+  if (existsSync20(bundledSkillsPath)) {
     if (bundledSkills.length > 0) {
       p.log.message(dim("  Bundled skills: " + bundledSkills.join(", ")));
     }
   }
   if (bundledSkills.length > 0) {
     const globalSkills = listDirectoryNames(skillsDir);
-    const managedBundled = globalSkills.filter((name) => existsSync17(join27(skillsDir, name, BUNDLED_SKILL_MARKER_FILENAME)));
+    const managedBundled = globalSkills.filter((name) => existsSync20(join29(skillsDir, name, BUNDLED_SKILL_MARKER_FILENAME)));
     const missingBundled = bundledSkills.filter((name) => !globalSkills.includes(name));
     if (missingBundled.length > 0 || managedBundled.length > 0) {
       {
@@ -122809,8 +123623,8 @@ async function setup(forceReinstall = false, nonInteractive = false) {
       }
     }
   }
-  const agentsPath = join27(configDir, "AGENTS.md");
-  if (existsSync17(agentsPath)) {
+  const agentsPath = join29(configDir, "AGENTS.md");
+  if (existsSync20(agentsPath)) {
     {
       const s2 = p.spinner();
       s2.start("Updating AGENTS.md...");
@@ -122853,15 +123667,15 @@ Skills: Use skills_list to see available skills`, "Next steps");
 async function init() {
   p.intro("swarm init v" + VERSION);
   const projectPath = process.cwd();
-  const gitDir = existsSync17(".git");
+  const gitDir = existsSync20(".git");
   if (!gitDir) {
     p.log.error("Not in a git repository");
     p.log.message("Run 'git init' first, or cd to a git repo");
     p.outro("Aborted");
     process.exit(1);
   }
-  const hiveDir = existsSync17(".hive");
-  const beadsDir = existsSync17(".beads");
+  const hiveDir = existsSync20(".hive");
+  const beadsDir = existsSync20(".beads");
   if (hiveDir) {
     p.log.warn("Hive already initialized in this project (.hive/ exists)");
     const reinit = await p.confirm({
@@ -122944,8 +123758,8 @@ async function init() {
     });
     if (!p.isCancel(createSkillsDir) && createSkillsDir) {
       const skillsPath = ".opencode/skill";
-      if (!existsSync17(skillsPath)) {
-        mkdirSync9(skillsPath, { recursive: true });
+      if (!existsSync20(skillsPath)) {
+        mkdirSync11(skillsPath, { recursive: true });
         p.log.success("Created " + skillsPath + "/");
         p.log.message(dim("  Add SKILL.md files here for project-specific skills"));
       } else {
@@ -122976,14 +123790,14 @@ async function version4() {
     showUpdateNotification(updateInfo3);
 }
 function config4() {
-  const configDir = join27(homedir10(), ".config", "opencode");
-  const pluginPath = join27(configDir, "plugin", "swarm.ts");
-  const commandPath = join27(configDir, "command", "swarm.md");
-  const agentDir = join27(configDir, "agent");
-  const plannerAgentPath = join27(agentDir, "swarm-planner.md");
-  const workerAgentPath = join27(agentDir, "swarm-worker.md");
-  const researcherAgentPath = join27(agentDir, "swarm-researcher.md");
-  const globalSkillsPath = join27(configDir, "skills");
+  const configDir = join29(homedir11(), ".config", "opencode");
+  const pluginPath = join29(configDir, "plugin", "swarm.ts");
+  const commandPath = join29(configDir, "command", "swarm.md");
+  const agentDir = join29(configDir, "agent");
+  const plannerAgentPath = join29(agentDir, "swarm-planner.md");
+  const workerAgentPath = join29(agentDir, "swarm-worker.md");
+  const researcherAgentPath = join29(agentDir, "swarm-researcher.md");
+  const globalSkillsPath = join29(configDir, "skills");
   console.log(yellow(BANNER));
   console.log(dim("  " + TAGLINE + " v" + VERSION));
   console.log();
@@ -122997,8 +123811,8 @@ function config4() {
     { path: researcherAgentPath, desc: "@swarm-researcher agent", emoji: "\uD83D\uDD2C" }
   ];
   for (const { path: path4, desc, emoji: emoji4 } of files) {
-    const exists4 = existsSync17(path4);
-    const status = exists4 ? "✓" : "✗";
+    const exists4 = existsSync20(path4);
+    const status = exists4 ? "\u2713" : "\u2717";
     const color = exists4 ? "\x1B[32m" : "\x1B[31m";
     console.log(`  ${emoji4} ${desc}`);
     console.log(`     ${color}${status}\x1B[0m ${dim(path4)}`);
@@ -123006,8 +123820,8 @@ function config4() {
   }
   console.log(cyan("Skills:"));
   console.log();
-  const globalSkillsExists = existsSync17(globalSkillsPath);
-  const globalStatus = globalSkillsExists ? "✓" : "✗";
+  const globalSkillsExists = existsSync20(globalSkillsPath);
+  const globalStatus = globalSkillsExists ? "\u2713" : "\u2717";
   const globalColor = globalSkillsExists ? "\x1B[32m" : "\x1B[31m";
   console.log(`  \uD83D\uDCDA Global skills directory`);
   console.log(`     ${globalColor}${globalStatus}\x1B[0m ${dim(globalSkillsPath)}`);
@@ -123026,8 +123840,8 @@ function config4() {
   console.log(`     ${dim(".claude/skills/")}`);
   console.log(`     ${dim("skill/")}`);
   console.log();
-  const bundledSkillsPath = join27(__dirname2, "..", "global-skills");
-  if (existsSync17(bundledSkillsPath)) {
+  const bundledSkillsPath = join29(__dirname2, "..", "global-skills");
+  if (existsSync20(bundledSkillsPath)) {
     try {
       const { readdirSync: readdirSync3 } = __require("fs");
       const bundled = readdirSync3(bundledSkillsPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
@@ -123058,7 +123872,7 @@ async function update10() {
     p.outro("No update needed!");
     return;
   }
-  s.stop("Update available: " + VERSION + " → " + updateInfo3.latest);
+  s.stop("Update available: " + VERSION + " \u2192 " + updateInfo3.latest);
   const confirmUpdate = await p.confirm({
     message: "Update to v" + updateInfo3.latest + "?",
     initialValue: true
@@ -123195,7 +124009,7 @@ async function dashboard() {
           console.log(dim("  No subtasks"));
         } else {
           for (const p2 of progress) {
-            const bar = "█".repeat(Math.floor(p2.progress_percent / 10)) + "░".repeat(10 - Math.floor(p2.progress_percent / 10));
+            const bar = "\u2588".repeat(Math.floor(p2.progress_percent / 10)) + "\u2591".repeat(10 - Math.floor(p2.progress_percent / 10));
             console.log(`  ${p2.bead_id} [${bar}] ${p2.progress_percent}% - ${p2.status}`);
           }
         }
@@ -123221,7 +124035,7 @@ async function dashboard() {
         for (const msg of messages) {
           const timeAgo = Math.floor((Date.now() - new Date(msg.timestamp).getTime()) / 1000);
           const toList = Array.isArray(msg.to) ? msg.to.join(", ") : "unknown";
-          console.log(`  ${msg.from || "unknown"} → ${toList}: ${msg.subject} (${timeAgo}s ago)`);
+          console.log(`  ${msg.from || "unknown"} \u2192 ${toList}: ${msg.subject} (${timeAgo}s ago)`);
         }
       }
       console.log();
@@ -123362,7 +124176,7 @@ async function exportEvents() {
         break;
     }
     if (parsed.output) {
-      writeFileSync6(parsed.output, result);
+      writeFileSync7(parsed.output, result);
       p.log.success(`Exported to: ${parsed.output}`);
     } else {
       console.log();
@@ -123397,6 +124211,7 @@ ${cyan("Commands:")}
   swarm viz       Alias for 'swarm serve' (deprecated, use serve)
     --port <n>          Port to listen on (default: 4483)
   swarm cells     List or get cells from database (replaces 'swarm tool hive_query')
+  swarm memory    Manage unified memory system (learnings + sessions)
   swarm log       View swarm logs with filtering
   swarm stats     Show swarm health metrics powered by swarm-insights (strategy success rates, patterns)
   swarm o11y      Show observability health - hook coverage, event capture, session quality
@@ -123424,6 +124239,17 @@ ${cyan("Cell Management:")}
   swarm cells --ready                  Show next ready (unblocked) cell
   swarm cells --json                   Raw JSON output (array, no wrapper)
 
+${cyan("Memory Management (Hivemind):")}
+  swarm memory store <info> [--tags <tags>]    Store a learning/memory
+  swarm memory find <query> [--limit <n>]      Search all memories (semantic + FTS)
+  swarm memory get <id>                        Get specific memory by ID
+  swarm memory remove <id>                     Delete outdated/incorrect memory
+  swarm memory validate <id>                   Confirm accuracy (resets 90-day decay)
+  swarm memory stats                           Show database statistics
+  swarm memory index                           Index AI sessions (use hivemind_index tool)
+  swarm memory sync                            Sync to .hive/memories.jsonl (use hivemind_sync tool)
+  swarm memory <command> --json                Output JSON for all commands
+
 ${cyan("Log Viewing:")}
   swarm log                            Tail recent logs (last 50 lines)
   swarm log <module>                   Filter by module (e.g., compaction)
@@ -123582,43 +124408,74 @@ async function listTools() {
   console.log(dim("Example: swarm tool hive_ready"));
   console.log(dim(`Example: swarm tool hive_create --json '{"title": "Fix bug"}'`));
 }
-async function agents() {
+async function agents(nonInteractive = false) {
   const home = process.env.HOME || process.env.USERPROFILE || "~";
-  const agentsPath = join27(home, ".config", "opencode", "AGENTS.md");
+  const agentsPath = join29(home, ".config", "opencode", "AGENTS.md");
   p.intro(yellow(BANNER));
-  if (!existsSync17(agentsPath)) {
+  if (!existsSync20(agentsPath)) {
     p.log.warn("No AGENTS.md found at " + agentsPath);
     p.log.message(dim("Create one first, then run this command to add skill awareness"));
     p.outro("Aborted");
     return;
   }
-  const confirm2 = await p.confirm({
-    message: "Update AGENTS.md with skill awareness?",
-    initialValue: true
-  });
-  if (p.isCancel(confirm2) || !confirm2) {
-    p.outro("Aborted");
-    return;
+  if (!nonInteractive) {
+    const result = await p.confirm({
+      message: "Update AGENTS.md with Hivemind unification?",
+      initialValue: true
+    });
+    if (p.isCancel(result) || !result) {
+      p.outro("Aborted");
+      return;
+    }
   }
   const s = p.spinner();
-  s.start("Updating AGENTS.md with skill awareness...");
-  const bundledSkillsPath = join27(__dirname2, "..", "global-skills");
-  const bundledSkills = listDirectoryNames(bundledSkillsPath);
+  s.start("Updating AGENTS.md via LLM...");
+  const prompt = `You are updating ~/.config/opencode/AGENTS.md to unify memory tools under Hivemind (ADR-011).
+
+TASK: Update the AGENTS.md file to:
+
+1. **Rename tool references** throughout the file:
+   - \`cass_search\` \u2192 \`hivemind_find\`
+   - \`cass_view\` \u2192 \`hivemind_get\`
+   - \`cass_expand\` \u2192 \`hivemind_get\`
+   - \`cass_health\` \u2192 \`hivemind_stats\`
+   - \`cass_index\` \u2192 \`hivemind_index\`
+   - \`cass_stats\` \u2192 \`hivemind_stats\`
+   - \`semantic-memory_store\` \u2192 \`hivemind_store\`
+   - \`semantic-memory_find\` \u2192 \`hivemind_find\`
+   - \`semantic-memory_get\` \u2192 \`hivemind_get\`
+   - \`semantic-memory_remove\` \u2192 \`hivemind_remove\`
+   - \`semantic-memory_validate\` \u2192 \`hivemind_validate\`
+   - \`semantic-memory_list\` \u2192 \`hivemind_find\`
+   - \`semantic-memory_stats\` \u2192 \`hivemind_stats\`
+
+2. **Consolidate sections**: If there are separate "CASS" and "Semantic Memory" sections, merge them into a single "Hivemind - Unified Memory System" section that covers:
+   - Unified storage (learnings + sessions in same DB)
+   - All hivemind_* tools with descriptions
+   - Usage examples showing both storing learnings and searching sessions
+   - The 90-day decay and validation workflow
+
+3. **Update any prose** that mentions "CASS" or "semantic memory" separately to use "Hivemind" terminology.
+
+4. **Keep existing structure** - don't reorganize unrelated sections.
+
+Read the file, make the updates, and save it. Create a backup first.`;
   try {
-    const bundledSkillsCsv = bundledSkills.length > 0 ? bundledSkills.join(", ") : "cli-builder, learning-systems, skill-creator, swarm-coordination, system-design, testing-patterns";
-    const result = updateAgentsMdFile({ agentsPath, bundledSkillsCsv });
-    if (result.changed) {
-      s.stop("AGENTS.md updated with skill awareness");
-      p.log.success("Skills section added to " + agentsPath);
-      p.log.message(dim("Skills available: skills_list, skills_use, skills_read"));
-      if (result.backupPath) {
-        p.log.message(dim("Backup: " + result.backupPath));
-      }
+    const proc = Bun.spawn(["opencode", "run", prompt], {
+      stdio: ["inherit", "pipe", "pipe"],
+      cwd: home
+    });
+    const exitCode = await proc.exited;
+    if (exitCode === 0) {
+      s.stop("AGENTS.md updated via LLM");
+      p.log.success("Hivemind unification complete");
     } else {
-      s.stop("AGENTS.md already up to date");
+      const stderr = await new Response(proc.stderr).text();
+      s.stop("LLM update failed");
+      p.log.error(stderr || `Exit code: ${exitCode}`);
     }
   } catch (error54) {
-    s.stop("Failed to update AGENTS.md");
+    s.stop("Failed to run opencode");
     p.log.error(String(error54));
   }
   p.outro("Done");
@@ -123627,9 +124484,9 @@ async function migrate() {
   p.intro("swarm migrate v" + VERSION);
   const projectPath = process.cwd();
   const tempDirName = getLibSQLProjectTempDirName(projectPath);
-  const tempDir = join27(tmpdir3(), tempDirName);
-  const pglitePath = join27(tempDir, "streams");
-  const libsqlPath = join27(tempDir, "streams.db");
+  const tempDir = join29(tmpdir3(), tempDirName);
+  const pglitePath = join29(tempDir, "streams");
+  const libsqlPath = join29(tempDir, "streams.db");
   if (!pgliteExists(pglitePath)) {
     p.log.success("No PGlite database found - nothing to migrate!");
     p.outro("Done");
@@ -123659,7 +124516,7 @@ async function migrate() {
       p.log.message(`  \uD83D\uDC1D ${dryResult.beads.migrated} cells`);
     }
     if (dryResult.messages.migrated > 0) {
-      p.log.message(`  ✉️  ${dryResult.messages.migrated} messages`);
+      p.log.message(`  \u2709\uFE0F  ${dryResult.messages.migrated} messages`);
     }
     if (dryResult.agents.migrated > 0) {
       p.log.message(`  \uD83E\uDD16 ${dryResult.agents.migrated} agents`);
@@ -123717,10 +124574,10 @@ async function migrate() {
   }
 }
 function parseSessionFile(filePath) {
-  if (!existsSync17(filePath)) {
+  if (!existsSync20(filePath)) {
     throw new Error(`Session file not found: ${filePath}`);
   }
-  const content = readFileSync13(filePath, "utf-8");
+  const content = readFileSync16(filePath, "utf-8");
   const lines = content.split(`
 `).filter((line) => line.trim());
   const events = [];
@@ -123733,12 +124590,12 @@ function parseSessionFile(filePath) {
   return events;
 }
 function listSessionFiles(dir) {
-  if (!existsSync17(dir))
+  if (!existsSync20(dir))
     return [];
   const files = readdirSync2(dir).filter((f) => f.endsWith(".jsonl"));
   const sessions = [];
   for (const file4 of files) {
-    const filePath = join27(dir, file4);
+    const filePath = join29(dir, file4);
     try {
       const events = parseSessionFile(filePath);
       if (events.length === 0)
@@ -123788,7 +124645,7 @@ function formatEvent(event, useColor = true) {
 }
 async function logSessions() {
   const args3 = process.argv.slice(4);
-  const sessionsDir = join27(homedir10(), ".config", "swarm-tools", "sessions");
+  const sessionsDir = join29(homedir11(), ".config", "swarm-tools", "sessions");
   let sessionId = null;
   let latest = false;
   let jsonOutput = false;
@@ -123989,14 +124846,14 @@ ${dim(JSON.stringify(log4.data, null, 2))}`;
   return output;
 }
 function readLogFiles(dir) {
-  if (!existsSync17(dir))
+  if (!existsSync20(dir))
     return [];
   const allFiles = readdirSync2(dir);
-  const logFiles = allFiles.filter((f) => /\.\d+log$/.test(f) || /\.log$/.test(f)).sort().map((f) => join27(dir, f));
+  const logFiles = allFiles.filter((f) => /\.\d+log$/.test(f) || /\.log$/.test(f)).sort().map((f) => join29(dir, f));
   const entries2 = [];
   for (const file4 of logFiles) {
     try {
-      const content = readFileSync13(file4, "utf-8");
+      const content = readFileSync16(file4, "utf-8");
       const fileLines = content.split(`
 `).filter((line) => line.trim());
       for (const line of fileLines) {
@@ -124071,7 +124928,7 @@ async function cells() {
   }
   const projectPath = process.cwd();
   try {
-    const swarmMail = await getSwarmMailLibSQL17(projectPath);
+    const swarmMail = await getSwarmMailLibSQL19(projectPath);
     const db = await swarmMail.getDatabase();
     const adapter = createHiveAdapter4(db, projectPath);
     await adapter.runMigrations();
@@ -124177,8 +125034,8 @@ async function logs() {
       moduleFilter = arg;
     }
   }
-  const logsDir = join27(homedir10(), ".config", "swarm-tools", "logs");
-  if (!existsSync17(logsDir)) {
+  const logsDir = join29(homedir11(), ".config", "swarm-tools", "logs");
+  if (!existsSync20(logsDir)) {
     if (!jsonOutput) {
       p.log.warn("No logs directory found");
       p.log.message(dim(`  Expected: ${logsDir}`));
@@ -124211,11 +125068,11 @@ async function logs() {
     console.log();
     const filePositions = new Map;
     const initializePositions = () => {
-      if (!existsSync17(logsDir))
+      if (!existsSync20(logsDir))
         return;
       const files = readdirSync2(logsDir).filter((f) => /\.\d+log$/.test(f) || /\.log$/.test(f));
       for (const file4 of files) {
-        const filePath = join27(logsDir, file4);
+        const filePath = join29(logsDir, file4);
         try {
           const stats = statSync2(filePath);
           filePositions.set(filePath, stats.size);
@@ -124232,7 +125089,7 @@ async function logs() {
           }
           return [];
         }
-        const content = readFileSync13(filePath, "utf-8");
+        const content = readFileSync16(filePath, "utf-8");
         const newContent = content.slice(lastPos);
         filePositions.set(filePath, stats.size);
         return newContent.split(`
@@ -124249,11 +125106,11 @@ async function logs() {
     }
     initializePositions();
     const pollForNewLogs = () => {
-      if (!existsSync17(logsDir))
+      if (!existsSync20(logsDir))
         return;
       const files = readdirSync2(logsDir).filter((f) => /\.\d+log$/.test(f) || /\.log$/.test(f));
       for (const file4 of files) {
-        const filePath = join27(logsDir, file4);
+        const filePath = join29(logsDir, file4);
         const newLines = readNewLines(filePath);
         for (const line of newLines) {
           const parsed = parseLogLine(line, filePath);
@@ -124309,7 +125166,7 @@ async function db() {
   const projectName = basename3(projectPath);
   const hash5 = hashLibSQLProjectPath(projectPath);
   const dbPath = getLibSQLDatabasePath(projectPath);
-  const dbDir = dirname7(dbPath.replace("file:", ""));
+  const dbDir = dirname9(dbPath.replace("file:", ""));
   const dbFile = dbPath.replace("file:", "");
   console.log(yellow(BANNER));
   console.log(dim(`  ${TAGLINE}
@@ -124322,51 +125179,51 @@ async function db() {
   console.log(`  ${dim("DB Directory:")} ${dbDir}`);
   console.log(`  ${dim("DB File:")}      ${dbFile}`);
   console.log();
-  if (existsSync17(dbFile)) {
+  if (existsSync20(dbFile)) {
     const stats = statSync2(dbFile);
     const sizeKB = Math.round(stats.size / 1024);
-    console.log(`  ${green("✓")} Database exists (${sizeKB} KB)`);
+    console.log(`  ${green("\u2713")} Database exists (${sizeKB} KB)`);
     try {
       const schema = execSync(`sqlite3 "${dbFile}" "SELECT sql FROM sqlite_master WHERE type='table' AND name='beads'"`, { encoding: "utf-8" }).trim();
       if (schema) {
         const hasProjectKey = schema.includes("project_key");
         if (hasProjectKey) {
-          console.log(`  ${green("✓")} Schema is correct (has project_key)`);
+          console.log(`  ${green("\u2713")} Schema is correct (has project_key)`);
         } else {
-          console.log(`  \x1B[31m✗\x1B[0m Schema is OLD (missing project_key)`);
+          console.log(`  \x1B[31m\u2717\x1B[0m Schema is OLD (missing project_key)`);
           console.log();
           console.log(dim("    To fix: delete the database and restart OpenCode"));
           console.log(dim(`    rm -r "${dbDir}"`));
         }
       } else {
-        console.log(`  ${dim("○")} No beads table yet (will be created on first use)`);
+        console.log(`  ${dim("\u25CB")} No beads table yet (will be created on first use)`);
       }
       try {
         const version5 = execSync(`sqlite3 "${dbFile}" "SELECT MAX(version) FROM schema_version"`, { encoding: "utf-8" }).trim();
         if (version5 && version5 !== "") {
-          console.log(`  ${dim("○")} Schema version: ${version5}`);
+          console.log(`  ${dim("\u25CB")} Schema version: ${version5}`);
         }
       } catch {
-        console.log(`  ${dim("○")} No schema_version table`);
+        console.log(`  ${dim("\u25CB")} No schema_version table`);
       }
       try {
         const beadCount = execSync(`sqlite3 "${dbFile}" "SELECT COUNT(*) FROM beads"`, { encoding: "utf-8" }).trim();
-        console.log(`  ${dim("○")} Cells: ${beadCount}`);
+        console.log(`  ${dim("\u25CB")} Cells: ${beadCount}`);
       } catch {}
       try {
         const memoryCount = execSync(`sqlite3 "${dbFile}" "SELECT COUNT(*) FROM memories"`, { encoding: "utf-8" }).trim();
-        console.log(`  ${dim("○")} Memories: ${memoryCount}`);
+        console.log(`  ${dim("\u25CB")} Memories: ${memoryCount}`);
       } catch {}
     } catch (error54) {
-      console.log(`  ${dim("○")} Could not inspect schema (sqlite3 not available)`);
+      console.log(`  ${dim("\u25CB")} Could not inspect schema (sqlite3 not available)`);
     }
   } else {
-    console.log(`  ${dim("○")} Database does not exist yet`);
+    console.log(`  ${dim("\u25CB")} Database does not exist yet`);
     console.log(dim("    Will be created on first use"));
   }
   console.log();
-  const pglitePath = join27(dbDir, "streams");
-  if (existsSync17(pglitePath)) {
+  const pglitePath = join29(dbDir, "streams");
+  if (existsSync20(pglitePath)) {
     console.log(`  \x1B[33m!\x1B[0m Legacy PGLite directory exists`);
     console.log(dim(`    ${pglitePath}`));
     console.log(dim("    Run 'swarm migrate' to migrate data"));
@@ -124376,7 +125233,7 @@ async function db() {
 function generateSparkline(scores) {
   if (scores.length === 0)
     return "";
-  const chars = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+  const chars = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
   const min4 = Math.min(...scores);
   const max5 = Math.max(...scores);
   const range3 = max5 - min4;
@@ -124390,7 +125247,7 @@ function generateSparkline(scores) {
   }).join("");
 }
 function formatEvalStatusOutput(status) {
-  const phaseEmoji = status.phase === "bootstrap" ? "\uD83C\uDF31" : status.phase === "stabilization" ? "⚙️" : "\uD83D\uDE80";
+  const phaseEmoji = status.phase === "bootstrap" ? "\uD83C\uDF31" : status.phase === "stabilization" ? "\u2699\uFE0F" : "\uD83D\uDE80";
   const phaseColor = status.phase === "bootstrap" ? yellow : status.phase === "stabilization" ? cyan : green;
   p.log.step(`${phaseEmoji} Phase: ${phaseColor(bold(status.phase))}`);
   p.log.message(`${dim("Runs:")} ${status.runCount}`);
@@ -124398,8 +125255,8 @@ function formatEvalStatusOutput(status) {
   p.log.message(bold("Gate Thresholds"));
   const stabilizationPct = (status.thresholds.stabilization * 100).toFixed(0);
   const productionPct = (status.thresholds.production * 100).toFixed(0);
-  p.log.message(`  ${yellow("⚠")}  Stabilization: ${stabilizationPct}% regression ${dim("(warn)")}`);
-  p.log.message(`  ${red("✗")}  Production:    ${productionPct}% regression ${dim("(fail)")}`);
+  p.log.message(`  ${yellow("\u26A0")}  Stabilization: ${stabilizationPct}% regression ${dim("(warn)")}`);
+  p.log.message(`  ${red("\u2717")}  Production:    ${productionPct}% regression ${dim("(fail)")}`);
   console.log();
   if (status.recentScores.length > 0) {
     p.log.message(bold("Recent Scores"));
@@ -124449,9 +125306,9 @@ function formatEvalHistoryOutput(history) {
 }
 function formatEvalRunResultOutput(result) {
   if (result.passed) {
-    p.log.success(bold(green("✓ PASS")));
+    p.log.success(bold(green("\u2713 PASS")));
   } else {
-    p.log.error(bold(red("✗ FAIL")));
+    p.log.error(bold(red("\u2717 FAIL")));
   }
   console.log();
   const phaseColor = result.phase === "bootstrap" ? yellow : result.phase === "stabilization" ? cyan : green;
@@ -124488,7 +125345,7 @@ async function stats() {
   }
   try {
     const projectPath = process.cwd();
-    const swarmMail = await getSwarmMailLibSQL17(projectPath);
+    const swarmMail = await getSwarmMailLibSQL19(projectPath);
     const db2 = await swarmMail.getDatabase();
     const since = parseTimePeriod(period);
     const periodMatch = period.match(/^(\d+)([dhm])$/);
@@ -124512,21 +125369,21 @@ async function stats() {
       strategy: row.strategy,
       success: row.success === "true"
     })));
-    const sessionsPath = join27(homedir10(), ".config", "swarm-tools", "sessions");
+    const sessionsPath = join29(homedir11(), ".config", "swarm-tools", "sessions");
     let coordinatorStats = {
       violationRate: 0,
       spawnEfficiency: 0,
       reviewThoroughness: 0
     };
-    if (existsSync17(sessionsPath)) {
-      const sessionFiles = readdirSync2(sessionsPath).filter((f) => f.endsWith(".jsonl") && statSync2(join27(sessionsPath, f)).mtimeMs >= since);
+    if (existsSync20(sessionsPath)) {
+      const sessionFiles = readdirSync2(sessionsPath).filter((f) => f.endsWith(".jsonl") && statSync2(join29(sessionsPath, f)).mtimeMs >= since);
       let totalViolations = 0;
       let totalSpawns = 0;
       let totalReviews = 0;
       let totalSwarms = 0;
       for (const file4 of sessionFiles) {
         try {
-          const content = readFileSync13(join27(sessionsPath, file4), "utf-8");
+          const content = readFileSync16(join29(sessionsPath, file4), "utf-8");
           const lines = content.trim().split(`
 `);
           let violations = 0;
@@ -124568,7 +125425,7 @@ async function stats() {
       recentDays: Math.round(periodDays * 10) / 10
     };
     if (showRegressions) {
-      const regressions = detectRegressions(projectPath, 0.1);
+      const regressions = detectRegressions2(projectPath, 0.1);
       if (format5 === "json") {
         console.log(JSON.stringify({ stats: stats2, regressions }, null, 2));
       } else {
@@ -124577,17 +125434,17 @@ async function stats() {
         console.log();
         if (regressions.length > 0) {
           console.log(`
-⚠️  EVAL REGRESSIONS DETECTED`);
+\u26A0\uFE0F  EVAL REGRESSIONS DETECTED`);
           for (const reg of regressions) {
             const oldPercent = (reg.oldScore * 100).toFixed(1);
             const newPercent = (reg.newScore * 100).toFixed(1);
             const deltaPercent = reg.deltaPercent.toFixed(1);
-            console.log(`├── ${reg.evalName}: ${oldPercent}% → ${newPercent}% (${deltaPercent}%)`);
+            console.log(`\u251C\u2500\u2500 ${reg.evalName}: ${oldPercent}% \u2192 ${newPercent}% (${deltaPercent}%)`);
           }
-          console.log(`└── Threshold: 10%
+          console.log(`\u2514\u2500\u2500 Threshold: 10%
 `);
         } else {
-          console.log(`✅ No eval regressions detected (>10% threshold)
+          console.log(`\u2705 No eval regressions detected (>10% threshold)
 `);
         }
       }
@@ -124677,7 +125534,7 @@ async function swarmHistory() {
       console.log("Details:");
       for (const record4 of records) {
         console.log(`  ${record4.epic_id}: ${record4.epic_title} (${record4.strategy})`);
-        console.log(`    Tasks: ${record4.completed_count}/${record4.task_count}, Success: ${record4.overall_success ? "✅" : "❌"}`);
+        console.log(`    Tasks: ${record4.completed_count}/${record4.task_count}, Success: ${record4.overall_success ? "\u2705" : "\u274C"}`);
       }
       console.log();
     }
@@ -124732,8 +125589,8 @@ async function evalStatus() {
   p.intro("swarm eval status");
   const projectPath = process.cwd();
   const evalName = process.argv[4] || "swarm-decomposition";
-  const phase = getPhase(projectPath, evalName);
-  const history = getScoreHistory(projectPath, evalName);
+  const phase = getPhase2(projectPath, evalName);
+  const history = getScoreHistory2(projectPath, evalName);
   const recentScores = history.slice(-5).map((run) => ({
     timestamp: run.timestamp,
     score: run.score
@@ -124750,14 +125607,14 @@ async function evalStatus() {
 async function evalHistory() {
   p.intro("swarm eval history");
   const projectPath = process.cwd();
-  const historyPath = getEvalHistoryPath(projectPath);
-  if (!existsSync17(historyPath)) {
+  const historyPath = getEvalHistoryPath2(projectPath);
+  if (!existsSync20(historyPath)) {
     p.log.warn("No eval history found");
     p.log.message(dim(`Expected: ${historyPath}`));
     p.outro("Run evals to generate history");
     return;
   }
-  const content = readFileSync13(historyPath, "utf-8");
+  const content = readFileSync16(historyPath, "utf-8");
   const lines = content.trim().split(`
 `).filter(Boolean);
   const history = lines.map((line) => JSON.parse(line));
@@ -124788,7 +125645,7 @@ async function evalRun() {
       const evalPath = `evals/${evalName}.eval.ts`;
       const mockScore = 0.85;
       const gateResult = checkGate(projectPath, evalName, mockScore);
-      const history = getScoreHistory(projectPath, evalName);
+      const history = getScoreHistory2(projectPath, evalName);
       recordEvalRun(projectPath, {
         timestamp: new Date().toISOString(),
         eval_name: evalName,
@@ -124802,7 +125659,7 @@ async function evalRun() {
       if (!ciMode) {
         formatEvalRunResultOutput(gateResult);
       } else {
-        const status = gateResult.passed ? "✅ PASS" : "❌ FAIL";
+        const status = gateResult.passed ? "\u2705 PASS" : "\u274C FAIL";
         console.log(`${evalName}: ${status} (${gateResult.phase}, score: ${gateResult.currentScore.toFixed(2)})`);
         console.log(`  ${gateResult.message}`);
       }
@@ -124816,21 +125673,21 @@ async function evalRun() {
     }
   }
   if (ciMode) {
-    const resultsPath = join27(projectPath, ".hive", "eval-results.json");
+    const resultsPath = join29(projectPath, ".hive", "eval-results.json");
     ensureHiveDirectory(projectPath);
-    writeFileSync6(resultsPath, JSON.stringify(results, null, 2));
+    writeFileSync7(resultsPath, JSON.stringify(results, null, 2));
     console.log(`
 Results written to ${resultsPath}`);
     if (anyFailure) {
       const productionFailures = Object.entries(results).filter(([_, result]) => !result.passed && result.phase === "production");
       if (productionFailures.length > 0) {
         console.error(`
-❌ ${productionFailures.length} production-phase eval(s) failed`);
+\u274C ${productionFailures.length} production-phase eval(s) failed`);
         process.exit(1);
       }
     }
     console.log(`
-✅ All evals passed or in pre-production phase`);
+\u2705 All evals passed or in pre-production phase`);
   } else {
     console.log();
     p.outro(anyFailure ? "Some evals need attention" : "All evals passed!");
@@ -124845,7 +125702,7 @@ async function serve() {
   p.log.message(dim(`  Project: ${projectPath}`));
   p.log.message(dim(`  Port: ${port} (HIVE on phone keypad)`));
   try {
-    const swarmMail = await getSwarmMailLibSQL17(projectPath);
+    const swarmMail = await getSwarmMailLibSQL19(projectPath);
     const streamAdapter = createDurableStreamAdapter(swarmMail, projectPath);
     const db2 = await swarmMail.getDatabase(projectPath);
     const hiveAdapter = createHiveAdapter4(db2, projectPath);
@@ -124880,7 +125737,7 @@ async function viz() {
   p.log.message(dim(`  Project: ${projectPath}`));
   p.log.message(dim(`  Port: ${port}`));
   try {
-    const swarmMail = await getSwarmMailLibSQL17(projectPath);
+    const swarmMail = await getSwarmMailLibSQL19(projectPath);
     const streamAdapter = createDurableStreamAdapter(swarmMail, projectPath);
     const db2 = await swarmMail.getDatabase(projectPath);
     const hiveAdapter = createHiveAdapter4(db2, projectPath);
@@ -124963,6 +125820,247 @@ async function capture3() {
     process.exit(1);
   }
 }
+function parseMemoryArgs(subcommand, args3) {
+  let json4 = false;
+  let info;
+  let query2;
+  let id;
+  let tags;
+  let limit;
+  let collection;
+  if (args3.length > 0 && !args3[0].startsWith("--")) {
+    if (subcommand === "store") {
+      info = args3[0];
+    } else if (subcommand === "find") {
+      query2 = args3[0];
+    } else if (subcommand === "get" || subcommand === "remove" || subcommand === "validate") {
+      id = args3[0];
+    }
+  }
+  for (let i = 0;i < args3.length; i++) {
+    const arg = args3[i];
+    if (arg === "--json") {
+      json4 = true;
+    } else if (arg === "--tags" && i + 1 < args3.length) {
+      tags = args3[++i];
+    } else if (arg === "--limit" && i + 1 < args3.length) {
+      const val = parseInt(args3[++i], 10);
+      if (!isNaN(val))
+        limit = val;
+    } else if (arg === "--collection" && i + 1 < args3.length) {
+      collection = args3[++i];
+    }
+  }
+  return { json: json4, info, query: query2, id, tags, limit, collection };
+}
+async function memory() {
+  const subcommand = process.argv[3];
+  const args3 = process.argv.slice(4);
+  const parsed = parseMemoryArgs(subcommand, args3);
+  const projectPath = process.cwd();
+  try {
+    const { getDb: getDb2 } = await import("swarm-mail");
+    const tempDirName = getLibSQLProjectTempDirName(projectPath);
+    const tempDir = join29(tmpdir3(), tempDirName);
+    if (!existsSync20(tempDir)) {
+      mkdirSync11(tempDir, { recursive: true });
+    }
+    const dbPath = join29(tempDir, "streams.db");
+    const dbUrl = `file://${dbPath}`;
+    const db2 = await getDb2(dbUrl);
+    const { createMemoryAdapter: createMemoryAdapter3 } = await import("swarm-mail");
+    const adapter = createMemoryAdapter3(db2, {
+      ollamaHost: process.env.OLLAMA_HOST || "http://localhost:11434",
+      ollamaModel: process.env.OLLAMA_MODEL || "mxbai-embed-large"
+    });
+    switch (subcommand) {
+      case "store": {
+        if (!parsed.info) {
+          console.error("Usage: swarm memory store <information> [--tags <tags>]");
+          process.exit(1);
+        }
+        const result = await adapter.store(parsed.info, {
+          tags: parsed.tags,
+          collection: parsed.collection || "default"
+        });
+        if (parsed.json) {
+          console.log(JSON.stringify({ success: true, id: result.id }));
+        } else {
+          p.intro("swarm memory store");
+          p.log.success(`Stored memory: ${result.id}`);
+          if (result.autoTags) {
+            p.log.message(`Auto-tags: ${result.autoTags.tags.join(", ")}`);
+          }
+          p.outro("Done");
+        }
+        break;
+      }
+      case "find": {
+        if (!parsed.query) {
+          console.error("Usage: swarm memory find <query> [--limit <n>] [--collection <name>]");
+          process.exit(1);
+        }
+        const results = await adapter.find(parsed.query, {
+          limit: parsed.limit || 10,
+          collection: parsed.collection
+        });
+        if (parsed.json) {
+          console.log(JSON.stringify({ success: true, results }));
+        } else {
+          p.intro(`swarm memory find: "${parsed.query}"`);
+          if (results.length === 0) {
+            p.log.warn("No memories found");
+          } else {
+            for (const result of results) {
+              console.log();
+              console.log(cyan(`[${result.memory.id}] Score: ${result.score.toFixed(3)}`));
+              console.log(dim(`  Created: ${new Date(result.memory.createdAt).toLocaleDateString()}`));
+              console.log(`  ${result.memory.content.slice(0, 200)}${result.memory.content.length > 200 ? "..." : ""}`);
+              if (result.memory.metadata.tags) {
+                console.log(dim(`  Tags: ${result.memory.metadata.tags.join(", ")}`));
+              }
+            }
+          }
+          p.outro(`Found ${results.length} result(s)`);
+        }
+        break;
+      }
+      case "get": {
+        if (!parsed.id) {
+          console.error("Usage: swarm memory get <id>");
+          process.exit(1);
+        }
+        const memory2 = await adapter.get(parsed.id);
+        if (parsed.json) {
+          if (memory2) {
+            console.log(JSON.stringify({ success: true, memory: memory2 }));
+          } else {
+            console.log(JSON.stringify({ success: false, error: "Memory not found" }));
+            process.exit(1);
+          }
+        } else {
+          p.intro(`swarm memory get: ${parsed.id}`);
+          if (!memory2) {
+            p.log.error("Memory not found");
+            p.outro("Aborted");
+            process.exit(1);
+          } else {
+            console.log();
+            console.log(cyan("Content:"));
+            console.log(memory2.content);
+            console.log();
+            console.log(dim(`Created: ${new Date(memory2.createdAt).toLocaleDateString()}`));
+            console.log(dim(`Collection: ${memory2.collection}`));
+            console.log(dim(`Confidence: ${memory2.confidence ?? 0.7}`));
+            if (memory2.metadata.tags) {
+              console.log(dim(`Tags: ${memory2.metadata.tags.join(", ")}`));
+            }
+            p.outro("Done");
+          }
+        }
+        break;
+      }
+      case "remove": {
+        if (!parsed.id) {
+          console.error("Usage: swarm memory remove <id>");
+          process.exit(1);
+        }
+        await adapter.remove(parsed.id);
+        if (parsed.json) {
+          console.log(JSON.stringify({ success: true }));
+        } else {
+          p.intro("swarm memory remove");
+          p.log.success(`Removed memory: ${parsed.id}`);
+          p.outro("Done");
+        }
+        break;
+      }
+      case "validate": {
+        if (!parsed.id) {
+          console.error("Usage: swarm memory validate <id>");
+          process.exit(1);
+        }
+        await adapter.validate(parsed.id);
+        if (parsed.json) {
+          console.log(JSON.stringify({ success: true }));
+        } else {
+          p.intro("swarm memory validate");
+          p.log.success(`Validated memory: ${parsed.id} (decay timer reset)`);
+          p.outro("Done");
+        }
+        break;
+      }
+      case "stats": {
+        const stats2 = await adapter.stats();
+        if (parsed.json) {
+          console.log(JSON.stringify({ success: true, stats: stats2 }));
+        } else {
+          p.intro("swarm memory stats");
+          console.log();
+          console.log(cyan("Database Statistics:"));
+          console.log(`  Memories: ${stats2.memories}`);
+          console.log(`  Embeddings: ${stats2.embeddings}`);
+          p.outro("Done");
+        }
+        break;
+      }
+      case "index": {
+        if (parsed.json) {
+          console.log(JSON.stringify({ success: true, message: "Use hivemind_index tool for session indexing" }));
+        } else {
+          p.intro("swarm memory index");
+          p.log.message("Session indexing is handled by the hivemind_index tool");
+          p.log.message("Use: swarm tool hivemind_index");
+          p.outro("Done");
+        }
+        break;
+      }
+      case "sync": {
+        if (parsed.json) {
+          console.log(JSON.stringify({ success: true, message: "Use hivemind_sync tool for git sync" }));
+        } else {
+          p.intro("swarm memory sync");
+          p.log.message("Memory sync to .hive/memories.jsonl is handled by the hivemind_sync tool");
+          p.log.message("Use: swarm tool hivemind_sync");
+          p.outro("Done");
+        }
+        break;
+      }
+      default: {
+        console.error(`Unknown subcommand: ${subcommand}`);
+        console.error("");
+        console.error("Usage: swarm memory <subcommand> [options]");
+        console.error("");
+        console.error("Subcommands:");
+        console.error("  store <info> [--tags <tags>]         Store a memory");
+        console.error("  find <query> [--limit <n>]           Search memories");
+        console.error("  get <id>                             Get memory by ID");
+        console.error("  remove <id>                          Delete memory");
+        console.error("  validate <id>                        Reset decay timer");
+        console.error("  stats                                Show database stats");
+        console.error("  index                                Index sessions (use hivemind_index)");
+        console.error("  sync                                 Sync to git (use hivemind_sync)");
+        console.error("");
+        console.error("Global options:");
+        console.error("  --json                               Output JSON");
+        process.exit(1);
+      }
+    }
+  } catch (error54) {
+    if (parsed.json) {
+      console.log(JSON.stringify({
+        success: false,
+        error: error54 instanceof Error ? error54.message : String(error54)
+      }));
+      process.exit(1);
+    } else {
+      p.log.error("Memory operation failed");
+      p.log.message(error54 instanceof Error ? error54.message : String(error54));
+      p.outro("Aborted");
+      process.exit(1);
+    }
+  }
+}
 var command = process.argv[2];
 switch (command) {
   case "setup": {
@@ -124971,9 +126069,11 @@ switch (command) {
     await setup(reinstallFlag || yesFlag, yesFlag);
     break;
   }
-  case "doctor":
-    await doctor();
+  case "doctor": {
+    const debugFlag = process.argv.includes("--debug") || process.argv.includes("-d");
+    await doctor(debugFlag);
     break;
+  }
   case "init":
     await init();
     break;
@@ -125000,9 +126100,11 @@ switch (command) {
     }
     break;
   }
-  case "agents":
-    await agents();
+  case "agents": {
+    const agentsNonInteractive = process.argv.includes("--yes") || process.argv.includes("-y");
+    await agents(agentsNonInteractive);
     break;
+  }
   case "migrate":
     await migrate();
     break;
@@ -125031,6 +126133,9 @@ switch (command) {
   case "capture":
     await capture3();
     break;
+  case "memory":
+    await memory();
+    break;
   case "query":
     await query();
     break;