opencode-swarm-plugin 0.36.0 → 0.37.0

package/src/plugin.ts

@@ -1,23 +1,23 @@
 /**
  * OpenCode Plugin Entry Point
  *
- * CRITICAL: Only export the plugin function from this file.
+ * CRITICAL: Only export the plugin function as DEFAULT from this file.
  *
  * OpenCode's plugin loader calls ALL exports as functions during initialization.
- * Exporting classes, constants, or non-function values will cause the plugin
- * to fail to load with cryptic errors.
+ * If you export both named AND default pointing to the same function, the plugin
+ * gets registered TWICE, causing hooks to fire multiple times.
  *
  * If you need to export utilities for external use, add them to src/index.ts instead.
  *
  * @example
- * // ✅ CORRECT - only export the plugin function
+ * // ✅ CORRECT - only default export
  * export default SwarmPlugin;
  *
- * // ❌ WRONG - will break plugin loading
- * export const VERSION = "1.0.0";
- * export class Helper {}
+ * // ❌ WRONG - causes double registration
+ * export { SwarmPlugin };
+ * export default SwarmPlugin;
  */
-import { SwarmPlugin } from "./index";
+import SwarmPlugin from "./index";
 
-// Only export the plugin function - nothing else!
-export { SwarmPlugin };
+// Only default export - no named exports!
+export default SwarmPlugin;

package/src/swarm-decompose.test.ts

@@ -0,0 +1,195 @@
+/**
+ * Swarm Decompose Unit Tests
+ *
+ * Tests for task decomposition, validation, and eval capture integration.
+ *
+ * TDD: Testing eval capture integration - verifies captureDecomposition() is called
+ * after successful validation with correct parameters.
+ */
+import { afterEach, beforeEach, describe, expect, test, mock } from "bun:test";
+import * as fs from "node:fs";
+import { swarm_validate_decomposition } from "./swarm-decompose";
+import * as evalCapture from "./eval-capture.js";
+
+// ============================================================================
+// Test Setup
+// ============================================================================
+
+const mockContext = {
+  sessionID: `test-decompose-${Date.now()}`,
+  messageID: `test-message-${Date.now()}`,
+  agent: "test-agent",
+  abort: new AbortController().signal,
+};
+
+let testProjectPath: string;
+
+beforeEach(() => {
+  testProjectPath = `/tmp/test-swarm-decompose-${Date.now()}`;
+  fs.mkdirSync(testProjectPath, { recursive: true });
+});
+
+afterEach(() => {
+  if (fs.existsSync(testProjectPath)) {
+    fs.rmSync(testProjectPath, { recursive: true, force: true });
+  }
+});
+
+// ============================================================================
+// Eval Capture Integration Tests
+// ============================================================================
+
+describe("captureDecomposition integration", () => {
+  test("calls captureDecomposition after successful validation with all params", async () => {
+    // Mock captureDecomposition to spy on calls
+    const captureDecompositionSpy = mock(() => ({
+      id: "test-epic-123",
+      timestamp: new Date().toISOString(),
+      task: "Add user authentication",
+    }));
+    const original = evalCapture.captureDecomposition;
+    // @ts-expect-error - mocking for test
+    evalCapture.captureDecomposition = captureDecompositionSpy;
+
+    const validCellTree = JSON.stringify({
+      epic: {
+        title: "Add OAuth",
+        description: "Implement OAuth authentication",
+      },
+      subtasks: [
+        {
+          title: "Add OAuth provider config",
+          description: "Set up Google OAuth",
+          files: ["src/auth/google.ts", "src/auth/config.ts"],
+          dependencies: [],
+          estimated_complexity: 2,
+        },
+        {
+          title: "Add login UI",
+          description: "Create login button component",
+          files: ["src/components/LoginButton.tsx"],
+          dependencies: [0],
+          estimated_complexity: 1,
+        },
+      ],
+    });
+
+    const result = await swarm_validate_decomposition.execute(
+      {
+        response: validCellTree,
+        project_path: testProjectPath,
+        task: "Add user authentication",
+        context: "Using NextAuth.js",
+        strategy: "feature-based" as const,
+        epic_id: "test-epic-123",
+      },
+      mockContext,
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.valid).toBe(true);
+
+    // Verify captureDecomposition was called with correct params
+    expect(captureDecompositionSpy).toHaveBeenCalledTimes(1);
+    const callArgs = captureDecompositionSpy.mock.calls[0][0];
+    expect(callArgs.epicId).toBe("test-epic-123");
+    expect(callArgs.projectPath).toBe(testProjectPath);
+    expect(callArgs.task).toBe("Add user authentication");
+    expect(callArgs.context).toBe("Using NextAuth.js");
+    expect(callArgs.strategy).toBe("feature-based");
+    expect(callArgs.epicTitle).toBe("Add OAuth");
+    expect(callArgs.epicDescription).toBe("Implement OAuth authentication");
+    expect(callArgs.subtasks).toHaveLength(2);
+    expect(callArgs.subtasks[0].title).toBe("Add OAuth provider config");
+
+    // Restore
+    // @ts-expect-error - restoring mock
+    evalCapture.captureDecomposition = original;
+  });
+
+  test("does not call captureDecomposition when validation fails", async () => {
+    const captureDecompositionSpy = mock(() => ({}));
+    const original = evalCapture.captureDecomposition;
+    // @ts-expect-error - mocking for test
+    evalCapture.captureDecomposition = captureDecompositionSpy;
+
+    // Invalid CellTree - missing required fields
+    const invalidCellTree = JSON.stringify({
+      epic: { title: "Missing subtasks" },
+      // No subtasks array
+    });
+
+    const result = await swarm_validate_decomposition.execute(
+      {
+        response: invalidCellTree,
+        project_path: testProjectPath,
+        task: "Add auth",
+        strategy: "auto" as const,
+        epic_id: "test-epic-456",
+      },
+      mockContext,
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.valid).toBe(false);
+
+    // Verify captureDecomposition was NOT called
+    expect(captureDecompositionSpy).not.toHaveBeenCalled();
+
+    // Restore
+    // @ts-expect-error - restoring mock
+    evalCapture.captureDecomposition = original;
+  });
+
+  test("handles optional context and description fields", async () => {
+    const captureDecompositionSpy = mock(() => ({
+      id: "test-epic-789",
+      timestamp: new Date().toISOString(),
+      task: "Fix the auth bug",
+    }));
+    const original = evalCapture.captureDecomposition;
+    // @ts-expect-error - mocking for test
+    evalCapture.captureDecomposition = captureDecompositionSpy;
+
+    const validCellTree = JSON.stringify({
+      epic: {
+        title: "Fix bug",
+        // No description
+      },
+      subtasks: [
+        {
+          title: "Add test",
+          files: ["src/test.ts"],
+          dependencies: [],
+          estimated_complexity: 1,
+        },
+      ],
+    });
+
+    const result = await swarm_validate_decomposition.execute(
+      {
+        response: validCellTree,
+        project_path: testProjectPath,
+        task: "Fix the auth bug",
+        // No context
+        strategy: "risk-based" as const,
+        epic_id: "test-epic-789",
+      },
+      mockContext,
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.valid).toBe(true);
+
+    // Verify captureDecomposition was called without optional fields
+    expect(captureDecompositionSpy).toHaveBeenCalledTimes(1);
+    const callArgs = captureDecompositionSpy.mock.calls[0][0];
+    expect(callArgs.epicId).toBe("test-epic-789");
+    expect(callArgs.context).toBeUndefined();
+    expect(callArgs.epicDescription).toBeUndefined();
+
+    // Restore
+    // @ts-expect-error - restoring mock
+    evalCapture.captureDecomposition = original;
+  });
+});

package/src/swarm-decompose.ts

@@ -20,6 +20,7 @@ import {
   NEGATIVE_MARKERS,
   type DecompositionStrategy,
 } from "./swarm-strategies";
+import { captureCoordinatorEvent } from "./eval-capture.js";
 
 // ============================================================================
 // Decomposition Prompt (temporary - will be moved to swarm-prompts.ts)
@@ -534,11 +535,31 @@ export const swarm_decompose = tool({
  * Use this after the agent responds to swarm:decompose to validate the structure.
  */
 export const swarm_validate_decomposition = tool({
-  description: "Validate a decomposition response against CellTreeSchema",
+  description: "Validate a decomposition response against CellTreeSchema and capture for eval",
   args: {
     response: tool.schema
       .string()
       .describe("JSON response from agent (CellTree format)"),
+    project_path: tool.schema
+      .string()
+      .optional()
+      .describe("Project path for eval capture"),
+    task: tool.schema
+      .string()
+      .optional()
+      .describe("Original task description for eval capture"),
+    context: tool.schema
+      .string()
+      .optional()
+      .describe("Context provided for decomposition"),
+    strategy: tool.schema
+      .enum(["file-based", "feature-based", "risk-based", "auto"])
+      .optional()
+      .describe("Decomposition strategy used"),
+    epic_id: tool.schema
+      .string()
+      .optional()
+      .describe("Epic ID for eval capture"),
   },
   async execute(args) {
     try {
@@ -596,6 +617,37 @@ export const swarm_validate_decomposition = tool({
         validated.subtasks,
       );
 
+      // Capture decomposition for eval if all required params provided
+      if (
+        args.project_path &&
+        args.task &&
+        args.strategy &&
+        args.epic_id
+      ) {
+        try {
+          const { captureDecomposition } = await import("./eval-capture.js");
+          captureDecomposition({
+            epicId: args.epic_id,
+            projectPath: args.project_path,
+            task: args.task,
+            context: args.context,
+            strategy: args.strategy,
+            epicTitle: validated.epic.title,
+            epicDescription: validated.epic.description,
+            subtasks: validated.subtasks.map((s) => ({
+              title: s.title,
+              description: s.description,
+              files: s.files,
+              dependencies: s.dependencies,
+              estimated_complexity: s.estimated_complexity,
+            })),
+          });
+        } catch (error) {
+          // Non-fatal - don't block validation if capture fails
+          console.warn("[swarm_validate_decomposition] Failed to capture decomposition:", error);
+        }
+      }
+
       return JSON.stringify(
         {
           valid: true,
@@ -722,6 +774,25 @@ export const swarm_delegate_planning = tool({
       strategyReasoning = selection.reasoning;
     }
 
+    // Capture strategy selection decision
+    try {
+      captureCoordinatorEvent({
+        session_id: process.env.OPENCODE_SESSION_ID || "unknown",
+        epic_id: "planning", // No epic ID yet - this is pre-decomposition
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "strategy_selected",
+        payload: {
+          strategy: selectedStrategy,
+          reasoning: strategyReasoning,
+          task_preview: args.task.slice(0, 100),
+        },
+      });
+    } catch (error) {
+      // Non-fatal - don't block planning if capture fails
+      console.warn("[swarm_delegate_planning] Failed to capture strategy_selected:", error);
+    }
+
     // Query CASS for similar past tasks
     let cassContext = "";
     let cassResultInfo: {

package/src/swarm-orchestrate.ts

@@ -83,6 +83,7 @@ import {
   isReviewApproved,
   getReviewStatus,
 } from "./swarm-review";
+import { captureCoordinatorEvent } from "./eval-capture.js";
 
 // ============================================================================
 // Helper Functions
@@ -1709,6 +1710,28 @@ Files touched: ${args.files_touched?.join(", ") || "none recorded"}`,
             },
       };
 
+      // Capture subtask completion outcome
+      try {
+        const durationMs = args.start_time ? Date.now() - args.start_time : 0;
+        captureCoordinatorEvent({
+          session_id: process.env.OPENCODE_SESSION_ID || "unknown",
+          epic_id: epicId,
+          timestamp: new Date().toISOString(),
+          event_type: "OUTCOME",
+          outcome_type: "subtask_success",
+          payload: {
+            bead_id: args.bead_id,
+            duration_ms: durationMs,
+            files_touched: args.files_touched || [],
+            verification_passed: verificationResult?.passed ?? false,
+            verification_skipped: args.skip_verification ?? false,
+          },
+        });
+      } catch (error) {
+        // Non-fatal - don't block completion if capture fails
+        console.warn("[swarm_complete] Failed to capture subtask_success:", error);
+      }
+
       return JSON.stringify(response, null, 2);
     } catch (error) {
       // CRITICAL: Notify coordinator of failure via swarm mail
@@ -1796,6 +1819,27 @@ Files touched: ${args.files_touched?.join(", ") || "none recorded"}`,
         console.error(`[swarm_complete] Original error:`, error);
       }
 
+      // Capture subtask failure outcome
+      try {
+        const durationMs = args.start_time ? Date.now() - args.start_time : 0;
+        captureCoordinatorEvent({
+          session_id: process.env.OPENCODE_SESSION_ID || "unknown",
+          epic_id: epicId,
+          timestamp: new Date().toISOString(),
+          event_type: "OUTCOME",
+          outcome_type: "subtask_failed",
+          payload: {
+            bead_id: args.bead_id,
+            duration_ms: durationMs,
+            failed_step: failedStep,
+            error_message: errorMessage.slice(0, 500),
+          },
+        });
+      } catch (captureError) {
+        // Non-fatal - don't block error return if capture fails
+        console.warn("[swarm_complete] Failed to capture subtask_failed:", captureError);
+      }
+
       // Return structured error instead of throwing
       // This ensures the agent sees the actual error message
       return JSON.stringify(

package/src/swarm-prompts.ts

@@ -14,6 +14,7 @@
 
 import { tool } from "@opencode-ai/plugin";
 import { generateWorkerHandoff } from "./swarm-orchestrate";
+import { captureCoordinatorEvent } from "./eval-capture.js";
 
 // ============================================================================
 // Prompt Templates
@@ -1107,6 +1108,25 @@ export const swarm_spawn_subtask = tool({
       .replace(/{files_touched}/g, filesJoined)
       .replace(/{worker_id}/g, "worker");  // Will be filled by actual worker name
 
+    // Capture worker spawn decision
+    try {
+      captureCoordinatorEvent({
+        session_id: process.env.OPENCODE_SESSION_ID || "unknown",
+        epic_id: args.epic_id,
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "worker_spawned",
+        payload: {
+          bead_id: args.bead_id,
+          files: args.files,
+          worker_model: selectedModel,
+        },
+      });
+    } catch (error) {
+      // Non-fatal - don't block spawn if capture fails
+      console.warn("[swarm_spawn_subtask] Failed to capture worker_spawned:", error);
+    }
+
     return JSON.stringify(
       {
         prompt,

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

@@ -2,18 +2,15 @@
  * Integration tests for swarm review feedback flow
  * 
  * Tests the coordinator review feedback workflow with real HiveAdapter and swarm-mail.
- * Verifies that review approval/rejection properly updates state and sends messages.
+ * Verifies that review approval/rejection properly updates state.
  * 
- * **STATUS**: URL_INVALID bug FIXED by commit 7bf9385 (libSQL URL normalization).
- * Tests now execute without URL errors. sendSwarmMessage successfully creates adapters.
- *
- * **REMAINING ISSUE**: Message retrieval not working. getInbox returns empty even though
- * sendSwarmMessage succeeds. Possible causes:
- * - Database adapter instance mismatch (sendSwarmMessage creates new adapter each call)
- * - Message projection not materializing from events
- * - Database path resolution issue between send and receive
- *
- * Tests currently SKIPPED pending message retrieval fix.
+ * **ARCHITECTURE**: Coordinator-driven retry pattern (swarm_spawn_retry)
+ * - `approved` status: Sends message to worker (worker can complete)
+ * - `needs_changes` status: NO message sent (worker is dead, coordinator spawns retry)
+ * - After 3 rejections: Task marked blocked, NO message sent
+ * 
+ * This aligns with the "worker is dead" philosophy - failed reviews require coordinator
+ * intervention via swarm_spawn_retry, not worker self-retry.
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
@@ -195,23 +192,23 @@ describe("swarm_review integration", () => {
 		expect(feedbackParsed.attempt).toBe(1);
 		expect(feedbackParsed.remaining_attempts).toBe(2);
 
-		// Verify retry count incremented
-		expect(feedbackParsed.attempt).toBe(1);
-
-		// Verify message was sent with issues
+		// Verify retry_context is provided for coordinator to spawn retry
+		expect(feedbackParsed.retry_context).toBeDefined();
+		expect(feedbackParsed.retry_context.task_id).toBe(subtask.id);
+		expect(feedbackParsed.retry_context.attempt).toBe(1);
+		expect(feedbackParsed.retry_context.max_attempts).toBe(3);
+		expect(feedbackParsed.retry_context.issues).toEqual(issues);
+		expect(feedbackParsed.retry_context.next_action).toContain("swarm_spawn_retry");
+
+		// ARCHITECTURE CHANGE: No longer sends message to worker
+		// Worker is considered "dead" - coordinator must spawn retry
+		// Inbox should remain empty
 		const messages = await swarmMail.getInbox(
 			testProjectPath,
 			"TestWorker",
 			{ limit: 10 }
 		);
-		expect(messages.length).toBeGreaterThan(0);
-
-		const needsChangesMessage = messages.find((m) =>
-			m.subject.includes("NEEDS CHANGES")
-		);
-		expect(needsChangesMessage).toBeDefined();
-		expect(needsChangesMessage?.subject).toContain(subtask.id);
-		expect(needsChangesMessage?.subject).toContain("attempt 1/3");
+		expect(messages.length).toBe(0);
 	});
 
 	test("3-strike rule: task marked blocked after 3 rejections", async () => {
@@ -275,16 +272,14 @@ describe("swarm_review integration", () => {
 		const updatedCell = await hive.getCell(testProjectPath, subtask.id);
 		expect(updatedCell?.status).toBe("blocked");
 
-		// Verify final failure message was sent
+		// ARCHITECTURE CHANGE: No longer sends failure message
+		// Worker is dead, coordinator handles escalation
+		// Inbox should remain empty
 		const messages = await swarmMail.getInbox(
 			testProjectPath,
 			"TestWorker",
 			{ limit: 10 }
 		);
-
-		const failedMessage = messages.find((m) => m.subject.includes("FAILED"));
-		expect(failedMessage).toBeDefined();
-		expect(failedMessage?.subject).toContain("max review attempts reached");
-		expect(failedMessage?.importance).toBe("urgent");
+		expect(messages.length).toBe(0);
 	});
 });

package/src/swarm-review.ts

@@ -18,6 +18,7 @@ import { tool } from "@opencode-ai/plugin";
 import { z } from "zod";
 import { sendSwarmMessage, type HiveAdapter } from "swarm-mail";
 import { getHiveAdapter } from "./hive";
+import { captureCoordinatorEvent } from "./eval-capture.js";
 
 // ============================================================================
 // Types & Schemas
@@ -508,6 +509,25 @@ export const swarm_review_feedback = tool({
       // Mark as approved and clear attempts
       markReviewApproved(args.task_id);
 
+      // Capture review approval decision
+      try {
+        captureCoordinatorEvent({
+          session_id: process.env.OPENCODE_SESSION_ID || "unknown",
+          epic_id: epicId,
+          timestamp: new Date().toISOString(),
+          event_type: "DECISION",
+          decision_type: "review_completed",
+          payload: {
+            task_id: args.task_id,
+            status: "approved",
+            retry_count: 0,
+          },
+        });
+      } catch (error) {
+        // Non-fatal - don't block approval if capture fails
+        console.warn("[swarm_review_feedback] Failed to capture review_completed:", error);
+      }
+
       // Send approval message
       await sendSwarmMessage({
         projectPath: args.project_key,
@@ -539,6 +559,27 @@ You may now complete the task with \`swarm_complete\`.`,
     const attemptNumber = incrementAttempt(args.task_id);
     const remaining = MAX_REVIEW_ATTEMPTS - attemptNumber;
 
+    // Capture review rejection decision
+    try {
+      captureCoordinatorEvent({
+        session_id: process.env.OPENCODE_SESSION_ID || "unknown",
+        epic_id: epicId,
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "review_completed",
+        payload: {
+          task_id: args.task_id,
+          status: "needs_changes",
+          retry_count: attemptNumber,
+          remaining_attempts: remaining,
+          issues_count: parsedIssues.length,
+        },
+      });
+    } catch (error) {
+      // Non-fatal - don't block feedback if capture fails
+      console.warn("[swarm_review_feedback] Failed to capture review_completed:", error);
+    }
+
     // Check if task should fail
     if (remaining <= 0) {
       // Mark task as blocked using HiveAdapter