opencode-swarm-plugin 0.28.1 → 0.29.0

package/src/hive.integration.test.ts

@@ -521,7 +521,7 @@ describe("beads integration", () => {
     it("links a bead to an Agent Mail thread", async () => {
       const threadId = "test-thread-123";
       const result = await beads_link_thread.execute(
-        { cell_id: testBeadId, thread_id: threadId },
+        { bead_id: testBeadId, thread_id: threadId },
         mockContext,
       );
 
@@ -540,13 +540,13 @@ describe("beads integration", () => {
 
       // Link once
       await beads_link_thread.execute(
-        { cell_id: testBeadId, thread_id: threadId },
+        { bead_id: testBeadId, thread_id: threadId },
         mockContext,
       );
 
       // Try to link again
       const result = await beads_link_thread.execute(
-        { cell_id: testBeadId, thread_id: threadId },
+        { bead_id: testBeadId, thread_id: threadId },
         mockContext,
       );
 
@@ -562,7 +562,7 @@ describe("beads integration", () => {
 
       const threadId = "test-thread-789";
       await beads_link_thread.execute(
-        { cell_id: testBeadId, thread_id: threadId },
+        { bead_id: testBeadId, thread_id: threadId },
         mockContext,
       );
 
@@ -576,7 +576,7 @@ describe("beads integration", () => {
     it("throws BeadError for invalid bead ID", async () => {
       await expect(
         beads_link_thread.execute(
-          { cell_id: "nonexistent-bead-xyz", thread_id: "thread-123" },
+          { bead_id: "nonexistent-bead-xyz", thread_id: "thread-123" },
           mockContext,
         ),
       ).rejects.toThrow(BeadError);

package/src/hive.ts

@@ -1094,7 +1094,7 @@ export const hive_sync = tool({
 export const 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) {
@@ -1102,11 +1102,11 @@ export const hive_link_thread = tool({
     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}`,
+          `Cell not found: ${args.bead_id}`,
           "hive_link_thread",
         );
       }
@@ -1115,20 +1115,20 @@ export const hive_link_thread = tool({
       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}\n\n${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);
+      await adapter.markDirty(projectKey, args.bead_id);
 
-      return `Linked cell ${args.cell_id} to thread ${args.thread_id}`;
+      return `Linked cell ${args.bead_id} to thread ${args.thread_id}`;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       throw new HiveError(

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 || [],

package/src/swarm.integration.test.ts

@@ -1085,7 +1085,7 @@ describe("Tool Availability", () => {
 
   it("checks all tools at once", async () => {
     const availability = await checkAllTools();
-    expect(availability.size).toBe(6); // semantic-memory, cass, ubs, beads, swarm-mail, agent-mail
+    expect(availability.size).toBe(7); // semantic-memory, cass, ubs, hive, beads, swarm-mail, agent-mail
     expect(availability.has("semantic-memory")).toBe(true);
     expect(availability.has("cass")).toBe(true);
     expect(availability.has("ubs")).toBe(true);
@@ -1420,7 +1420,7 @@ describe("Swarm Prompt V2 (with Swarm Mail/Beads)", () => {
     it("enforces swarm_complete over manual hive_close", () => {
       // Step 9: Use swarm_complete, not hive_close
       expect(SUBTASK_PROMPT_V2).toContain("swarm_complete");
-      expect(SUBTASK_PROMPT_V2).toContain("DO NOT manually close the bead");
+      expect(SUBTASK_PROMPT_V2).toContain("DO NOT manually close the cell");
       expect(SUBTASK_PROMPT_V2).toContain("Use swarm_complete");
     });
   });
@@ -1583,6 +1583,92 @@ describe("Swarm Prompt V2 (with Swarm Mail/Beads)", () => {
       },
     );
 
+    it.skipIf(!beadsAvailable)(
+      "returns specific error message when bead_id not found",
+      async () => {
+        // Try to complete with a non-existent bead ID
+        const result = await swarm_complete.execute(
+          {
+            project_key: "/tmp/test-bead-not-found",
+            agent_name: "test-agent",
+            bead_id: "bd-totally-fake-xyz123",
+            summary: "This should fail with specific error",
+            skip_verification: true,
+          },
+          mockContext,
+        );
+
+        const parsed = JSON.parse(result);
+
+        // Should return structured error with specific message
+        expect(parsed.success).toBe(false);
+        expect(parsed.error).toBeDefined();
+        // RED: This will fail - we currently get generic "Tool execution failed"
+        // We want the error message to specifically mention the bead was not found
+        expect(
+          parsed.error.toLowerCase().includes("bead not found") ||
+            parsed.error.toLowerCase().includes("not found"),
+        ).toBe(true);
+        expect(parsed.bead_id).toBe("bd-totally-fake-xyz123");
+      },
+    );
+
+    it.skipIf(!beadsAvailable)(
+      "returns specific error when project_key is invalid/mismatched",
+      async () => {
+        // Create a real bead first
+        const createResult =
+          await Bun.$`bd create "Test project mismatch" -t task --json`
+            .quiet()
+            .nothrow();
+
+        if (createResult.exitCode !== 0) {
+          console.warn(
+            "Could not create bead:",
+            createResult.stderr.toString(),
+          );
+          return;
+        }
+
+        const bead = JSON.parse(createResult.stdout.toString());
+
+        try {
+          // Try to complete with mismatched project_key
+          const result = await swarm_complete.execute(
+            {
+              project_key: "/totally/wrong/project/path",
+              agent_name: "test-agent",
+              bead_id: bead.id,
+              summary: "This should fail with project mismatch",
+              skip_verification: true,
+            },
+            mockContext,
+          );
+
+          const parsed = JSON.parse(result);
+
+          // Should return structured error with specific message about project mismatch
+          expect(parsed.success).toBe(false);
+          expect(parsed.error).toBeDefined();
+          // RED: This will fail - we want specific validation error
+          // Error should mention project mismatch or validation failure
+          const errorLower = parsed.error.toLowerCase();
+          expect(
+            (errorLower.includes("project") &&
+              (errorLower.includes("mismatch") ||
+                errorLower.includes("invalid") ||
+                errorLower.includes("not found"))) ||
+              errorLower.includes("validation"),
+          ).toBe(true);
+        } finally {
+          // Clean up
+          await Bun.$`bd close ${bead.id} --reason "Test cleanup"`
+            .quiet()
+            .nothrow();
+        }
+      },
+    );
+
     it.skipIf(!beadsAvailable)(
       "includes message_sent status in response",
       async () => {

package/src/tool-availability.ts

@@ -214,31 +214,13 @@ const toolCheckers: Record<ToolName, () => Promise<ToolStatus>> = {
   },
 
   // DEPRECATED: Use hive instead
-  // Kept for backward compatibility only
+  // bd CLI is deprecated - always return false, use HiveAdapter instead
   beads: async () => {
-    const exists = await commandExists("bd");
-    if (!exists) {
-      return {
-        available: false,
-        checkedAt: new Date().toISOString(),
-        error: "bd command not found",
-      };
-    }
-
-    try {
-      // Just check if bd can run - don't require a repo
-      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 () => {