opencode-swarm-plugin 0.46.0 → 0.48.0

package/bin/swarm.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 /**
  * OpenCode Swarm Plugin CLI
  *
@@ -51,7 +51,7 @@ import {
   createDurableStreamAdapter,
   createDurableStreamServer,
 } from "swarm-mail";
-import { execSync } from "child_process";
+import { execSync, spawn } from "child_process";
 import { tmpdir } from "os";
 
 // Query & observability tools
@@ -464,6 +464,15 @@ interface CheckResult {
 // ============================================================================
 
 const DEPENDENCIES: Dependency[] = [
+  {
+    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",
@@ -512,34 +521,53 @@ async function checkCommand(
   cmd: string,
   args: string[],
 ): Promise<{ available: boolean; version?: string }> {
-  try {
-    const proc = Bun.spawn([cmd, ...args], {
-      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((resolve) => {
+    try {
+      const proc = spawn(cmd, args, {
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+      
+      let stdout = "";
+      proc.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      
+      proc.on("error", () => {
+        resolve({ available: false });
+      });
+      
+      proc.on("close", (exitCode) => {
+        if (exitCode === 0) {
+          const versionMatch = stdout.match(/v?(\d+\.\d+\.\d+)/);
+          resolve({ available: true, version: versionMatch?.[1] });
+        } else {
+          resolve({ available: false });
+        }
+      });
+    } catch {
+      resolve({ available: false });
     }
-    return { available: false };
-  } catch {
-    return { available: false };
-  }
+  });
 }
 
 async function runInstall(command: string): Promise<boolean> {
-  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((resolve) => {
+    try {
+      const proc = spawn("bash", ["-c", command], {
+        stdio: "inherit",
+      });
+      
+      proc.on("error", () => {
+        resolve(false);
+      });
+      
+      proc.on("close", (exitCode) => {
+        resolve(exitCode === 0);
+      });
+    } catch {
+      resolve(false);
+    }
+  });
 }
 
 async function checkAllDependencies(): Promise<CheckResult[]> {
@@ -707,68 +735,173 @@ function buildAgentsSkillsSection(
   ].join(newline);
 }
 
-function buildAgentsCassSection(newline: string): string {
+/**
+ * Build the unified Hivemind section (ADR-011).
+ * Replaces separate CASS and Semantic Memory sections.
+ */
+function buildAgentsHivemindSection(newline: string): string {
   return [
-    "## CASS - Cross-Agent Session Search",
+    "## Hivemind - Unified Memory System",
+    "",
+    "The hive remembers everything. Learnings, sessions, patterns—all searchable.",
+    "",
+    "**Unified storage:** Manual learnings and AI agent session histories stored in the same database, searchable together. Powered by libSQL vectors + Ollama embeddings.",
     "",
-    "Search across ALL your AI coding agent histories before solving problems from scratch.",
+    "**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: string): string {
-  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);
 }
 
+// Legacy functions kept for backwards compatibility during migration
+function buildAgentsCassSection(newline: string): string {
+  // Redirect to Hivemind section
+  return buildAgentsHivemindSection(newline);
+}
+
+function buildAgentsSemanticMemorySection(newline: string): string {
+  // Redirect to Hivemind section
+  return buildAgentsHivemindSection(newline);
+}
+
 function buildAgentsSwarmCoordinatorSection(newline: string): string {
   return [
     "## Swarm Coordinator Checklist (MANDATORY)",
@@ -935,6 +1068,53 @@ function updateAgentsMdContent({
     changes.push("Updated bundled skills list");
   }
 
+  // ADR-011: Migrate old tool names to hivemind
+  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 has old tools but not new hivemind tools, we need to update
+  if ((hasOldCassTools || hasOldSemanticTools) && !hasHivemindTools) {
+    // Replace old tool references with hivemind equivalents
+    const beforeMigration = updated;
+    
+    // Tool name replacements
+    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(");
+    
+    // Table references (without parentheses)
+    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)");
+    }
+  }
+
   // Update tool preferences block if present
   const toolPrefsResult = updateAgentsToolPreferencesBlock(updated, newline);
   if (toolPrefsResult.changed) {
@@ -942,14 +1122,11 @@ function updateAgentsMdContent({
     changes.push("Updated tool_preferences tool list");
   }
 
-  // Add missing sections (append at end)
+  // Check for sections - now unified under Hivemind
   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) ||
@@ -962,13 +1139,9 @@ function updateAgentsMdContent({
     );
     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));
@@ -1434,15 +1607,33 @@ function getFixCommand(dep: Dependency): string | 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 } of results) {
+      const status = available ? green("✓") : red("✗");
+      p.log.message(dim(`  ${status} ${dep.command} ${dep.checkArgs.join(" ")} → ${available ? `v${version || "unknown"}` : "not found"}`));
+    }
+  }
 
   const required = results.filter((r) => r.dep.required);
   const optional = results.filter((r) => !r.dep.required);
@@ -1571,6 +1762,23 @@ async function setup(forceReinstall = false, nonInteractive = false) {
 
   p.intro("opencode-swarm-plugin v" + VERSION);
 
+  // CRITICAL: Check for Bun first - the CLI requires Bun runtime
+  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`);
+
   // Migrate legacy database if present (do this first, before config check)
   const cwd = process.cwd();
   const tempDirName = getLibSQLProjectTempDirName(cwd);
@@ -3008,6 +3216,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
@@ -3035,6 +3244,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)
@@ -3257,7 +3477,7 @@ async function listTools() {
 // Agents Command - Update AGENTS.md with skill awareness
 // ============================================================================
 
-async function agents() {
+async function agents(nonInteractive = false) {
   const home = process.env.HOME || process.env.USERPROFILE || "~";
   const agentsPath = join(home, ".config", "opencode", "AGENTS.md");
 
@@ -3273,44 +3493,70 @@ async function agents() {
     return;
   }
 
-  const confirm = await p.confirm({
-    message: "Update AGENTS.md with skill awareness?",
-    initialValue: true,
-  });
+  if (!nonInteractive) {
+    const result = await p.confirm({
+      message: "Update AGENTS.md with Hivemind unification?",
+      initialValue: true,
+    });
 
-  if (p.isCancel(confirm) || !confirm) {
-    p.outro("Aborted");
-    return;
+    if (p.isCancel(result) || !result) {
+      p.outro("Aborted");
+      return;
+    }
   }
 
   const s = p.spinner();
-  s.start("Updating AGENTS.md with skill awareness...");
+  s.start("Updating AGENTS.md via LLM...");
 
-  const bundledSkillsPath = join(__dirname, "..", "global-skills");
-  const bundledSkills = listDirectoryNames(bundledSkillsPath);
+  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\` → \`hivemind_find\`
+   - \`cass_view\` → \`hivemind_get\`
+   - \`cass_expand\` → \`hivemind_get\`
+   - \`cass_health\` → \`hivemind_stats\`
+   - \`cass_index\` → \`hivemind_index\`
+   - \`cass_stats\` → \`hivemind_stats\`
+   - \`semantic-memory_store\` → \`hivemind_store\`
+   - \`semantic-memory_find\` → \`hivemind_find\`
+   - \`semantic-memory_get\` → \`hivemind_get\`
+   - \`semantic-memory_remove\` → \`hivemind_remove\`
+   - \`semantic-memory_validate\` → \`hivemind_validate\`
+   - \`semantic-memory_list\` → \`hivemind_find\`
+   - \`semantic-memory_stats\` → \`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 (error) {
-    s.stop("Failed to update AGENTS.md");
+    s.stop("Failed to run opencode");
     p.log.error(String(error));
   }
 
@@ -5269,6 +5515,319 @@ async function capture() {
   }
 }
 
+// ============================================================================
+// Memory Commands
+// ============================================================================
+
+/**
+ * Parse args for memory commands
+ */
+function parseMemoryArgs(subcommand: string, args: string[]): {
+  json: boolean;
+  info?: string;
+  query?: string;
+  id?: string;
+  tags?: string;
+  limit?: number;
+  collection?: string;
+} {
+  let json = false;
+  let info: string | undefined;
+  let query: string | undefined;
+  let id: string | undefined;
+  let tags: string | undefined;
+  let limit: number | undefined;
+  let collection: string | undefined;
+
+  // First positional arg for store/find/get/remove/validate
+  if (args.length > 0 && !args[0].startsWith("--")) {
+    if (subcommand === "store") {
+      info = args[0];
+    } else if (subcommand === "find") {
+      query = args[0];
+    } else if (subcommand === "get" || subcommand === "remove" || subcommand === "validate") {
+      id = args[0];
+    }
+  }
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--json") {
+      json = true;
+    } else if (arg === "--tags" && i + 1 < args.length) {
+      tags = args[++i];
+    } else if (arg === "--limit" && i + 1 < args.length) {
+      const val = parseInt(args[++i], 10);
+      if (!isNaN(val)) limit = val;
+    } else if (arg === "--collection" && i + 1 < args.length) {
+      collection = args[++i];
+    }
+  }
+
+  return { json, info, query, id, tags, limit, collection };
+}
+
+/**
+ * Memory command - unified interface to memory operations
+ * 
+ * Commands:
+ *   swarm memory store <info> [--tags <tags>]
+ *   swarm memory find <query> [--limit <n>] [--collection <name>]
+ *   swarm memory get <id>
+ *   swarm memory remove <id>
+ *   swarm memory validate <id>
+ *   swarm memory stats
+ *   swarm memory index
+ *   swarm memory sync
+ */
+async function memory() {
+  const subcommand = process.argv[3];
+  const args = process.argv.slice(4);
+  const parsed = parseMemoryArgs(subcommand, args);
+
+  // Get project path for libSQL database
+  const projectPath = process.cwd();
+
+  try {
+    // Get database instance using getDb from swarm-mail
+    // This returns a drizzle instance (SwarmDb) that memory adapter expects
+    const { getDb } = await import("swarm-mail");
+    
+    // Calculate DB path (same logic as libsql.convenience.ts)
+    const tempDirName = getLibSQLProjectTempDirName(projectPath);
+    const tempDir = join(tmpdir(), tempDirName);
+    
+    // Ensure temp directory exists
+    if (!existsSync(tempDir)) {
+      mkdirSync(tempDir, { recursive: true });
+    }
+    
+    const dbPath = join(tempDir, "streams.db");
+    
+    // Convert to file:// URL (required by libSQL)
+    const dbUrl = `file://${dbPath}`;
+    
+    const db = await getDb(dbUrl);
+    
+    // Create memory adapter with default Ollama config
+    const { createMemoryAdapter } = await import("swarm-mail");
+    const adapter = createMemoryAdapter(db, {
+      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 as string[]).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 memory = await adapter.get(parsed.id);
+
+        if (parsed.json) {
+          if (memory) {
+            console.log(JSON.stringify({ success: true, memory }));
+          } else {
+            console.log(JSON.stringify({ success: false, error: "Memory not found" }));
+            process.exit(1);
+          }
+        } else {
+          p.intro(`swarm memory get: ${parsed.id}`);
+          if (!memory) {
+            p.log.error("Memory not found");
+            p.outro("Aborted");
+            process.exit(1);
+          } else {
+            console.log();
+            console.log(cyan("Content:"));
+            console.log(memory.content);
+            console.log();
+            console.log(dim(`Created: ${new Date(memory.createdAt).toLocaleDateString()}`));
+            console.log(dim(`Collection: ${memory.collection}`));
+            console.log(dim(`Confidence: ${memory.confidence ?? 0.7}`));
+            if (memory.metadata.tags) {
+              console.log(dim(`Tags: ${(memory.metadata.tags as string[]).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 stats = await adapter.stats();
+
+        if (parsed.json) {
+          console.log(JSON.stringify({ success: true, stats }));
+        } else {
+          p.intro("swarm memory stats");
+          console.log();
+          console.log(cyan("Database Statistics:"));
+          console.log(`  Memories: ${stats.memories}`);
+          console.log(`  Embeddings: ${stats.embeddings}`);
+          p.outro("Done");
+        }
+        break;
+      }
+
+      case "index": {
+        // Index is a stub - actual indexing happens via session indexing
+        // which is handled by hivemind_index tool
+        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": {
+        // Sync is a stub - actual sync happens via .hive/memories.jsonl
+        // which is handled by hivemind_sync tool
+        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 (error) {
+    if (parsed.json) {
+      console.log(JSON.stringify({
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      }));
+      process.exit(1);
+    } else {
+      p.log.error("Memory operation failed");
+      p.log.message(error instanceof Error ? error.message : String(error));
+      p.outro("Aborted");
+      process.exit(1);
+    }
+  }
+}
+
 // ============================================================================
 // Main
 // ============================================================================
@@ -5282,9 +5841,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;
@@ -5313,9 +5874,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;
@@ -5344,6 +5907,9 @@ switch (command) {
   case "capture":
     await capture();
     break;
+  case "memory":
+    await memory();
+    break;
   case "query":
     await query();
     break;