opencode-swarm-plugin 0.36.1 → 0.38.0

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

@@ -495,6 +495,158 @@ describe("End-to-end research workflow", () => {
 	});
 });
 
+describe("Research spawn instructions (NEW)", () => {
+	let testProjectPath: string;
+
+	beforeEach(() => {
+		testProjectPath = join(tmpdir(), `spawn-test-${Date.now()}`);
+		mkdirSync(testProjectPath, { recursive: true });
+	});
+
+	afterEach(() => {
+		rmSync(testProjectPath, { recursive: true, force: true });
+	});
+
+	test("runResearchPhase generates spawn instructions for each technology", async () => {
+		// Create package.json with dependencies
+		const packageJson = {
+			dependencies: {
+				zod: "^3.22.4",
+				typescript: "^5.3.3",
+			},
+		};
+
+		writeFileSync(
+			join(testProjectPath, "package.json"),
+			JSON.stringify(packageJson, null, 2),
+		);
+
+		// Run research phase
+		const result = await runResearchPhase(
+			"Add Zod validation to TypeScript API",
+			testProjectPath,
+		);
+
+		// Should have spawn_instructions array
+		expect(result.spawn_instructions).toBeDefined();
+		expect(Array.isArray(result.spawn_instructions)).toBe(true);
+
+		// Should have one instruction per technology
+		expect(result.spawn_instructions.length).toBe(result.tech_stack.length);
+
+		// Each instruction should have required fields
+		for (const instruction of result.spawn_instructions) {
+			expect(instruction.research_id).toBeDefined();
+			expect(instruction.research_id).toMatch(/^research-/); // Should start with "research-"
+			expect(instruction.tech).toBeDefined();
+			expect(result.tech_stack).toContain(instruction.tech); // Tech should be from tech_stack
+			expect(instruction.prompt).toBeDefined();
+			expect(typeof instruction.prompt).toBe("string");
+			expect(instruction.prompt.length).toBeGreaterThan(0);
+			expect(instruction.subagent_type).toBe("swarm/researcher");
+		}
+	});
+
+	test("runResearchPhase prompts contain correct technology", async () => {
+		const packageJson = {
+			dependencies: {
+				zod: "^3.22.4",
+			},
+		};
+
+		writeFileSync(
+			join(testProjectPath, "package.json"),
+			JSON.stringify(packageJson, null, 2),
+		);
+
+		const result = await runResearchPhase("Use Zod", testProjectPath);
+
+		// Should have exactly one spawn instruction (one tech)
+		expect(result.spawn_instructions.length).toBe(1);
+
+		const instruction = result.spawn_instructions[0];
+		expect(instruction.tech).toBe("zod");
+		expect(instruction.prompt).toContain("zod");
+		expect(instruction.prompt).toContain(testProjectPath);
+	});
+
+	test("runResearchPhase with multiple technologies generates multiple instructions", async () => {
+		const packageJson = {
+			dependencies: {
+				zod: "^3.22.4",
+				typescript: "^5.3.3",
+				react: "^18.2.0",
+			},
+		};
+
+		writeFileSync(
+			join(testProjectPath, "package.json"),
+			JSON.stringify(packageJson, null, 2),
+		);
+
+		const result = await runResearchPhase(
+			"Build React app with Zod and TypeScript",
+			testProjectPath,
+		);
+
+		// Should extract 3 technologies
+		expect(result.tech_stack.length).toBe(3);
+
+		// Should have 3 spawn instructions
+		expect(result.spawn_instructions.length).toBe(3);
+
+		// Each tech should have one instruction
+		const techs = result.spawn_instructions.map((i) => i.tech);
+		expect(techs).toContain("zod");
+		expect(techs).toContain("typescript");
+		expect(techs).toContain("react");
+
+		// Research IDs should be unique
+		const researchIds = result.spawn_instructions.map((i) => i.research_id);
+		const uniqueIds = new Set(researchIds);
+		expect(uniqueIds.size).toBe(researchIds.length);
+	});
+
+	test("runResearchPhase with empty tech_stack returns empty spawn_instructions", async () => {
+		// Don't create package.json - no dependencies
+
+		const result = await runResearchPhase(
+			"Implement something with FooBarBaz",
+			testProjectPath,
+		);
+
+		// Should have empty tech_stack (no known technologies)
+		expect(result.tech_stack).toEqual([]);
+
+		// Should have empty spawn_instructions
+		expect(result.spawn_instructions).toEqual([]);
+
+		// Other fields should be empty
+		expect(result.summaries).toEqual({});
+		expect(result.memory_ids).toEqual([]);
+	});
+
+	test("spawn instruction prompts include swarmmail_init", async () => {
+		const packageJson = {
+			dependencies: {
+				zod: "^3.22.4",
+			},
+		};
+
+		writeFileSync(
+			join(testProjectPath, "package.json"),
+			JSON.stringify(packageJson, null, 2),
+		);
+
+		const result = await runResearchPhase("Use Zod", testProjectPath);
+
+		// Prompt should include swarmmail_init (researcher workers need this)
+		const instruction = result.spawn_instructions[0];
+		expect(instruction.prompt).toContain("swarmmail_init");
+		expect(instruction.prompt).toContain("semantic-memory_store");
+	});
+});
+
 describe("Real-world fixture: this repo", () => {
 	test("discovers tools and versions from actual repo", async () => {
 		// Use the plugin package directory, not monorepo root
@@ -540,5 +692,10 @@ describe("Real-world fixture: this repo", () => {
 		expect(result.summaries).toBeDefined();
 		expect(result.memory_ids).toBeDefined();
 		expect(Array.isArray(result.memory_ids)).toBe(true);
+
+		// NEW: Should have spawn_instructions
+		expect(result.spawn_instructions).toBeDefined();
+		expect(Array.isArray(result.spawn_instructions)).toBe(true);
+		expect(result.spawn_instructions.length).toBeGreaterThan(0);
 	});
 });

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