opencode-swarm-plugin 0.25.2 → 0.26.0

package/src/index.ts

@@ -121,9 +121,6 @@ export const SwarmPlugin: Plugin = async (
       });
 
       if (response.ok) {
-        console.log(
-          `[swarm-plugin] Auto-released ${activeAgentMailState.reservations.length} file reservation(s)`,
-        );
         activeAgentMailState.reservations = [];
       }
     } catch (error) {
@@ -202,9 +199,6 @@ export const SwarmPlugin: Plugin = async (
         const guardrailResult = guardrailOutput(toolName, output.output);
         if (guardrailResult.truncated) {
           output.output = guardrailResult.output;
-          console.log(
-            `[swarm-plugin] Guardrail truncated ${toolName}: ${guardrailResult.originalLength} → ${guardrailResult.truncatedLength} chars`,
-          );
         }
       }
 
@@ -242,20 +236,12 @@ export const SwarmPlugin: Plugin = async (
       // Auto-release after swarm:complete
       if (toolName === "swarm_complete" && activeAgentMailState) {
         await releaseReservations();
-        console.log(
-          "[swarm-plugin] Auto-released reservations after swarm:complete",
-        );
       }
 
       // Auto-sync beads after closing
       if (toolName === "beads_close") {
         // Trigger async sync without blocking - fire and forget
-        void $`bd sync`
-          .quiet()
-          .nothrow()
-          .then(() => {
-            console.log("[swarm-plugin] Auto-synced beads after close");
-          });
+        void $`bd sync`.quiet().nothrow();
       }
     },
   };

package/src/rate-limiter.ts

@@ -490,11 +490,6 @@ export class SqliteRateLimiter implements RateLimiter {
       if (result.changes < BATCH_SIZE) break;
     }
 
-    if (totalDeleted > 0) {
-      console.log("[RateLimiter] Cleanup completed:", {
-        deletedRows: totalDeleted,
-      });
-    }
   }
 
   async recordRequest(agentName: string, endpoint: string): Promise<void> {

package/src/storage.ts

@@ -329,10 +329,6 @@ export class SemanticMemoryStorage implements LearningStorage {
   constructor(config: Partial<StorageConfig> = {}) {
     // Use getDefaultStorageConfig() to ensure env vars are read at runtime
     this.config = { ...getDefaultStorageConfig(), ...config };
-    console.log(
-      `[storage] SemanticMemoryStorage initialized with collections:`,
-      this.config.collections,
-    );
   }
 
   // -------------------------------------------------------------------------
@@ -381,7 +377,6 @@ export class SemanticMemoryStorage implements LearningStorage {
       args.push("--metadata", JSON.stringify(metadata));
     }
 
-    console.log(`[storage] store() -> collection="${collection}"`);
     sessionStats.storesCount++;
 
     const result = await execSemanticMemory(args);
@@ -416,9 +411,6 @@ export class SemanticMemoryStorage implements LearningStorage {
       args.push("--fts");
     }
 
-    console.log(
-      `[storage] find() -> collection="${collection}", query="${query.slice(0, 50)}${query.length > 50 ? "..." : ""}", limit=${limit}, fts=${useFts}`,
-    );
     sessionStats.queriesCount++;
 
     const result = await execSemanticMemory(args);
@@ -456,7 +448,6 @@ export class SemanticMemoryStorage implements LearningStorage {
   }
 
   private async list<T>(collection: string): Promise<T[]> {
-    console.log(`[storage] list() -> collection="${collection}"`);
     sessionStats.queriesCount++;
 
     const result = await execSemanticMemory([

package/src/swarm-mail.integration.test.ts

@@ -9,7 +9,11 @@
 
 import { randomUUID } from "node:crypto";
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { resetDatabase, closeDatabase, getDatabase } from "./streams/index";
+import {
+  resetDatabase,
+  getDatabase,
+  closeDatabase,
+} from "swarm-mail";
 import {
   swarmmail_init,
   swarmmail_send,

package/src/swarm-orchestrate.ts

@@ -1031,7 +1031,7 @@ export const swarm_complete = tool({
       .optional()
       .describe("Number of retry attempts during task"),
   },
-  async execute(args) {
+  async execute(args, _ctx) {
     // Extract epic ID early for error notifications
     const epicId = args.bead_id.includes(".")
       ? args.bead_id.split(".")[0]
@@ -1295,9 +1295,6 @@ Continuing with completion, but this should be fixed for future subtasks.`;
 
           if (storeResult.exitCode === 0) {
             memoryStored = true;
-            console.log(
-              `[swarm_complete] Stored learning for ${args.bead_id} in semantic-memory`,
-            );
           } else {
             memoryError = `semantic-memory store failed: ${storeResult.stderr.toString().slice(0, 200)}`;
             console.warn(`[swarm_complete] ${memoryError}`);
@@ -1351,15 +1348,27 @@ Continuing with completion, but this should be fixed for future subtasks.`;
         .filter(Boolean)
         .join("\n");
 
-      await sendSwarmMessage({
-        projectPath: args.project_key,
-        fromAgent: args.agent_name,
-        toAgents: [], // Thread broadcast
-        subject: `Complete: ${args.bead_id}`,
-        body: completionBody,
-        threadId: epicId,
-        importance: "normal",
-      });
+      // Send completion message (non-fatal if it fails)
+      let messageSent = false;
+      let messageError: string | undefined;
+      try {
+        await sendSwarmMessage({
+          projectPath: args.project_key,
+          fromAgent: args.agent_name,
+          toAgents: [], // Thread broadcast
+          subject: `Complete: ${args.bead_id}`,
+          body: completionBody,
+          threadId: epicId,
+          importance: "normal",
+        });
+        messageSent = true;
+      } catch (error) {
+        // Non-fatal - log and continue
+        messageError = error instanceof Error ? error.message : String(error);
+        console.warn(
+          `[swarm_complete] Failed to send completion message: ${messageError}`,
+        );
+      }
 
       // Build success response with semantic-memory integration
       const response = {
@@ -1367,7 +1376,8 @@ Continuing with completion, but this should be fixed for future subtasks.`;
         bead_id: args.bead_id,
         closed: true,
         reservations_released: true,
-        message_sent: true,
+        message_sent: messageSent,
+        message_error: messageError,
         agent_registration: {
           verified: agentRegistered,
           warning: registrationWarning || undefined,

package/src/swarm.integration.test.ts

@@ -1548,6 +1548,89 @@ describe("Swarm Prompt V2 (with Swarm Mail/Beads)", () => {
       },
     );
   });
+
+  describe("swarm_complete error handling", () => {
+    let beadsAvailable = false;
+
+    beforeAll(async () => {
+      beadsAvailable = await isBeadsAvailable();
+    });
+
+    it.skipIf(!beadsAvailable)(
+      "returns structured error when bead close fails",
+      async () => {
+        // Try to complete a non-existent bead
+        const result = await swarm_complete.execute(
+          {
+            project_key: "/tmp/test-error-handling",
+            agent_name: "test-agent",
+            bead_id: "bd-nonexistent-12345",
+            summary: "This should fail",
+            skip_verification: true,
+          },
+          mockContext,
+        );
+
+        const parsed = JSON.parse(result);
+
+        // Should return structured error, not throw
+        expect(parsed.success).toBe(false);
+        expect(parsed.error).toContain("Failed to close bead");
+        expect(parsed.failed_step).toBe("bd close");
+        expect(parsed.bead_id).toBe("bd-nonexistent-12345");
+        expect(parsed.recovery).toBeDefined();
+        expect(parsed.recovery.steps).toBeInstanceOf(Array);
+      },
+    );
+
+    it.skipIf(!beadsAvailable)(
+      "includes message_sent status in response",
+      async () => {
+        const createResult =
+          await Bun.$`bd create "Test message status" -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 {
+          const result = await swarm_complete.execute(
+            {
+              project_key: "/tmp/test-message-status",
+              agent_name: "test-agent",
+              bead_id: bead.id,
+              summary: "Test message status tracking",
+              skip_verification: true,
+            },
+            mockContext,
+          );
+
+          const parsed = JSON.parse(result);
+
+          // Should have message_sent field (true or false)
+          expect(parsed).toHaveProperty("message_sent");
+          // If message failed, should have message_error
+          if (!parsed.message_sent) {
+            expect(parsed).toHaveProperty("message_error");
+          }
+        } catch (error) {
+          // Clean up bead if test fails
+          await Bun.$`bd close ${bead.id} --reason "Test cleanup"`
+            .quiet()
+            .nothrow();
+          throw error;
+        }
+      },
+    );
+  });
 });
 
 // ============================================================================