opencode-swarm-plugin 0.28.1 → 0.29.0

package/dist/plugin.js

@@ -27156,7 +27156,6 @@ var EpicCreateResultSchema = exports_external.object({
   subtasks: exports_external.array(CellSchema),
   rollback_hint: exports_external.string().optional()
 });
-var BeadSchema = CellSchema;
 // src/schemas/evaluation.ts
 init_zod();
 var CriterionEvaluationSchema = exports_external.object({
@@ -28015,30 +28014,30 @@ var hive_sync = tool({
 var hive_link_thread = tool({
   description: "Add metadata linking cell to Agent Mail thread",
   args: {
-    cell_id: tool.schema.string().describe("Cell ID"),
+    bead_id: tool.schema.string().describe("Cell ID"),
     thread_id: tool.schema.string().describe("Agent Mail thread ID")
   },
   async execute(args, ctx) {
     const projectKey = getHiveWorkingDirectory();
     const adapter = await getHiveAdapter(projectKey);
     try {
-      const cell = await adapter.getCell(projectKey, args.cell_id);
+      const cell = await adapter.getCell(projectKey, args.bead_id);
       if (!cell) {
-        throw new HiveError(`Cell not found: ${args.cell_id}`, "hive_link_thread");
+        throw new HiveError(`Cell not found: ${args.bead_id}`, "hive_link_thread");
       }
       const existingDesc = cell.description || "";
       const threadMarker = `[thread:${args.thread_id}]`;
       if (existingDesc.includes(threadMarker)) {
-        return `Cell ${args.cell_id} already linked to thread ${args.thread_id}`;
+        return `Cell ${args.bead_id} already linked to thread ${args.thread_id}`;
       }
       const newDesc = existingDesc ? `${existingDesc}
 
 ${threadMarker}` : threadMarker;
-      await adapter.updateCell(projectKey, args.cell_id, {
+      await adapter.updateCell(projectKey, args.bead_id, {
         description: newDesc
       });
-      await adapter.markDirty(projectKey, args.cell_id);
-      return `Linked cell ${args.cell_id} to thread ${args.thread_id}`;
+      await adapter.markDirty(projectKey, args.bead_id);
+      return `Linked cell ${args.bead_id} to thread ${args.thread_id}`;
     } catch (error45) {
       const message = error45 instanceof Error ? error45.message : String(error45);
       throw new HiveError(`Failed to link thread: ${message}`, "hive_link_thread");
@@ -28269,27 +28268,11 @@ var toolCheckers = {
     }
   },
   beads: async () => {
-    const exists = await commandExists("bd");
-    if (!exists) {
-      return {
-        available: false,
-        checkedAt: new Date().toISOString(),
-        error: "bd command not found"
-      };
-    }
-    try {
-      const result = await Bun.$`bd --version`.quiet().nothrow();
-      return {
-        available: result.exitCode === 0,
-        checkedAt: new Date().toISOString()
-      };
-    } catch (e) {
-      return {
-        available: false,
-        checkedAt: new Date().toISOString(),
-        error: String(e)
-      };
-    }
+    return {
+      available: false,
+      checkedAt: new Date().toISOString(),
+      error: "bd CLI is deprecated - use hive_* tools with HiveAdapter instead"
+    };
   },
   "swarm-mail": async () => {
     try {
@@ -32263,27 +32246,25 @@ var reviewTools = {
 };
 
 // src/swarm-orchestrate.ts
-async function queryEpicSubtasks(epicId) {
-  const beadsAvailable = await isToolAvailable("beads");
-  if (!beadsAvailable) {
-    warnMissingTool("beads");
-    return [];
-  }
-  const result = await Bun.$`bd list --parent ${epicId} --json`.quiet().nothrow();
-  if (result.exitCode !== 0) {
-    console.error(`[swarm] ERROR: Failed to query subtasks for epic ${epicId}:`, result.stderr.toString());
-    return [];
-  }
+async function queryEpicSubtasks(projectKey, epicId) {
   try {
-    const parsed = JSON.parse(result.stdout.toString());
-    return exports_external.array(BeadSchema).parse(parsed);
+    const adapter = await getHiveAdapter(projectKey);
+    const cells = await adapter.queryCells(projectKey, { parent_id: epicId });
+    return cells.filter((cell) => cell.status !== "tombstone").map((cell) => ({
+      id: cell.id,
+      title: cell.title,
+      description: cell.description || "",
+      status: cell.status,
+      priority: cell.priority,
+      issue_type: cell.type,
+      created_at: new Date(cell.created_at).toISOString(),
+      updated_at: cell.updated_at ? new Date(cell.updated_at).toISOString() : undefined,
+      dependencies: [],
+      metadata: {}
+    }));
   } catch (error45) {
-    if (error45 instanceof exports_external.ZodError) {
-      console.error(`[swarm] ERROR: Invalid bead data for epic ${epicId}:`, error45.message);
-      return [];
-    }
-    console.error(`[swarm] ERROR: Failed to parse beads for epic ${epicId}:`, error45);
-    throw error45;
+    console.error(`[swarm] ERROR: Failed to query subtasks for epic ${epicId}:`, error45 instanceof Error ? error45.message : String(error45));
+    return [];
   }
 }
 async function querySwarmMessages(projectKey, threadId) {
@@ -32635,7 +32616,7 @@ var swarm_status = tool({
     project_key: tool.schema.string().describe("Project path (for Agent Mail queries)")
   },
   async execute(args) {
-    const subtasks = await queryEpicSubtasks(args.epic_id);
+    const subtasks = await queryEpicSubtasks(args.project_key, args.epic_id);
     const statusCounts = {
       running: 0,
       completed: 0,
@@ -32710,8 +32691,13 @@ var swarm_progress = tool({
     };
     const validated = AgentProgressSchema.parse(progress);
     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 (error45) {
+        console.error(`[swarm] Failed to update cell status: ${error45 instanceof Error ? error45.message : String(error45)}`);
+      }
     }
     const epicId = args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id;
     await sendSwarmMessage3({
@@ -32855,6 +32841,22 @@ Or use skip_review=true to bypass (not recommended for production work).`
     }
     try {
       const projectKey = args.project_key.replace(/\//g, "-").replace(/\\/g, "-");
+      const adapter = await getHiveAdapter(args.project_key);
+      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."
+        });
+      }
+      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."
+        });
+      }
       let agentRegistered = false;
       let registrationWarning = "";
       try {
@@ -32939,32 +32941,25 @@ Continuing with completion, but this should be fixed for future subtasks.`;
           }, null, 2);
         }
       }
-      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();
-        const isNoDatabaseError = stderrOutput.includes("no beads database found");
-        const isNotFoundError = stderrOutput.includes("not found") || stderrOutput.includes("does not exist");
+      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()`,
+            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: 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."
+            hint: "Cell may already be closed, or the ID is incorrect."
           }
         }, null, 2);
       }
@@ -33165,12 +33160,13 @@ ${errorStack.slice(0, 1000)}
       }
       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 || [],
@@ -35105,6 +35101,11 @@ var sessionStats = {
 
 // src/index.ts
 init_skills();
+
+// src/compaction-hook.ts
+import { checkSwarmHealth as checkSwarmHealth3 } from "swarm-mail";
+
+// src/index.ts
 var SwarmPlugin = async (input) => {
   const { $, directory } = input;
   setHiveWorkingDirectory(directory);

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.1",
+  "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.3",
+    "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
   };
 }