opencode-swarm-plugin 0.28.2 → 0.30.0

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.28.2",
+  "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",
@@ -34,7 +34,7 @@
     "@opencode-ai/plugin": "^1.0.134",
     "gray-matter": "^4.0.3",
     "ioredis": "^5.4.1",
-    "swarm-mail": "0.3.4",
+    "swarm-mail": "0.4.0",
     "zod": "4.1.8"
   },
   "devDependencies": {

package/src/compaction-hook.test.ts

@@ -0,0 +1,110 @@
+/**
+ * Tests for Swarm-Aware Compaction Hook
+ */
+
+import { describe, expect, it, mock } from "bun:test";
+import {
+  SWARM_COMPACTION_CONTEXT,
+  SWARM_DETECTION_FALLBACK,
+  createCompactionHook,
+} from "./compaction-hook";
+
+// Mock the dependencies
+mock.module("./hive", () => ({
+  getHiveWorkingDirectory: () => "/test/project",
+  getHiveAdapter: async () => ({
+    queryCells: async () => [],
+  }),
+}));
+
+mock.module("swarm-mail", () => ({
+  checkSwarmHealth: async () => ({
+    healthy: true,
+    database: "connected",
+    stats: {
+      events: 0,
+      agents: 0,
+      messages: 0,
+      reservations: 0,
+    },
+  }),
+}));
+
+describe("Compaction Hook", () => {
+  describe("SWARM_COMPACTION_CONTEXT", () => {
+    it("contains coordinator instructions", () => {
+      expect(SWARM_COMPACTION_CONTEXT).toContain("COORDINATOR");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("Keep Cooking");
+    });
+
+    it("contains resume instructions", () => {
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarm_status");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarmmail_inbox");
+    });
+
+    it("contains summary format", () => {
+      expect(SWARM_COMPACTION_CONTEXT).toContain("Swarm State");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("Active:");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("Blocked:");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("Completed:");
+    });
+  });
+
+  describe("SWARM_DETECTION_FALLBACK", () => {
+    it("contains detection patterns", () => {
+      expect(SWARM_DETECTION_FALLBACK).toContain("swarm_decompose");
+      expect(SWARM_DETECTION_FALLBACK).toContain("swarmmail_init");
+      expect(SWARM_DETECTION_FALLBACK).toContain("hive_create_epic");
+    });
+
+    it("contains ID patterns", () => {
+      expect(SWARM_DETECTION_FALLBACK).toContain("bd-xxx");
+      expect(SWARM_DETECTION_FALLBACK).toContain("Agent names");
+    });
+
+    it("contains coordination language", () => {
+      expect(SWARM_DETECTION_FALLBACK).toContain("spawn");
+      expect(SWARM_DETECTION_FALLBACK).toContain("coordinator");
+      expect(SWARM_DETECTION_FALLBACK).toContain("reservation");
+    });
+  });
+
+  describe("createCompactionHook", () => {
+    it("returns a function", () => {
+      const hook = createCompactionHook();
+      expect(typeof hook).toBe("function");
+    });
+
+    it("accepts input and output parameters", async () => {
+      const hook = createCompactionHook();
+      const input = { sessionID: "test-session" };
+      const output = { context: [] as string[] };
+
+      // Should not throw
+      await hook(input, output);
+    });
+
+    it("does not inject context when no swarm detected", async () => {
+      const hook = createCompactionHook();
+      const output = { context: [] as string[] };
+
+      await hook({ sessionID: "test" }, output);
+
+      // With mocked empty data, should not inject
+      expect(output.context.length).toBe(0);
+    });
+  });
+
+  describe("Detection confidence levels", () => {
+    it("HIGH confidence triggers full context", async () => {
+      // This would need proper mocking of active reservations
+      // For now, just verify the context strings exist
+      expect(SWARM_COMPACTION_CONTEXT).toContain("SWARM ACTIVE");
+    });
+
+    it("LOW confidence triggers fallback prompt", async () => {
+      expect(SWARM_DETECTION_FALLBACK).toContain("Swarm Detection");
+      expect(SWARM_DETECTION_FALLBACK).toContain("Check Your Context");
+    });
+  });
+});

package/src/compaction-hook.ts

@@ -5,6 +5,12 @@
  * When context is compacted, this hook injects instructions for the summarizer
  * to preserve swarm coordination state and enable seamless resumption.
  *
+ * ## Philosophy: Err on the Side of Continuation
+ * 
+ * It's better to inject swarm context unnecessarily than to lose an active swarm.
+ * The cost of a false positive (extra context) is low.
+ * The cost of a false negative (lost swarm) is high - wasted work, confused agents.
+ *
  * Hook signature (from @opencode-ai/plugin):
  * ```typescript
  * "experimental.session.compacting"?: (
@@ -23,6 +29,9 @@
  * ```
  */
 
+import { getHiveAdapter, getHiveWorkingDirectory } from "./hive";
+import { checkSwarmHealth } from "swarm-mail";
+
 // ============================================================================
 // Compaction Context
 // ============================================================================
@@ -93,50 +102,187 @@ 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.
+ */
+export 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."
+`;
+
 // ============================================================================
-// Hook Registration Helper
+// Swarm Detection
 // ============================================================================
 
+/**
+ * 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 cells (active work)
- * - Open cells with parent_id (subtasks of an epic)
- * - Unclosed epics
+ * Uses multiple signals with different confidence levels:
+ * - HIGH: Active reservations, in_progress cells
+ * - MEDIUM: Open subtasks, unclosed epics, recent activity
+ * - LOW: Any cells exist, swarm-mail initialized
  * 
- * Uses the adapter directly to query beads.
+ * Philosophy: Err on the side of continuation.
  */
-import { getHiveAdapter, getHiveWorkingDirectory } from "./hive";
+async function detectSwarm(): Promise<SwarmDetection> {
+  const reasons: string[] = [];
+  let highConfidence = false;
+  let mediumConfidence = false;
+  let lowConfidence = false;
 
-async function hasSwarmSign(): Promise<boolean> {
   try {
     const projectKey = getHiveWorkingDirectory();
-    const adapter = await getHiveAdapter(projectKey);
-    const cells = await adapter.queryCells(projectKey, {});
-    
-    if (!Array.isArray(cells)) return false;
-
-    // Look for swarm sign:
-    // 1. Any in_progress cells
-    // 2. Any open cells with a parent (subtasks)
-    // 3. Any epics that aren't closed
-    return cells.some(
-      (c) =>
-        c.status === "in_progress" ||
-        (c.status === "open" && c.parent_id) ||
-        (c.type === "epic" && c.status !== "closed"),
-    );
+
+    // Check 1: Active reservations in swarm-mail (HIGH confidence)
+    try {
+      const health = await checkSwarmHealth(projectKey);
+      if (health.healthy && health.stats) {
+        if (health.stats.reservations > 0) {
+          highConfidence = true;
+          reasons.push(`${health.stats.reservations} active file reservations`);
+        }
+        if (health.stats.agents > 0) {
+          mediumConfidence = true;
+          reasons.push(`${health.stats.agents} registered agents`);
+        }
+        if (health.stats.messages > 0) {
+          lowConfidence = true;
+          reasons.push(`${health.stats.messages} swarm messages`);
+        }
+      }
+    } catch {
+      // Swarm-mail not available, continue with other checks
+    }
+
+    // Check 2: Hive cells (various confidence levels)
+    try {
+      const adapter = await getHiveAdapter(projectKey);
+      const cells = await adapter.queryCells(projectKey, {});
+
+      if (Array.isArray(cells) && cells.length > 0) {
+        // HIGH: Any in_progress cells
+        const inProgress = cells.filter((c) => 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) => 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) => 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) => 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 {
+      // Hive not available, continue
+    }
   } catch {
-    return false;
+    // Project detection failed, use fallback
+    lowConfidence = true;
+    reasons.push("Could not detect project, 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,
+  };
 }
 
+// ============================================================================
+// Hook Registration
+// ============================================================================
+
 /**
  * Create the compaction hook for use in plugin registration
  *
- * Only injects swarm context if there's an active swarm (in-progress beads).
- * This keeps the coordinator cooking after compaction.
+ * Injects swarm context based on detection confidence:
+ * - HIGH/MEDIUM: Full swarm context (definitely/probably a swarm)
+ * - LOW: Fallback detection prompt (let compactor check context)
+ * - NONE: No injection (probably not a swarm)
+ *
+ * Philosophy: Err on the side of continuation. A false positive costs
+ * a bit of context space. A false negative loses the swarm.
  *
  * @example
  * ```typescript
@@ -153,9 +299,17 @@ export function createCompactionHook() {
     _input: { sessionID: string },
     output: { context: string[] },
   ): Promise<void> => {
-    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/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
     },
   };
 };

package/src/learning.integration.test.ts

@@ -1572,7 +1572,13 @@ describe("3-Strike Detection", () => {
         "Failed 1",
         storage,
       );
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      // Capture the timestamps from first strike
+      const firstStrikeAt = record1.first_strike_at;
+      const firstLastStrikeAt = record1.last_strike_at;
+      
+      // Wait to ensure different timestamp
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      
       const record2 = await addStrike(
         "test-bead-4",
         "Fix 2",
@@ -1580,8 +1586,10 @@ describe("3-Strike Detection", () => {
         storage,
       );
 
-      expect(record2.first_strike_at).toBe(record1.first_strike_at);
-      expect(record2.last_strike_at).not.toBe(record1.last_strike_at);
+      // first_strike_at should be preserved from first call
+      expect(record2.first_strike_at).toBe(firstStrikeAt);
+      // last_strike_at should be updated (different from first call's last_strike_at)
+      expect(record2.last_strike_at).not.toBe(firstLastStrikeAt);
     });
   });