opencode-swarm-plugin 0.37.0 → 0.38.0

package/src/swarm-orchestrate.test.ts

@@ -6,10 +6,13 @@
  * - Researcher spawning for identified technologies
  * - Summary collection from semantic-memory
  * - Research result aggregation
+ * - Eval capture integration (captureSubtaskOutcome wiring)
  */
 
-import { describe, test, expect, beforeEach } from "bun:test";
-import { runResearchPhase, extractTechStack } from "./swarm-orchestrate";
+import { describe, test, expect, beforeEach, afterEach, spyOn } from "bun:test";
+import { runResearchPhase, extractTechStack, swarm_complete } from "./swarm-orchestrate";
+import * as evalCapture from "./eval-capture.js";
+import * as fs from "node:fs";
 
 describe("extractTechStack", () => {
   test("extracts Next.js from task description", () => {
@@ -115,9 +118,269 @@ describe("runResearchPhase", () => {
   });
 });
 
-describe("swarm_research_phase tool", () => {
-  test.todo("exposes research phase as plugin tool");
-  test.todo("validates task parameter");
-  test.todo("validates project_path parameter");
-  test.todo("returns JSON string with research results");
+// describe("swarm_research_phase tool", () => {
+//   test.todo("exposes research phase as plugin tool");
+//   test.todo("validates task parameter");
+//   test.todo("validates project_path parameter");
+//   test.todo("returns JSON string with research results");
+// });
+
+// ============================================================================
+// Eval Capture Integration Tests (swarm_complete)
+// ============================================================================
+
+describe("captureSubtaskOutcome integration", () => {
+  const mockContext = {
+    sessionID: `test-complete-${Date.now()}`,
+    messageID: `test-message-${Date.now()}`,
+    agent: "test-agent",
+    abort: new AbortController().signal,
+  };
+
+  let testProjectPath: string;
+
+  beforeEach(async () => {
+    testProjectPath = `/tmp/test-swarm-complete-${Date.now()}`;
+    fs.mkdirSync(testProjectPath, { recursive: true });
+    
+    // Create .hive directory and issues.jsonl
+    const hiveDir = `${testProjectPath}/.hive`;
+    fs.mkdirSync(hiveDir, { recursive: true });
+    fs.writeFileSync(`${hiveDir}/issues.jsonl`, "", "utf-8");
+    
+    // Set hive working directory to testProjectPath
+    const { setHiveWorkingDirectory } = await import("./hive");
+    setHiveWorkingDirectory(testProjectPath);
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(testProjectPath)) {
+      fs.rmSync(testProjectPath, { recursive: true, force: true });
+    }
+  });
+
+  test("calls captureSubtaskOutcome after successful completion with all params", async () => {
+    // Import hive tools
+    const { hive_create_epic } = await import("./hive");
+    
+    // Spy on captureSubtaskOutcome
+    const captureOutcomeSpy = spyOn(evalCapture, "captureSubtaskOutcome");
+
+    // Create an epic with a subtask using hive_create_epic
+    const epicResult = await hive_create_epic.execute({
+      epic_title: "Add OAuth",
+      epic_description: "Implement OAuth authentication",
+      subtasks: [
+        {
+          title: "Add auth service",
+          priority: 2,
+          files: ["src/auth/service.ts", "src/auth/schema.ts"],
+        },
+      ],
+    }, mockContext);
+    
+    const epicData = JSON.parse(epicResult);
+    expect(epicData.success).toBe(true);
+    
+    const epicId = epicData.epic.id;
+    const beadId = epicData.subtasks[0].id;
+
+    const startTime = Date.now() - 120000; // Started 2 minutes ago
+    const plannedFiles = ["src/auth/service.ts", "src/auth/schema.ts"];
+    const actualFiles = ["src/auth/service.ts", "src/auth/schema.ts", "src/auth/types.ts"];
+
+    // Call swarm_complete
+    const result = await swarm_complete.execute(
+      {
+        project_key: testProjectPath,
+        agent_name: "TestAgent",
+        bead_id: beadId,
+        summary: "Implemented OAuth service with JWT strategy",
+        files_touched: actualFiles,
+        skip_verification: true, // Skip verification for test
+        skip_review: true, // Skip review for test
+        planned_files: plannedFiles,
+        start_time: startTime,
+        error_count: 0,
+        retry_count: 0,
+      },
+      mockContext,
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.success).toBe(true);
+
+    // Verify captureSubtaskOutcome was called with correct params
+    expect(captureOutcomeSpy).toHaveBeenCalledTimes(1);
+    
+    const call = captureOutcomeSpy.mock.calls[0][0];
+    expect(call.epicId).toBe(epicId);
+    expect(call.projectPath).toBe(testProjectPath);
+    expect(call.beadId).toBe(beadId);
+    expect(call.title).toBe("Add auth service");
+    expect(call.plannedFiles).toEqual(plannedFiles);
+    expect(call.actualFiles).toEqual(actualFiles);
+    expect(call.durationMs).toBeGreaterThan(0);
+    expect(call.errorCount).toBe(0);
+    expect(call.retryCount).toBe(0);
+    expect(call.success).toBe(true);
+
+    captureOutcomeSpy.mockRestore();
+  });
+
+  test("does not call captureSubtaskOutcome when required params missing", async () => {
+    const { hive_create_epic } = await import("./hive");
+    const captureOutcomeSpy = spyOn(evalCapture, "captureSubtaskOutcome");
+
+    // Create an epic with a subtask
+    const epicResult = await hive_create_epic.execute({
+      epic_title: "Fix bug",
+      subtasks: [
+        {
+          title: "Fix auth bug",
+          priority: 1,
+          files: ["src/auth.ts"],
+        },
+      ],
+    }, mockContext);
+    
+    const epicData = JSON.parse(epicResult);
+    const beadId = epicData.subtasks[0].id;
+
+    // Call without planned_files or start_time
+    const result = await swarm_complete.execute(
+      {
+        project_key: testProjectPath,
+        agent_name: "TestAgent",
+        bead_id: beadId,
+        summary: "Fixed the bug",
+        skip_verification: true,
+        skip_review: true,
+        // No planned_files, start_time
+      },
+      mockContext,
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.success).toBe(true);
+
+    // Capture should still be called, but with default values
+    // (The function is called in all success cases, it just handles missing params)
+    expect(captureOutcomeSpy).toHaveBeenCalledTimes(1);
+
+    captureOutcomeSpy.mockRestore();
+  });
+});
+
+// ============================================================================
+// Eval Capture Integration Tests (swarm_record_outcome)
+// ============================================================================
+
+describe("finalizeEvalRecord integration", () => {
+  const mockContext = {
+    sessionID: `test-finalize-${Date.now()}`,
+    messageID: `test-message-${Date.now()}`,
+    agent: "test-agent",
+    abort: new AbortController().signal,
+  };
+
+  test("calls finalizeEvalRecord when project_path and epic_id provided", async () => {
+    const { swarm_record_outcome } = await import("./swarm-orchestrate");
+    
+    // Spy on finalizeEvalRecord
+    const finalizeEvalSpy = spyOn(evalCapture, "finalizeEvalRecord");
+    finalizeEvalSpy.mockReturnValue(null); // Mock return value
+
+    const testProjectPath = "/tmp/test-project";
+    const testEpicId = "bd-test123";
+    const testBeadId = `${testEpicId}.0`;
+
+    // Call swarm_record_outcome with epic_id and project_path
+    await swarm_record_outcome.execute({
+      bead_id: testBeadId,
+      duration_ms: 120000,
+      error_count: 0,
+      retry_count: 0,
+      success: true,
+      files_touched: ["src/test.ts"],
+      epic_id: testEpicId,
+      project_path: testProjectPath,
+    }, mockContext);
+
+    // Verify finalizeEvalRecord was called
+    expect(finalizeEvalSpy).toHaveBeenCalledTimes(1);
+    expect(finalizeEvalSpy).toHaveBeenCalledWith({
+      epicId: testEpicId,
+      projectPath: testProjectPath,
+    });
+
+    finalizeEvalSpy.mockRestore();
+  });
+
+  test("does not call finalizeEvalRecord when epic_id or project_path missing", async () => {
+    const { swarm_record_outcome } = await import("./swarm-orchestrate");
+    
+    // Spy on finalizeEvalRecord
+    const finalizeEvalSpy = spyOn(evalCapture, "finalizeEvalRecord");
+
+    const testBeadId = "bd-test123.0";
+
+    // Call without epic_id or project_path
+    await swarm_record_outcome.execute({
+      bead_id: testBeadId,
+      duration_ms: 120000,
+      error_count: 0,
+      retry_count: 0,
+      success: true,
+    }, mockContext);
+
+    // Verify finalizeEvalRecord was NOT called
+    expect(finalizeEvalSpy).toHaveBeenCalledTimes(0);
+
+    finalizeEvalSpy.mockRestore();
+  });
+
+  test("includes finalized record in response when available", async () => {
+    const { swarm_record_outcome } = await import("./swarm-orchestrate");
+    
+    // Mock finalizeEvalRecord to return a record
+    const mockFinalRecord = {
+      id: "bd-test123",
+      timestamp: new Date().toISOString(),
+      project_path: "/tmp/test-project",
+      task: "Test task",
+      strategy: "file-based" as const,
+      subtask_count: 2,
+      epic_title: "Test Epic",
+      subtasks: [],
+      overall_success: true,
+      total_duration_ms: 240000,
+      total_errors: 0,
+    };
+
+    const finalizeEvalSpy = spyOn(evalCapture, "finalizeEvalRecord");
+    finalizeEvalSpy.mockReturnValue(mockFinalRecord);
+
+    const testProjectPath = "/tmp/test-project";
+    const testEpicId = "bd-test123";
+    const testBeadId = `${testEpicId}.0`;
+
+    // Call with epic_id and project_path
+    const result = await swarm_record_outcome.execute({
+      bead_id: testBeadId,
+      duration_ms: 120000,
+      error_count: 0,
+      retry_count: 0,
+      success: true,
+      epic_id: testEpicId,
+      project_path: testProjectPath,
+    }, mockContext);
+
+    // Parse result and check for finalized record
+    const parsed = JSON.parse(result);
+    expect(parsed).toHaveProperty("finalized_eval_record");
+    expect(parsed.finalized_eval_record).toEqual(mockFinalRecord);
+
+    finalizeEvalSpy.mockRestore();
+  });
 });

package/src/swarm-orchestrate.ts

@@ -83,7 +83,8 @@ import {
   isReviewApproved,
   getReviewStatus,
 } from "./swarm-review";
-import { captureCoordinatorEvent } from "./eval-capture.js";
+import { captureCoordinatorEvent, type EvalRecord } from "./eval-capture.js";
+import { formatResearcherPrompt } from "./swarm-prompts";
 
 // ============================================================================
 // Helper Functions
@@ -1710,6 +1711,31 @@ Files touched: ${args.files_touched?.join(", ") || "none recorded"}`,
             },
       };
 
+      // Capture subtask completion outcome for eval data
+      try {
+        const { captureSubtaskOutcome } = await import("./eval-capture.js");
+        const durationMs = args.start_time ? Date.now() - args.start_time : 0;
+        
+        // Determine epic ID: use parent_id if available, otherwise fall back to extracting from bead_id
+        const evalEpicId = cell.parent_id || epicId;
+        
+        captureSubtaskOutcome({
+          epicId: evalEpicId,
+          projectPath: args.project_key,
+          beadId: args.bead_id,
+          title: cell.title,
+          plannedFiles: args.planned_files || [],
+          actualFiles: args.files_touched || [],
+          durationMs,
+          errorCount: args.error_count || 0,
+          retryCount: args.retry_count || 0,
+          success: true,
+        });
+      } catch (error) {
+        // Non-fatal - don't block completion if capture fails
+        console.warn("[swarm_complete] Failed to capture subtask outcome:", error);
+      }
+
       // Capture subtask completion outcome
       try {
         const durationMs = args.start_time ? Date.now() - args.start_time : 0;
@@ -1946,6 +1972,14 @@ export const swarm_record_outcome = tool({
       .string()
       .optional()
       .describe("Detailed failure context (error message, stack trace, etc.)"),
+    project_path: tool.schema
+      .string()
+      .optional()
+      .describe("Project path (for finalizing eval records when all subtasks complete)"),
+    epic_id: tool.schema
+      .string()
+      .optional()
+      .describe("Epic ID (for finalizing eval records when all subtasks complete)"),
   },
   async execute(args) {
     // Build outcome signals
@@ -1980,6 +2014,21 @@ export const swarm_record_outcome = tool({
     // Get error patterns from accumulator
     const errorStats = await globalErrorAccumulator.getErrorStats(args.bead_id);
 
+    // Finalize eval record if project_path and epic_id provided
+    let finalizedRecord: EvalRecord | null = null;
+    if (args.project_path && args.epic_id) {
+      try {
+        const { finalizeEvalRecord } = await import("./eval-capture.js");
+        finalizedRecord = finalizeEvalRecord({
+          epicId: args.epic_id,
+          projectPath: args.project_path,
+        });
+      } catch (error) {
+        // Non-fatal - log and continue
+        console.warn("[swarm_record_outcome] Failed to finalize eval record:", error);
+      }
+    }
+
     // Generate feedback events for each criterion
     const criteriaToScore = args.criteria ?? [
       "type_safe",
@@ -2030,6 +2079,7 @@ export const swarm_record_outcome = tool({
           accumulated_errors: errorStats.total,
           unresolved_errors: errorStats.unresolved,
         },
+        finalized_eval_record: finalizedRecord || undefined,
         note: "Feedback events should be stored for criterion weight calculation. Use learning.ts functions to apply weights.",
       },
       null,
@@ -2087,12 +2137,28 @@ export function extractTechStack(task: string): string[] {
   return Array.from(detected);
 }
 
+/**
+ * Spawn instruction for a researcher worker
+ */
+export interface ResearchSpawnInstruction {
+  /** Unique ID for this research task */
+  research_id: string;
+  /** Technology being researched */
+  tech: string;
+  /** Full prompt for the researcher agent */
+  prompt: string;
+  /** Agent type for the Task tool */
+  subagent_type: "swarm/researcher";
+}
+
 /**
  * Research result from documentation discovery phase
  */
 export interface ResearchResult {
   /** Technologies identified and researched */
   tech_stack: string[];
+  /** Spawn instructions for researcher workers */
+  spawn_instructions: ResearchSpawnInstruction[];
   /** Summaries keyed by technology name */
   summaries: Record<string, string>;
   /** Semantic-memory IDs where research is stored */
@@ -2154,24 +2220,45 @@ export async function runResearchPhase(
   if (techStack.length === 0) {
     return {
       tech_stack: [],
+      spawn_instructions: [],
       summaries: {},
       memory_ids: [],
     };
   }
 
-  // Step 2: For each technology, spawn a researcher
-  // TODO: Implement researcher spawning using swarm_spawn_researcher
-  // and Task tool. This requires coordination logic that will be
-  // added in a future iteration.
-
-  // For now, return empty summaries (GREEN phase - make tests pass)
-  // The full implementation will spawn researchers in parallel and
-  // collect their findings.
+  // Step 2: Generate spawn instructions for each technology
+  // The coordinator will use these to spawn researcher workers via Task()
+  const spawnInstructions: ResearchSpawnInstruction[] = [];
+  
+  for (const tech of techStack) {
+    // Generate unique research ID
+    const researchId = `research-${tech}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    
+    // Generate researcher prompt
+    const prompt = formatResearcherPrompt({
+      research_id: researchId,
+      epic_id: "standalone-research", // No epic context for standalone research
+      tech_stack: [tech], // Single tech per researcher
+      project_path: projectPath,
+      check_upgrades: options?.checkUpgrades ?? false,
+    });
+    
+    spawnInstructions.push({
+      research_id: researchId,
+      tech,
+      prompt,
+      subagent_type: "swarm/researcher",
+    });
+  }
 
+  // Step 3: Return spawn instructions for coordinator
+  // The coordinator will spawn Task() agents using these instructions
+  // and collect results from swarm mail after completion
   return {
     tech_stack: techStack,
-    summaries: {},
-    memory_ids: [],
+    spawn_instructions: spawnInstructions,
+    summaries: {}, // Will be populated by coordinator after researchers complete
+    memory_ids: [], // Will be populated by coordinator after researchers store in semantic-memory
   };
 }
 

package/src/swarm-prompts.test.ts

@@ -9,8 +9,10 @@ import { describe, expect, test } from "bun:test";
 import {
   formatSubtaskPromptV2,
   formatResearcherPrompt,
+  formatCoordinatorPrompt,
   SUBTASK_PROMPT_V2,
   RESEARCHER_PROMPT,
+  COORDINATOR_PROMPT,
 } from "./swarm-prompts";
 
 describe("SUBTASK_PROMPT_V2", () => {
@@ -818,3 +820,122 @@ describe("swarm_spawn_retry tool", () => {
     expect(parsed.prompt).toMatch(/preserve.*working|fix.*while preserving/i);
   });
 });
+
+describe("COORDINATOR_PROMPT", () => {
+  test("constant exists and is exported", () => {
+    expect(COORDINATOR_PROMPT).toBeDefined();
+    expect(typeof COORDINATOR_PROMPT).toBe("string");
+    expect(COORDINATOR_PROMPT.length).toBeGreaterThan(100);
+  });
+
+  test("contains all phase headers (0-8)", () => {
+    expect(COORDINATOR_PROMPT).toContain("Phase 0:");
+    expect(COORDINATOR_PROMPT).toContain("Phase 1:");
+    expect(COORDINATOR_PROMPT).toContain("Phase 2:");
+    expect(COORDINATOR_PROMPT).toContain("Phase 3:");
+    expect(COORDINATOR_PROMPT).toContain("Phase 4:");
+    expect(COORDINATOR_PROMPT).toContain("Phase 5:");
+    expect(COORDINATOR_PROMPT).toContain("Phase 6:");
+    expect(COORDINATOR_PROMPT).toContain("Phase 7:");
+    expect(COORDINATOR_PROMPT).toContain("Phase 8:");
+  });
+
+  test("contains Phase 1.5: Research Phase section", () => {
+    expect(COORDINATOR_PROMPT).toContain("Phase 1.5:");
+    expect(COORDINATOR_PROMPT).toMatch(/Phase 1\.5:.*Research/i);
+  });
+
+  test("Phase 1.5 documents swarm_spawn_researcher usage", () => {
+    // Extract Phase 1.5 section
+    const phase15Match = COORDINATOR_PROMPT.match(/Phase 1\.5:[\s\S]*?Phase 2:/);
+    expect(phase15Match).not.toBeNull();
+    if (!phase15Match) return;
+    const phase15Content = phase15Match[0];
+
+    expect(phase15Content).toContain("swarm_spawn_researcher");
+    expect(phase15Content).toContain("Task(subagent_type=\"swarm/researcher\"");
+  });
+
+  test("has section explicitly forbidding direct research tool calls", () => {
+    expect(COORDINATOR_PROMPT).toMatch(/NEVER.*direct|forbidden.*tools|do not call directly/i);
+  });
+
+  test("forbidden tools section lists all prohibited tools", () => {
+    const forbiddenTools = [
+      "repo-crawl_",
+      "repo-autopsy_",
+      "webfetch",
+      "fetch_fetch",
+      "context7_",
+      "pdf-brain_search",
+      "pdf-brain_read"
+    ];
+
+    for (const tool of forbiddenTools) {
+      expect(COORDINATOR_PROMPT).toContain(tool);
+    }
+  });
+
+  test("forbidden tools section explains to use swarm_spawn_researcher instead", () => {
+    // Find the forbidden tools section
+    const forbiddenMatch = COORDINATOR_PROMPT.match(/(FORBIDDEN.*for coordinators|NEVER.*FETCH.*DIRECTLY)[\s\S]{0,500}swarm_spawn_researcher/i);
+    expect(forbiddenMatch).not.toBeNull();
+  });
+
+  test("contains coordinator role boundaries section", () => {
+    expect(COORDINATOR_PROMPT).toContain("Coordinator Role Boundaries");
+    expect(COORDINATOR_PROMPT).toMatch(/COORDINATORS NEVER.*EXECUTE.*WORK/i);
+  });
+
+  test("contains MANDATORY review loop section", () => {
+    expect(COORDINATOR_PROMPT).toContain("MANDATORY Review Loop");
+    expect(COORDINATOR_PROMPT).toContain("swarm_review");
+    expect(COORDINATOR_PROMPT).toContain("swarm_review_feedback");
+  });
+
+  test("Phase 1.5 positioned between Phase 1 (Initialize) and Phase 2 (Knowledge)", () => {
+    const phase1Pos = COORDINATOR_PROMPT.indexOf("Phase 1:");
+    const phase15Pos = COORDINATOR_PROMPT.indexOf("Phase 1.5:");
+    const phase2Pos = COORDINATOR_PROMPT.indexOf("Phase 2:");
+
+    expect(phase15Pos).toBeGreaterThan(phase1Pos);
+    expect(phase15Pos).toBeLessThan(phase2Pos);
+  });
+});
+
+describe("formatCoordinatorPrompt", () => {
+  test("function exists and returns string", () => {
+    expect(formatCoordinatorPrompt).toBeDefined();
+    const result = formatCoordinatorPrompt({ task: "test task", projectPath: "/test" });
+    expect(typeof result).toBe("string");
+  });
+
+  test("substitutes {task} placeholder", () => {
+    const result = formatCoordinatorPrompt({ 
+      task: "Implement auth", 
+      projectPath: "/test" 
+    });
+    expect(result).toContain("Implement auth");
+  });
+
+  test("substitutes {project_path} placeholder", () => {
+    const result = formatCoordinatorPrompt({ 
+      task: "test", 
+      projectPath: "/Users/joel/my-project" 
+    });
+    expect(result).toContain("/Users/joel/my-project");
+  });
+
+  test("returns complete prompt with all phases", () => {
+    const result = formatCoordinatorPrompt({ 
+      task: "test", 
+      projectPath: "/test" 
+    });
+    
+    // Should contain all phase headers
+    for (let i = 0; i <= 8; i++) {
+      expect(result).toContain(`Phase ${i}:`);
+    }
+    expect(result).toContain("Phase 1.5:");
+  });
+});