opencode-swarm-plugin 0.28.2 → 0.29.0

package/dist/swarm-orchestrate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swarm-orchestrate.d.ts","sourceRoot":"","sources":["../src/swarm-orchestrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwiBxB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;CA8JrB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;CAoFvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;CA8GzB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;CA6E1B,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAknBzB,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkJ/B,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;CA6CjC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;CAmClC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;CAmB9B,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;CAoJ9B,CAAC;AA4BH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqG3B,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;CAsGxB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgMtB,CAAC;AAMH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAc5B,CAAC"}
+{"version":3,"file":"swarm-orchestrate.d.ts","sourceRoot":"","sources":["../src/swarm-orchestrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA8hBxB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;CA8JrB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;CAoFvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;CAkHzB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;CA6E1B,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqnBzB,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkJ/B,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;CA6CjC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;CAmClC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;CAmB9B,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;CAoJ9B,CAAC;AA4BH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqG3B,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;CAsGxB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgMtB,CAAC;AAMH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAc5B,CAAC"}

package/dist/tool-availability.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-availability.d.ts","sourceRoot":"","sources":["../src/tool-availability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAUH,MAAM,MAAM,QAAQ,GAChB,iBAAiB,GACjB,MAAM,GACN,KAAK,GACL,MAAM,GACN,OAAO,GACP,YAAY,GACZ,YAAY,CAAC;AAEjB,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,UAAU,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AA+PD;;;;;GAKG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,CAWnE;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAGtE;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,gBAAgB,CAAC,CAO3B;AAED;;GAEG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAC5C,GAAG,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAChC,CA0BA;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAQpD;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAO/D;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACxB,QAAQ,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAC7B,OAAO,CAAC,CAAC,CAAC,CASZ;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,CAAC,EACrC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACvB,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CASxB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAGrC;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,GAAG,CAAC,QAAQ,EAAE,gBAAgB,CAAC,GAC5C,MAAM,CAWR"}
+{"version":3,"file":"tool-availability.d.ts","sourceRoot":"","sources":["../src/tool-availability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAUH,MAAM,MAAM,QAAQ,GAChB,iBAAiB,GACjB,MAAM,GACN,KAAK,GACL,MAAM,GACN,OAAO,GACP,YAAY,GACZ,YAAY,CAAC;AAEjB,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,UAAU,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AA6OD;;;;;GAKG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,CAWnE;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAGtE;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,gBAAgB,CAAC,CAO3B;AAED;;GAEG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAC5C,GAAG,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAChC,CA0BA;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAQpD;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAO/D;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACxB,QAAQ,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAC7B,OAAO,CAAC,CAAC,CAAC,CASZ;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,CAAC,EACrC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACvB,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CASxB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAGrC;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,GAAG,CAAC,QAAQ,EAAE,gBAAgB,CAAC,GAC5C,MAAM,CAWR"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.28.2",
+  "version": "0.29.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/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);
     });
   });
 

package/src/swarm-orchestrate.ts

@@ -67,6 +67,7 @@ import {
   isToolAvailable,
   warnMissingTool,
 } from "./tool-availability";
+import { getHiveAdapter } from "./hive";
 import { listSkills } from "./skills";
 import {
   canUseWorktreeIsolation,
@@ -82,45 +83,34 @@ import {
 // ============================================================================
 
 /**
- * Query beads for subtasks of an epic
+ * Query beads for subtasks of an epic using HiveAdapter (not bd CLI)
  */
-async function queryEpicSubtasks(epicId: string): Promise<Bead[]> {
-  // Check if beads is available
-  const beadsAvailable = await isToolAvailable("beads");
-  if (!beadsAvailable) {
-    warnMissingTool("beads");
-    return []; // Return empty - swarm can still function without status tracking
-  }
-
-  const result = await Bun.$`bd list --parent ${epicId} --json`
-    .quiet()
-    .nothrow();
-
-  if (result.exitCode !== 0) {
-    // Don't throw - just return empty and log error prominently
-    console.error(
-      `[swarm] ERROR: Failed to query subtasks for epic ${epicId}:`,
-      result.stderr.toString(),
-    );
-    return [];
-  }
-
+async function queryEpicSubtasks(projectKey: string, epicId: string): Promise<Bead[]> {
   try {
-    const parsed = JSON.parse(result.stdout.toString());
-    return z.array(BeadSchema).parse(parsed);
+    const adapter = await getHiveAdapter(projectKey);
+    const cells = await adapter.queryCells(projectKey, { parent_id: epicId });
+    // Map Cell (from HiveAdapter) to Bead schema format
+    // Cell uses `type` and numeric timestamps, Bead uses `issue_type` and ISO strings
+    return cells
+      .filter(cell => cell.status !== "tombstone") // Exclude deleted cells
+      .map(cell => ({
+        id: cell.id,
+        title: cell.title,
+        description: cell.description || "",
+        status: cell.status as "open" | "in_progress" | "blocked" | "closed",
+        priority: cell.priority,
+        issue_type: cell.type as "bug" | "feature" | "task" | "epic" | "chore",
+        created_at: new Date(cell.created_at).toISOString(),
+        updated_at: cell.updated_at ? new Date(cell.updated_at).toISOString() : undefined,
+        dependencies: [], // Dependencies fetched separately if needed
+        metadata: {},
+      }));
   } catch (error) {
-    if (error instanceof z.ZodError) {
-      console.error(
-        `[swarm] ERROR: Invalid bead data for epic ${epicId}:`,
-        error.message,
-      );
-      return [];
-    }
     console.error(
-      `[swarm] ERROR: Failed to parse beads for epic ${epicId}:`,
-      error,
+      `[swarm] ERROR: Failed to query subtasks for epic ${epicId}:`,
+      error instanceof Error ? error.message : String(error),
     );
-    throw error;
+    return [];
   }
 }
 
@@ -758,7 +748,7 @@ export const swarm_status = tool({
   },
   async execute(args) {
     // Query subtasks from beads
-    const subtasks = await queryEpicSubtasks(args.epic_id);
+    const subtasks = await queryEpicSubtasks(args.project_key, args.epic_id);
 
     // Count statuses
     const statusCounts = {
@@ -878,12 +868,16 @@ export const swarm_progress = tool({
     // Validate
     const validated = AgentProgressSchema.parse(progress);
 
-    // Update cell status if needed
+    // Update cell status if needed (using HiveAdapter, not bd CLI)
     if (args.status === "blocked" || args.status === "in_progress") {
-      const beadStatus = args.status === "blocked" ? "blocked" : "in_progress";
-      await Bun.$`bd update ${args.bead_id} --status ${beadStatus} --json`
-        .quiet()
-        .nothrow();
+      try {
+        const adapter = await getHiveAdapter(args.project_key);
+        const newStatus = args.status === "blocked" ? "blocked" : "in_progress";
+        await adapter.changeCellStatus(args.project_key, args.bead_id, newStatus);
+      } catch (error) {
+        // Non-fatal - log but continue
+        console.error(`[swarm] Failed to update cell status: ${error instanceof Error ? error.message : String(error)}`);
+      }
     }
 
     // Extract epic ID from bead ID (e.g., bd-abc123.1 -> bd-abc123)
@@ -1152,11 +1146,35 @@ Or use skip_review=true to bypass (not recommended for production work).`,
     }
 
     try {
-      // Verify agent is registered in swarm-mail
-      // This catches agents who skipped swarmmail_init
+      // Validate bead_id exists and is not already closed (EARLY validation)
       const projectKey = args.project_key
         .replace(/\//g, "-")
         .replace(/\\/g, "-");
+
+      // Use HiveAdapter for validation (not bd CLI)
+      const adapter = await getHiveAdapter(args.project_key);
+
+      // 1. Check if bead exists
+      const cell = await adapter.getCell(projectKey, args.bead_id);
+      if (!cell) {
+        return JSON.stringify({
+          success: false,
+          error: `Bead not found: ${args.bead_id}`,
+          hint: "Check the bead ID is correct. Use hive_query to list open cells.",
+        });
+      }
+
+      // 2. Check if bead is already closed
+      if (cell.status === "closed") {
+        return JSON.stringify({
+          success: false,
+          error: `Bead already closed: ${args.bead_id}`,
+          hint: "This bead was already completed. No action needed.",
+        });
+      }
+
+      // Verify agent is registered in swarm-mail
+      // This catches agents who skipped swarmmail_init
       let agentRegistered = false;
       let registrationWarning = "";
 
@@ -1303,49 +1321,27 @@ Continuing with completion, but this should be fixed for future subtasks.`;
         }
       }
 
-      // Close the cell - use project_key as working directory to find correct .beads/
-      // This fixes the issue where cell ID prefix (e.g., "pdf-library-g84.2") doesn't match CWD
-      const closeResult =
-        await Bun.$`bd close ${args.bead_id} --reason ${args.summary} --json`
-          .cwd(args.project_key)
-          .quiet()
-          .nothrow();
-
-      if (closeResult.exitCode !== 0) {
-        const stderrOutput = closeResult.stderr.toString().trim();
-        const stdoutOutput = closeResult.stdout.toString().trim();
-
-        // Check for common error patterns and provide better guidance
-        const isNoDatabaseError = stderrOutput.includes("no beads database found");
-        const isNotFoundError = stderrOutput.includes("not found") || stderrOutput.includes("does not exist");
-
+      // Close the cell using HiveAdapter (not bd CLI)
+      try {
+        await adapter.closeCell(args.project_key, args.bead_id, args.summary);
+      } catch (closeError) {
+        const errorMessage = closeError instanceof Error ? closeError.message : String(closeError);
         return JSON.stringify(
           {
             success: false,
             error: "Failed to close cell",
-            failed_step: "bd close",
-            details: stderrOutput || stdoutOutput || "Unknown error from bd close command",
+            failed_step: "closeCell",
+            details: errorMessage,
             bead_id: args.bead_id,
             project_key: args.project_key,
             recovery: {
-              steps: isNoDatabaseError
-                ? [
-                    `1. Verify project_key is correct: "${args.project_key}"`,
-                    `2. Check .beads/ exists in that directory`,
-                    `3. Cell ID prefix "${args.bead_id.split("-")[0]}" should match project`,
-                    `4. Try: hive_close(id="${args.bead_id}", reason="...")`,
-                  ]
-                : [
-                    `1. Check cell exists: bd show ${args.bead_id}`,
-                    `2. Check cell status (might already be closed): hive_query()`,
-                    `3. If cell is blocked, unblock first: hive_update(id="${args.bead_id}", status="in_progress")`,
-                    `4. Try closing directly: hive_close(id="${args.bead_id}", reason="...")`,
-                  ],
-              hint: isNoDatabaseError
-                ? `The project_key "${args.project_key}" doesn't have a .beads/ directory. Make sure you're using the correct project path.`
-                : isNotFoundError
-                  ? `Cell "${args.bead_id}" not found. It may have been closed already or the ID is incorrect.`
-                  : "If cell is in 'blocked' status, you must change it to 'in_progress' or 'open' before closing.",
+              steps: [
+                `1. Check cell exists: hive_query()`,
+                `2. Check cell status (might already be closed)`,
+                `3. If cell is blocked, unblock first: hive_update(id="${args.bead_id}", status="in_progress")`,
+                `4. Try closing directly: hive_close(id="${args.bead_id}", reason="...")`,
+              ],
+              hint: "Cell may already be closed, or the ID is incorrect.",
             },
           },
           null,
@@ -1645,12 +1641,13 @@ Files touched: ${args.files_touched?.join(", ") || "none recorded"}`,
       return JSON.stringify(
         {
           success: false,
-          error: errorMessage,
+          error: `swarm_complete failed: ${errorMessage}`,
           failed_step: failedStep,
           bead_id: args.bead_id,
           agent_name: args.agent_name,
           coordinator_notified: notificationSent,
           stack_trace: errorStack?.slice(0, 500),
+          hint: "Check the error message above. Common issues: bead not found, session not initialized.",
           context: {
             summary: args.summary,
             files_touched: args.files_touched || [],