opencode-swarm-plugin 0.29.0 → 0.30.0

package/.turbo/turbo-build.log

@@ -1,9 +1,9 @@
 $ bun build ./src/index.ts --outdir ./dist --target node --external @electric-sql/pglite --external swarm-mail && bun build ./src/plugin.ts --outfile ./dist/plugin.js --target node --external @electric-sql/pglite --external swarm-mail && tsc
-Bundled 200 modules in 35ms
+Bundled 200 modules in 34ms
 
   index.js  1.20 MB  (entry point)
 
-Bundled 201 modules in 34ms
+Bundled 201 modules in 44ms
 
   plugin.js  1.16 MB  (entry point)
 

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # opencode-swarm-plugin
 
+## 0.30.0
+
+### Minor Changes
+
+- [`f3917ad`](https://github.com/joelhooks/swarm-tools/commit/f3917ad911d3c716a2470a01c66bce3500f644f4) Thanks [@joelhooks](https://github.com/joelhooks)! - ## 🐝 The Great bd CLI Purge
+
+  The `bd` CLI is officially dead. Long live HiveAdapter!
+
+  **What changed:**
+
+  ### `swarm init` Command Rewritten
+
+  - No longer shells out to `bd init` or `bd create`
+  - Uses `ensureHiveDirectory()` and `getHiveAdapter()` directly
+  - Supports `.beads` → `.hive` migration with user prompts
+  - Creates cells via HiveAdapter, not CLI
+
+  ### Auto-sync Removed from `index.ts`
+
+  - Removed `void $\`bd sync\`.quiet().nothrow()`after`hive_close`
+  - Users should call `hive_sync` explicitly at session end
+  - This was a fire-and-forget that could race with other operations
+
+  ### Plugin Template Updated
+
+  - `detectSwarm()` now has confidence levels (HIGH/MEDIUM/LOW/NONE)
+  - Added `SWARM_DETECTION_FALLBACK` for uncertain cases
+  - Compaction hook injects context based on confidence:
+    - HIGH/MEDIUM → Full swarm context
+    - LOW → Fallback detection prompt
+    - NONE → No injection
+
+  ### Error Handling Fixed
+
+  - `execTool()` now handles both string and object error formats
+  - Fixes "Tool execution failed" generic error from `swarm_complete`
+  - Actual error messages now propagate to the agent
+
+  **Why it matters:**
+
+  - No external CLI dependency for core functionality
+  - HiveAdapter is type-safe and testable
+  - Plugin works in environments without `bd` installed
+  - Better error messages for debugging
+
+  **Migration:** Run `swarm setup` to update your deployed plugin.
+
 ## 0.29.0
 
 ### Minor Changes

package/bin/swarm.test.ts

@@ -0,0 +1,163 @@
+#!/usr/bin/env bun
+/**
+ * Tests for swarm CLI file operation helpers
+ * 
+ * These tests verify the verbose output helpers used in `swarm setup`:
+ * - writeFileWithStatus: logs created/updated/unchanged status
+ * - mkdirWithStatus: logs directory creation
+ * - rmWithStatus: logs file removal
+ */
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+type FileStatus = "created" | "updated" | "unchanged";
+
+/**
+ * Mock logger for testing (matches @clack/prompts API)
+ */
+class MockLogger {
+  logs: Array<{ type: string; message: string }> = [];
+
+  success(msg: string) {
+    this.logs.push({ type: "success", message: msg });
+  }
+
+  message(msg: string) {
+    this.logs.push({ type: "message", message: msg });
+  }
+
+  reset() {
+    this.logs = [];
+  }
+}
+
+describe("File operation helpers", () => {
+  let testDir: string;
+  let logger: MockLogger;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `swarm-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+    logger = new MockLogger();
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  describe("writeFileWithStatus", () => {
+    // Helper that mimics the implementation
+    function writeFileWithStatus(path: string, content: string, label: string): FileStatus {
+      const exists = existsSync(path);
+      
+      if (exists) {
+        const current = readFileSync(path, "utf-8");
+        if (current === content) {
+          logger.message(`  ${label}: ${path} (unchanged)`);
+          return "unchanged";
+        }
+      }
+      
+      writeFileSync(path, content);
+      const status: FileStatus = exists ? "updated" : "created";
+      logger.success(`${label}: ${path} (${status})`);
+      return status;
+    }
+
+    test("returns 'created' for new file", () => {
+      const filePath = join(testDir, "new.txt");
+      const result = writeFileWithStatus(filePath, "content", "Test");
+      
+      expect(result).toBe("created");
+      expect(logger.logs[0].type).toBe("success");
+      expect(logger.logs[0].message).toContain("(created)");
+      expect(existsSync(filePath)).toBe(true);
+    });
+
+    test("returns 'unchanged' if content is same", () => {
+      const filePath = join(testDir, "existing.txt");
+      writeFileSync(filePath, "same content");
+      
+      const result = writeFileWithStatus(filePath, "same content", "Test");
+      
+      expect(result).toBe("unchanged");
+      expect(logger.logs[0].type).toBe("message");
+      expect(logger.logs[0].message).toContain("(unchanged)");
+    });
+
+    test("returns 'updated' if content differs", () => {
+      const filePath = join(testDir, "existing.txt");
+      writeFileSync(filePath, "old content");
+      
+      const result = writeFileWithStatus(filePath, "new content", "Test");
+      
+      expect(result).toBe("updated");
+      expect(logger.logs[0].type).toBe("success");
+      expect(logger.logs[0].message).toContain("(updated)");
+      expect(readFileSync(filePath, "utf-8")).toBe("new content");
+    });
+  });
+
+  describe("mkdirWithStatus", () => {
+    function mkdirWithStatus(path: string): boolean {
+      if (!existsSync(path)) {
+        mkdirSync(path, { recursive: true });
+        logger.message(`  Created directory: ${path}`);
+        return true;
+      }
+      return false;
+    }
+
+    test("creates directory and logs when it doesn't exist", () => {
+      const dirPath = join(testDir, "newdir");
+      const result = mkdirWithStatus(dirPath);
+      
+      expect(result).toBe(true);
+      expect(existsSync(dirPath)).toBe(true);
+      expect(logger.logs[0].type).toBe("message");
+      expect(logger.logs[0].message).toContain("Created directory");
+    });
+
+    test("returns false when directory already exists", () => {
+      const dirPath = join(testDir, "existing");
+      mkdirSync(dirPath);
+      
+      const result = mkdirWithStatus(dirPath);
+      
+      expect(result).toBe(false);
+      expect(logger.logs.length).toBe(0);
+    });
+  });
+
+  describe("rmWithStatus", () => {
+    function rmWithStatus(path: string, label: string): void {
+      if (existsSync(path)) {
+        rmSync(path);
+        logger.message(`  Removed ${label}: ${path}`);
+      }
+    }
+
+    test("removes file and logs when it exists", () => {
+      const filePath = join(testDir, "todelete.txt");
+      writeFileSync(filePath, "content");
+      
+      rmWithStatus(filePath, "test file");
+      
+      expect(existsSync(filePath)).toBe(false);
+      expect(logger.logs[0].type).toBe("message");
+      expect(logger.logs[0].message).toContain("Removed test file");
+    });
+
+    test("does nothing when file doesn't exist", () => {
+      const filePath = join(testDir, "nonexistent.txt");
+      
+      rmWithStatus(filePath, "test file");
+      
+      expect(logger.logs.length).toBe(0);
+    });
+  });
+});

package/bin/swarm.ts

@@ -32,6 +32,8 @@ import {
   migrateBeadsToHive,
   mergeHistoricBeads,
   importJsonlToPGLite,
+  ensureHiveDirectory,
+  getHiveAdapter,
 } from "../src/hive";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -71,6 +73,68 @@ const magenta = (s: string) => `\x1b[35m${s}\x1b[0m`;
 
 const PACKAGE_NAME = "opencode-swarm-plugin";
 
+// ============================================================================
+// File Operation Helpers
+// ============================================================================
+
+type FileStatus = "created" | "updated" | "unchanged";
+
+interface FileStats {
+  created: number;
+  updated: number;
+  unchanged: number;
+}
+
+/**
+ * Write a file with status logging (created/updated/unchanged)
+ * @param path - File path to write
+ * @param content - Content to write
+ * @param label - Label for logging (e.g., "Plugin", "Command")
+ * @returns Status of the operation
+ */
+function writeFileWithStatus(path: string, content: string, label: string): FileStatus {
+  const exists = existsSync(path);
+  
+  if (exists) {
+    const current = readFileSync(path, "utf-8");
+    if (current === content) {
+      p.log.message(dim(`  ${label}: ${path} (unchanged)`));
+      return "unchanged";
+    }
+  }
+  
+  writeFileSync(path, content);
+  const status: FileStatus = exists ? "updated" : "created";
+  p.log.success(`${label}: ${path} (${status})`);
+  return status;
+}
+
+/**
+ * Create a directory with logging
+ * @param path - Directory path to create
+ * @returns true if created, false if already exists
+ */
+function mkdirWithStatus(path: string): boolean {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+    p.log.message(dim(`  Created directory: ${path}`));
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Remove a file with logging
+ * @param path - File path to remove
+ * @param label - Label for logging
+ */
+function rmWithStatus(path: string, label: string): void {
+  if (existsSync(path)) {
+    rmSync(path);
+    p.log.message(dim(`  Removed ${label}: ${path}`));
+  }
+}
+
 // ============================================================================
 // Seasonal Messages (inspired by Astro's Houston)
 // ============================================================================
@@ -1707,39 +1771,29 @@ async function setup() {
 
   p.log.step("Setting up OpenCode integration...");
 
+  // Track file operation statistics
+  const stats: FileStats = { created: 0, updated: 0, unchanged: 0 };
+
   // Create directories if needed
   const skillsDir = join(configDir, "skills");
   for (const dir of [pluginDir, commandDir, agentDir, swarmAgentDir, skillsDir]) {
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
+    mkdirWithStatus(dir);
   }
 
-  writeFileSync(pluginPath, getPluginWrapper());
-  p.log.success("Plugin: " + pluginPath);
-
-  writeFileSync(commandPath, SWARM_COMMAND);
-  p.log.success("Command: " + commandPath);
+  // Write plugin and command files
+  stats[writeFileWithStatus(pluginPath, getPluginWrapper(), "Plugin")]++;
+  stats[writeFileWithStatus(commandPath, SWARM_COMMAND, "Command")]++;
 
   // Write nested agent files (swarm/planner.md, swarm/worker.md)
   // This is the format used by Task(subagent_type="swarm/worker")
-  writeFileSync(plannerAgentPath, getPlannerAgent(coordinatorModel as string));
-  p.log.success("Planner agent: " + plannerAgentPath);
-
-  writeFileSync(workerAgentPath, getWorkerAgent(workerModel as string));
-  p.log.success("Worker agent: " + workerAgentPath);
+  stats[writeFileWithStatus(plannerAgentPath, getPlannerAgent(coordinatorModel as string), "Planner agent")]++;
+  stats[writeFileWithStatus(workerAgentPath, getWorkerAgent(workerModel as string), "Worker agent")]++;
 
   // Clean up legacy flat agent files if they exist
-  if (existsSync(legacyPlannerPath)) {
-    rmSync(legacyPlannerPath);
-    p.log.message(dim("  Removed legacy: " + legacyPlannerPath));
-  }
-  if (existsSync(legacyWorkerPath)) {
-    rmSync(legacyWorkerPath);
-    p.log.message(dim("  Removed legacy: " + legacyWorkerPath));
-  }
+  rmWithStatus(legacyPlannerPath, "legacy planner");
+  rmWithStatus(legacyWorkerPath, "legacy worker");
 
-  p.log.success("Skills directory: " + skillsDir);
+  p.log.message(dim(`  Skills directory: ${skillsDir}`));
 
   // Show bundled skills info (and optionally sync to global skills dir)
   const bundledSkillsPath = join(__dirname, "..", "global-skills");
@@ -1850,17 +1904,29 @@ async function setup() {
     }
   }
 
+  // Show setup summary
+  const totalFiles = stats.created + stats.updated + stats.unchanged;
+  const summaryParts: string[] = [];
+  if (stats.created > 0) summaryParts.push(`${stats.created} created`);
+  if (stats.updated > 0) summaryParts.push(`${stats.updated} updated`);
+  if (stats.unchanged > 0) summaryParts.push(`${stats.unchanged} unchanged`);
+  
+  p.log.message("");
+  p.log.success(`Setup complete: ${totalFiles} files (${summaryParts.join(", ")})`);
+
   p.note(
-    'cd your-project\nbd init\nopencode\n/swarm "your task"\n\nSkills: Use skills_list to see available skills',
+    'cd your-project\nswarm init\nopencode\n/swarm "your task"\n\nSkills: Use skills_list to see available skills',
     "Next steps",
   );
 
-  p.outro("Setup complete! Run 'swarm doctor' to verify.");
+  p.outro("Run 'swarm doctor' to verify installation.");
 }
 
 async function init() {
   p.intro("swarm init v" + VERSION);
 
+  const projectPath = process.cwd();
+
   const gitDir = existsSync(".git");
   if (!gitDir) {
     p.log.error("Not in a git repository");
@@ -1869,12 +1935,15 @@ async function init() {
     process.exit(1);
   }
 
+  // Check for existing .hive or .beads directories
+  const hiveDir = existsSync(".hive");
   const beadsDir = existsSync(".beads");
-  if (beadsDir) {
-    p.log.warn("Beads already initialized in this project");
+  
+  if (hiveDir) {
+    p.log.warn("Hive already initialized in this project (.hive/ exists)");
 
     const reinit = await p.confirm({
-      message: "Re-initialize beads?",
+      message: "Continue anyway?",
       initialValue: false,
     });
 
@@ -1882,25 +1951,54 @@ async function init() {
       p.outro("Aborted");
       process.exit(0);
     }
+  } else if (beadsDir) {
+    // Offer migration from .beads to .hive
+    p.log.warn("Found legacy .beads/ directory");
+    
+    const migrate = await p.confirm({
+      message: "Migrate .beads/ to .hive/?",
+      initialValue: true,
+    });
+
+    if (!p.isCancel(migrate) && migrate) {
+      const s = p.spinner();
+      s.start("Migrating .beads/ to .hive/...");
+      
+      const result = await migrateBeadsToHive(projectPath);
+      
+      if (result.migrated) {
+        s.stop("Migration complete");
+        p.log.success("Renamed .beads/ to .hive/");
+        
+        // Merge historic beads if beads.base.jsonl exists
+        const mergeResult = await mergeHistoricBeads(projectPath);
+        if (mergeResult.merged > 0) {
+          p.log.success(`Merged ${mergeResult.merged} historic cells`);
+        }
+      } else {
+        s.stop("Migration skipped: " + result.reason);
+      }
+    }
   }
 
   const s = p.spinner();
-  s.start("Initializing beads...");
-
-  const success = await runInstall("bd init");
+  s.start("Initializing hive...");
 
-  if (success) {
-    s.stop("Beads initialized");
-    p.log.success("Created .beads/ directory");
+  try {
+    // Create .hive directory using our function (no bd CLI needed)
+    ensureHiveDirectory(projectPath);
+    
+    s.stop("Hive initialized");
+    p.log.success("Created .hive/ directory");
 
-    const createBead = await p.confirm({
-      message: "Create your first bead?",
+    const createCell = await p.confirm({
+      message: "Create your first cell?",
       initialValue: true,
     });
 
-    if (!p.isCancel(createBead) && createBead) {
+    if (!p.isCancel(createCell) && createCell) {
       const title = await p.text({
-        message: "Bead title:",
+        message: "Cell title:",
         placeholder: "Implement user authentication",
         validate: (v) => (v.length === 0 ? "Title required" : undefined),
       });
@@ -1917,17 +2015,22 @@ async function init() {
         });
 
         if (!p.isCancel(typeResult)) {
-          const beadSpinner = p.spinner();
-          beadSpinner.start("Creating bead...");
-
-          const createSuccess = await runInstall(
-            'bd create --title "' + title + '" --type ' + typeResult,
-          );
-
-          if (createSuccess) {
-            beadSpinner.stop("Bead created");
-          } else {
-            beadSpinner.stop("Failed to create bead");
+          const cellSpinner = p.spinner();
+          cellSpinner.start("Creating cell...");
+
+          try {
+            // Use HiveAdapter to create the cell (no bd CLI needed)
+            const adapter = await getHiveAdapter(projectPath);
+            const cell = await adapter.createCell(projectPath, {
+              title: title as string,
+              type: typeResult as "feature" | "bug" | "task" | "chore",
+              priority: 2,
+            });
+            
+            cellSpinner.stop("Cell created: " + cell.id);
+          } catch (error) {
+            cellSpinner.stop("Failed to create cell");
+            p.log.error(error instanceof Error ? error.message : String(error));
           }
         }
       }
@@ -1953,9 +2056,9 @@ async function init() {
     }
 
     p.outro("Project initialized! Use '/swarm' in OpenCode to get started.");
-  } else {
-    s.stop("Failed to initialize beads");
-    p.log.error("Make sure 'bd' is installed: swarm doctor");
+  } catch (error) {
+    s.stop("Failed to initialize hive");
+    p.log.error(error instanceof Error ? error.message : String(error));
     p.outro("Aborted");
     process.exit(1);
   }

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -36161,9 +36161,6 @@ var SwarmPlugin = async (input) => {
       if (toolName === "swarm_complete" && activeAgentMailState) {
         await releaseReservations();
       }
-      if (toolName === "hive_close" || toolName === "hive_close") {
-        $`bd sync`.quiet().nothrow();
-      }
     }
   };
 };

package/dist/plugin.js

@@ -35197,9 +35197,6 @@ var SwarmPlugin = async (input) => {
       if (toolName === "swarm_complete" && activeAgentMailState) {
         await releaseReservations();
       }
-      if (toolName === "hive_close" || toolName === "hive_close") {
-        $`bd sync`.quiet().nothrow();
-      }
     }
   };
 };

package/examples/plugin-wrapper-template.ts

@@ -73,7 +73,11 @@ async function execTool(
             );
           } else if (!result.success && result.error) {
             // Tool returned an error in JSON format
-            reject(new Error(result.error.message || "Tool execution failed"));
+            // Handle both string errors and object errors with .message
+            const errorMsg = typeof result.error === "string" 
+              ? result.error 
+              : (result.error.message || "Tool execution failed");
+            reject(new Error(errorMsg));
           } else {
             resolve(stdout);
           }
@@ -89,11 +93,11 @@ async function execTool(
         try {
           const result = JSON.parse(stdout);
           if (!result.success && result.error) {
-            reject(
-              new Error(
-                result.error.message || `Tool failed with code ${code}`,
-              ),
-            );
+            // Handle both string errors and object errors with .message
+            const errorMsg = typeof result.error === "string"
+              ? result.error
+              : (result.error.message || `Tool failed with code ${code}`);
+            reject(new Error(errorMsg));
           } else {
             reject(
               new Error(stderr || stdout || `Tool failed with code ${code}`),
@@ -883,15 +887,33 @@ const skills_execute = tool({
 // Compaction Hook - Swarm Recovery Context
 // =============================================================================
 
+/**
+ * Detection result with confidence level
+ */
+interface SwarmDetection {
+  detected: boolean;
+  confidence: "high" | "medium" | "low" | "none";
+  reasons: string[];
+}
+
 /**
  * Check for swarm sign - evidence a swarm passed through
  *
- * Like deer scat on a trail, we look for traces:
- * - In-progress beads (active work)
- * - Open beads with parent_id (subtasks of an epic)
- * - Unclosed epics
+ * Uses multiple signals with different confidence levels:
+ * - HIGH: in_progress cells (active work)
+ * - MEDIUM: Open subtasks, unclosed epics, recently updated cells
+ * - LOW: Any cells exist
+ *
+ * Philosophy: Err on the side of continuation.
+ * False positive = extra context (low cost)
+ * False negative = lost swarm (high cost)
  */
-async function hasSwarmSign(): Promise<boolean> {
+async function detectSwarm(): Promise<SwarmDetection> {
+  const reasons: string[] = [];
+  let highConfidence = false;
+  let mediumConfidence = false;
+  let lowConfidence = false;
+
   try {
     const result = await new Promise<{ exitCode: number; stdout: string }>(
       (resolve) => {
@@ -909,24 +931,82 @@ async function hasSwarmSign(): Promise<boolean> {
       },
     );
 
-    if (result.exitCode !== 0) return false;
+    if (result.exitCode !== 0) {
+      return { detected: false, confidence: "none", reasons: ["hive_query failed"] };
+    }
 
-    const beads = JSON.parse(result.stdout);
-    if (!Array.isArray(beads)) return false;
+    const cells = JSON.parse(result.stdout);
+    if (!Array.isArray(cells) || cells.length === 0) {
+      return { detected: false, confidence: "none", reasons: ["no cells found"] };
+    }
 
-    // Look for swarm sign:
-    // 1. Any in_progress beads
-    // 2. Any open beads with a parent (subtasks)
-    // 3. Any epics that aren't closed
-    return beads.some(
-      (b: { status: string; parent_id?: string; type?: string }) =>
-        b.status === "in_progress" ||
-        (b.status === "open" && b.parent_id) ||
-        (b.type === "epic" && b.status !== "closed"),
+    // HIGH: Any in_progress cells
+    const inProgress = cells.filter(
+      (c: { status: string }) => c.status === "in_progress"
+    );
+    if (inProgress.length > 0) {
+      highConfidence = true;
+      reasons.push(`${inProgress.length} cells in_progress`);
+    }
+
+    // MEDIUM: Open subtasks (cells with parent_id)
+    const subtasks = cells.filter(
+      (c: { status: string; parent_id?: string }) =>
+        c.status === "open" && c.parent_id
+    );
+    if (subtasks.length > 0) {
+      mediumConfidence = true;
+      reasons.push(`${subtasks.length} open subtasks`);
+    }
+
+    // MEDIUM: Unclosed epics
+    const openEpics = cells.filter(
+      (c: { status: string; type?: string }) =>
+        c.type === "epic" && c.status !== "closed"
+    );
+    if (openEpics.length > 0) {
+      mediumConfidence = true;
+      reasons.push(`${openEpics.length} unclosed epics`);
+    }
+
+    // MEDIUM: Recently updated cells (last hour)
+    const oneHourAgo = Date.now() - 60 * 60 * 1000;
+    const recentCells = cells.filter(
+      (c: { updated_at?: number }) => c.updated_at && c.updated_at > oneHourAgo
     );
+    if (recentCells.length > 0) {
+      mediumConfidence = true;
+      reasons.push(`${recentCells.length} cells updated in last hour`);
+    }
+
+    // LOW: Any cells exist at all
+    if (cells.length > 0) {
+      lowConfidence = true;
+      reasons.push(`${cells.length} total cells in hive`);
+    }
   } catch {
-    return false;
+    // Detection failed, use fallback
+    lowConfidence = true;
+    reasons.push("Detection error, using fallback");
   }
+
+  // Determine overall confidence
+  let confidence: "high" | "medium" | "low" | "none";
+  if (highConfidence) {
+    confidence = "high";
+  } else if (mediumConfidence) {
+    confidence = "medium";
+  } else if (lowConfidence) {
+    confidence = "low";
+  } else {
+    confidence = "none";
+  }
+
+  return {
+    detected: confidence !== "none",
+    confidence,
+    reasons,
+  };
 }
 
 /**
@@ -992,6 +1072,47 @@ Extract from session context:
 **You are not waiting for instructions. You are the coordinator. Coordinate.**
 `;
 
+/**
+ * Fallback detection prompt - tells the compactor what to look for
+ * 
+ * Used when we can't definitively detect a swarm but want to be safe.
+ * The compactor can check the conversation context for these patterns.
+ */
+const SWARM_DETECTION_FALLBACK = `## 🐝 Swarm Detection - Check Your Context
+
+**IMPORTANT:** Before summarizing, check if this session involves an active swarm.
+
+Look for ANY of these patterns in the conversation:
+
+### Tool Calls (definite swarm sign)
+- \`swarm_decompose\`, \`swarm_spawn_subtask\`, \`swarm_status\`, \`swarm_complete\`
+- \`swarmmail_init\`, \`swarmmail_reserve\`, \`swarmmail_send\`
+- \`hive_create_epic\`, \`hive_start\`, \`hive_close\`
+
+### IDs and Names
+- Cell IDs: \`bd-xxx\`, \`bd-xxx.N\` (subtask format)
+- Agent names: BlueLake, RedMountain, GreenValley, etc.
+- Epic references: "epic", "subtask", "parent"
+
+### Coordination Language
+- "spawn", "worker", "coordinator"
+- "reserve", "reservation", "files"
+- "blocked", "unblock", "dependency"
+- "progress", "complete", "in_progress"
+
+### If You Find Swarm Evidence
+
+Include this in your summary:
+1. Epic ID and title
+2. Project path
+3. Subtask status (running/blocked/done/pending)
+4. Any blockers or issues
+5. What should happen next
+
+**Then tell the resumed session:**
+"This is an active swarm. Check swarm_status and swarmmail_inbox immediately."
+`;
+
 // Extended hooks type to include experimental compaction hook
 type ExtendedHooks = Hooks & {
   "experimental.session.compacting"?: (
@@ -1065,15 +1186,23 @@ export const SwarmPlugin: Plugin = async (
       skills_execute,
     },
 
-    // Swarm-aware compaction hook - only fires if there's an active swarm
+    // Swarm-aware compaction hook - injects context based on detection confidence
     "experimental.session.compacting": async (
       _input: { sessionID: string },
       output: { context: string[] },
     ) => {
-      const hasSign = await hasSwarmSign();
-      if (hasSign) {
-        output.context.push(SWARM_COMPACTION_CONTEXT);
+      const detection = await detectSwarm();
+
+      if (detection.confidence === "high" || detection.confidence === "medium") {
+        // Definite or probable swarm - inject full context
+        const header = `[Swarm detected: ${detection.reasons.join(", ")}]\n\n`;
+        output.context.push(header + SWARM_COMPACTION_CONTEXT);
+      } else if (detection.confidence === "low") {
+        // Possible swarm - inject fallback detection prompt
+        const header = `[Possible swarm: ${detection.reasons.join(", ")}]\n\n`;
+        output.context.push(header + SWARM_DETECTION_FALLBACK);
       }
+      // confidence === "none" - no injection, probably not a swarm
     },
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "./dist/index.js",

package/src/index.ts

@@ -249,11 +249,9 @@ export const SwarmPlugin: Plugin = async (
         await releaseReservations();
       }
 
-      // Auto-sync hive after closing (supports both hive_close and legacy hive_close)
-      if (toolName === "hive_close" || toolName === "hive_close") {
-        // Trigger async sync without blocking - fire and forget
-        void $`bd sync`.quiet().nothrow();
-      }
+      // Note: hive_sync should be called explicitly at session end
+      // Auto-sync was removed because bd CLI is deprecated
+      // The hive_sync tool handles flushing to JSONL and git commit/push
     },
   };
 };