opencode-swarm-plugin 0.36.1 → 0.37.0

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

@@ -535,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 {
@@ -597,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,

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);
 	});
 });