opencode-swarm-plugin 0.38.0 → 0.40.0

package/src/eval-capture.test.ts

@@ -11,8 +11,9 @@ import {
   type CoordinatorSession,
   CoordinatorSessionSchema,
   captureCoordinatorEvent,
+  captureCompactionEvent,
   saveSession,
-} from "./eval-capture.js";
+} from "./eval-capture.ts";
 
 describe("CoordinatorEvent schemas", () => {
   describe("DECISION events", () => {
@@ -81,6 +82,110 @@ describe("CoordinatorEvent schemas", () => {
 
       expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
     });
+
+    test("validates researcher_spawned event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "researcher_spawned",
+        payload: {
+          researcher_id: "BlueLake",
+          research_topic: "Next.js Cache Components",
+          tools_used: ["pdf-brain", "context7"],
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates skill_loaded event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "skill_loaded",
+        payload: {
+          skill_name: "testing-patterns",
+          context: "Adding tests to legacy code",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates inbox_checked event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "inbox_checked",
+        payload: {
+          message_count: 3,
+          urgent_count: 1,
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates blocker_resolved event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "blocker_resolved",
+        payload: {
+          worker_id: "GreenStorm",
+          subtask_id: "bd-123.2",
+          blocker_type: "dependency",
+          resolution: "Unblocked via coordinator action",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates scope_change_approved event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "scope_change_approved",
+        payload: {
+          worker_id: "BlueLake",
+          subtask_id: "bd-123.1",
+          original_scope: "Add auth service",
+          new_scope: "Add auth service + email validation",
+          estimated_time_add: 900000, // 15 min in ms
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates scope_change_rejected event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "scope_change_rejected",
+        payload: {
+          worker_id: "BlueLake",
+          subtask_id: "bd-123.1",
+          requested_scope: "Add auth service + OAuth + SSO",
+          rejection_reason: "Too large for single subtask",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
   });
 
   describe("VIOLATION events", () => {
@@ -214,6 +319,25 @@ describe("CoordinatorEvent schemas", () => {
 
       expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
     });
+
+    test("validates blocker_detected event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "OUTCOME",
+        outcome_type: "blocker_detected",
+        payload: {
+          worker_id: "GreenStorm",
+          subtask_id: "bd-123.2",
+          blocker_type: "dependency",
+          blocker_description: "Waiting for database schema from bd-123.1",
+          reported_at: new Date().toISOString(),
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
   });
 });
 
@@ -336,6 +460,127 @@ describe("captureCoordinatorEvent", () => {
   });
 });
 
+describe("COMPACTION events", () => {
+  test("validates detection_complete event", () => {
+    const event: CoordinatorEvent = {
+      session_id: "test-session",
+      epic_id: "bd-123",
+      timestamp: new Date().toISOString(),
+      event_type: "COMPACTION",
+      compaction_type: "detection_complete",
+      payload: {
+        confidence: "high",
+        context_type: "full",
+        epic_id: "bd-456",
+      },
+    };
+
+    expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+  });
+
+  test("validates prompt_generated event", () => {
+    const event: CoordinatorEvent = {
+      session_id: "test-session",
+      epic_id: "bd-123",
+      timestamp: new Date().toISOString(),
+      event_type: "COMPACTION",
+      compaction_type: "prompt_generated",
+      payload: {
+        prompt_length: 5000,
+        full_prompt: "You are a coordinator...", // Full prompt content captured
+        context_type: "full",
+      },
+    };
+
+    expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+  });
+
+  test("validates context_injected event", () => {
+    const event: CoordinatorEvent = {
+      session_id: "test-session",
+      epic_id: "bd-123",
+      timestamp: new Date().toISOString(),
+      event_type: "COMPACTION",
+      compaction_type: "context_injected",
+      payload: {
+        context_type: "fallback",
+        injected_sections: ["swarm_status", "mandatory_instructions"],
+      },
+    };
+
+    expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+  });
+
+  test("validates resumption_started event", () => {
+    const event: CoordinatorEvent = {
+      session_id: "test-session",
+      epic_id: "bd-123",
+      timestamp: new Date().toISOString(),
+      event_type: "COMPACTION",
+      compaction_type: "resumption_started",
+      payload: {
+        epic_id: "bd-456",
+        agent_role: "coordinator",
+        context_loaded: true,
+      },
+    };
+
+    expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+  });
+
+  test("validates tool_call_tracked event", () => {
+    const event: CoordinatorEvent = {
+      session_id: "test-session",
+      epic_id: "bd-123",
+      timestamp: new Date().toISOString(),
+      event_type: "COMPACTION",
+      compaction_type: "tool_call_tracked",
+      payload: {
+        tool_name: "hive_create_epic",
+        extracted_data: {
+          epic_id: "bd-789",
+          epic_title: "Add auth",
+        },
+      },
+    };
+
+    expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+  });
+
+  test("rejects invalid compaction_type", () => {
+    const event = {
+      session_id: "test-session",
+      epic_id: "bd-123",
+      timestamp: new Date().toISOString(),
+      event_type: "COMPACTION",
+      compaction_type: "invalid_type",
+      payload: {},
+    };
+
+    expect(() => CoordinatorEventSchema.parse(event)).toThrow();
+  });
+
+  test("captures full prompt content without truncation", () => {
+    const longPrompt = "A".repeat(10000); // 10k chars
+    const event: CoordinatorEvent = {
+      session_id: "test-session",
+      epic_id: "bd-123",
+      timestamp: new Date().toISOString(),
+      event_type: "COMPACTION",
+      compaction_type: "prompt_generated",
+      payload: {
+        prompt_length: longPrompt.length,
+        full_prompt: longPrompt,
+        context_type: "full",
+      },
+    };
+
+    expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    expect(event.payload.full_prompt).toBe(longPrompt);
+    expect(event.payload.full_prompt.length).toBe(10000);
+  });
+});
+
 describe("saveSession", () => {
   let sessionDir: string;
   let sessionId: string;
@@ -388,3 +633,383 @@ describe("saveSession", () => {
     expect(session).toBeNull();
   });
 });
+
+describe("session_id propagation from ctx.sessionID", () => {
+  let sessionDir: string;
+  let sessionId: string;
+
+  beforeEach(() => {
+    sessionDir = path.join(os.homedir(), ".config", "swarm-tools", "sessions");
+    sessionId = `test-ctx-${Date.now()}`;
+  });
+
+  afterEach(() => {
+    // Clean up test session file
+    const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+    if (fs.existsSync(sessionPath)) {
+      fs.unlinkSync(sessionPath);
+    }
+  });
+
+  test("session_id should come from ctx.sessionID, not process.env", () => {
+    // GIVEN: process.env.OPENCODE_SESSION_ID is empty (mimics real scenario)
+    const oldEnv = process.env.OPENCODE_SESSION_ID;
+    delete process.env.OPENCODE_SESSION_ID;
+
+    try {
+      // WHEN: captureCoordinatorEvent is called with session_id from ctx.sessionID
+      const event: CoordinatorEvent = {
+        session_id: sessionId, // This should come from ctx.sessionID in call sites
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "strategy_selected",
+        payload: { strategy: "file-based" },
+      };
+
+      captureCoordinatorEvent(event);
+
+      // THEN: Event should be captured with correct session_id
+      const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+      expect(fs.existsSync(sessionPath)).toBe(true);
+
+      const content = fs.readFileSync(sessionPath, "utf-8");
+      const parsed = JSON.parse(content.trim());
+      expect(parsed.session_id).toBe(sessionId);
+      expect(parsed.session_id).not.toBe("unknown");
+    } finally {
+      // Restore env
+      if (oldEnv !== undefined) {
+        process.env.OPENCODE_SESSION_ID = oldEnv;
+      }
+    }
+  });
+
+  test("demonstrates call sites must pass ctx.sessionID not process.env", () => {
+    // GIVEN: This simulates what happens in real call sites
+    const oldEnv = process.env.OPENCODE_SESSION_ID;
+    delete process.env.OPENCODE_SESSION_ID; // Empty in real OpenCode environment
+    
+    try {
+      // WHEN: Call site uses process.env (CURRENT BAD PATTERN)
+      const badSessionId = process.env.OPENCODE_SESSION_ID || "unknown";
+      const badEvent: CoordinatorEvent = {
+        session_id: badSessionId, // This evaluates to "unknown"
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "strategy_selected",
+        payload: { strategy: "file-based" },
+      };
+
+      captureCoordinatorEvent(badEvent);
+
+      // THEN: Event goes to unknown.jsonl (BAD!)
+      const unknownPath = path.join(sessionDir, "unknown.jsonl");
+      expect(fs.existsSync(unknownPath)).toBe(true);
+
+      // WHEN: Call site uses ctx.sessionID (CORRECT PATTERN)
+      const goodEvent: CoordinatorEvent = {
+        session_id: sessionId, // From ctx.sessionID
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "strategy_selected",
+        payload: { strategy: "file-based" },
+      };
+
+      captureCoordinatorEvent(goodEvent);
+
+      // THEN: Event goes to correct session file
+      const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+      expect(fs.existsSync(sessionPath)).toBe(true);
+    } finally {
+      if (oldEnv !== undefined) {
+        process.env.OPENCODE_SESSION_ID = oldEnv;
+      }
+    }
+  });
+
+  test("verifies all call sites now use ctx.sessionID", () => {
+    // This test documents that we've fixed all call sites to use ctx.sessionID
+    // instead of process.env.OPENCODE_SESSION_ID
+    
+    // The fix was applied to:
+    // 1. src/swarm-orchestrate.ts:1743, 1852 - swarm_complete uses _ctx.sessionID
+    // 2. src/swarm-review.ts:515, 565 - swarm_review_feedback uses _ctx.sessionID
+    // 3. src/swarm-decompose.ts:780 - swarm_delegate_planning uses _ctx.sessionID
+    // 4. src/swarm-prompts.ts:1407 - swarm_spawn_subtask uses _ctx.sessionID
+    // 5. src/index.ts:216 - detectCoordinatorViolation uses input.sessionID
+    
+    // With ctx.sessionID, events go to proper session files
+    const oldEnv = process.env.OPENCODE_SESSION_ID;
+    delete process.env.OPENCODE_SESSION_ID;
+    
+    try {
+      // Simulate tool execution with ctx.sessionID
+      const mockCtx = { sessionID: sessionId };
+      
+      const event: CoordinatorEvent = {
+        session_id: mockCtx.sessionID || "unknown",
+        epic_id: "bd-456",
+        timestamp: new Date().toISOString(),
+        event_type: "OUTCOME",
+        outcome_type: "subtask_success",
+        payload: { bead_id: "bd-456.1" },
+      };
+
+      captureCoordinatorEvent(event);
+
+      // Verify event captured with correct session_id
+      const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+      expect(fs.existsSync(sessionPath)).toBe(true);
+      
+      const content = fs.readFileSync(sessionPath, "utf-8");
+      const parsed = JSON.parse(content.trim());
+      expect(parsed.session_id).toBe(sessionId);
+    } finally {
+      if (oldEnv !== undefined) {
+        process.env.OPENCODE_SESSION_ID = oldEnv;
+      }
+    }
+  });
+});
+
+describe("captureCompactionEvent", () => {
+  let sessionDir: string;
+  let sessionId: string;
+
+  beforeEach(() => {
+    sessionDir = path.join(os.homedir(), ".config", "swarm-tools", "sessions");
+    sessionId = `test-compaction-${Date.now()}`;
+  });
+
+  afterEach(() => {
+    // Clean up test session file
+    const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+    if (fs.existsSync(sessionPath)) {
+      fs.unlinkSync(sessionPath);
+    }
+  });
+
+  test("writes detection_complete event to session file", () => {
+    captureCompactionEvent({
+      session_id: sessionId,
+      epic_id: "bd-123",
+      compaction_type: "detection_complete",
+      payload: {
+        confidence: "high",
+        context_type: "full",
+        epic_id: "bd-456",
+      },
+    });
+
+    const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+    expect(fs.existsSync(sessionPath)).toBe(true);
+
+    const content = fs.readFileSync(sessionPath, "utf-8");
+    const lines = content.trim().split("\n");
+    expect(lines).toHaveLength(1);
+
+    const parsed = JSON.parse(lines[0]);
+    expect(parsed.event_type).toBe("COMPACTION");
+    expect(parsed.compaction_type).toBe("detection_complete");
+    expect(parsed.payload.confidence).toBe("high");
+  });
+
+  test("writes prompt_generated event with full prompt content", () => {
+    const fullPrompt = "You are a coordinator agent. ".repeat(200); // ~6k chars
+    
+    captureCompactionEvent({
+      session_id: sessionId,
+      epic_id: "bd-123",
+      compaction_type: "prompt_generated",
+      payload: {
+        prompt_length: fullPrompt.length,
+        full_prompt: fullPrompt,
+        context_type: "full",
+      },
+    });
+
+    const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+    const content = fs.readFileSync(sessionPath, "utf-8");
+    const parsed = JSON.parse(content.trim());
+
+    expect(parsed.payload.full_prompt).toBe(fullPrompt);
+    expect(parsed.payload.full_prompt.length).toBe(fullPrompt.length);
+  });
+
+  test("appends multiple compaction events to same session", () => {
+    captureCompactionEvent({
+      session_id: sessionId,
+      epic_id: "bd-123",
+      compaction_type: "detection_complete",
+      payload: { confidence: "high" },
+    });
+
+    captureCompactionEvent({
+      session_id: sessionId,
+      epic_id: "bd-123",
+      compaction_type: "prompt_generated",
+      payload: { prompt_length: 1000, full_prompt: "test" },
+    });
+
+    const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+    const content = fs.readFileSync(sessionPath, "utf-8");
+    const lines = content.trim().split("\n");
+    expect(lines).toHaveLength(2);
+
+    const event1 = JSON.parse(lines[0]);
+    const event2 = JSON.parse(lines[1]);
+    
+    expect(event1.compaction_type).toBe("detection_complete");
+    expect(event2.compaction_type).toBe("prompt_generated");
+  });
+
+  test("full compaction lifecycle tracking", () => {
+    // Simulate full compaction hook lifecycle
+    const lifecycleEvents = [
+      {
+        compaction_type: "detection_complete" as const,
+        payload: {
+          confidence: "high",
+          context_type: "full",
+          epic_id: "bd-789",
+        },
+      },
+      {
+        compaction_type: "prompt_generated" as const,
+        payload: {
+          prompt_length: 3500,
+          full_prompt: "You are a coordinator agent...",
+          context_type: "full",
+        },
+      },
+      {
+        compaction_type: "context_injected" as const,
+        payload: {
+          context_type: "full",
+          injected_sections: ["swarm_status", "mandatory_instructions"],
+        },
+      },
+      {
+        compaction_type: "resumption_started" as const,
+        payload: {
+          epic_id: "bd-789",
+          agent_role: "coordinator",
+          context_loaded: true,
+        },
+      },
+      {
+        compaction_type: "tool_call_tracked" as const,
+        payload: {
+          tool_name: "hive_create_epic",
+          extracted_data: { epic_id: "bd-789" },
+        },
+      },
+    ];
+
+    // Capture all lifecycle events
+    for (const event of lifecycleEvents) {
+      captureCompactionEvent({
+        session_id: sessionId,
+        epic_id: "bd-123",
+        ...event,
+      });
+    }
+
+    // Verify all events captured
+    const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+    const content = fs.readFileSync(sessionPath, "utf-8");
+    const lines = content.trim().split("\n");
+    expect(lines).toHaveLength(5);
+
+    // Verify lifecycle order
+    const capturedEvents = lines.map((line) => JSON.parse(line));
+    expect(capturedEvents[0].compaction_type).toBe("detection_complete");
+    expect(capturedEvents[1].compaction_type).toBe("prompt_generated");
+    expect(capturedEvents[2].compaction_type).toBe("context_injected");
+    expect(capturedEvents[3].compaction_type).toBe("resumption_started");
+    expect(capturedEvents[4].compaction_type).toBe("tool_call_tracked");
+  });
+});
+
+describe("hive_create_epic integration - decomposition_complete event", () => {
+  let sessionDir: string;
+  let sessionId: string;
+  const testProjectPath = "/tmp/test-epic-decomposition";
+
+  beforeEach(() => {
+    sessionDir = path.join(os.homedir(), ".config", "swarm-tools", "sessions");
+    sessionId = `test-epic-${Date.now()}`;
+  });
+
+  afterEach(() => {
+    // Clean up test session file
+    const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+    if (fs.existsSync(sessionPath)) {
+      fs.unlinkSync(sessionPath);
+    }
+  });
+
+  test("captures decomposition_complete event after hive_create_epic succeeds", async () => {
+    // Test the event capture by calling captureCoordinatorEvent directly
+    // Testing hive_create_epic directly would require full plugin infrastructure
+    
+    // GIVEN: We simulate what hive_create_epic does after epic creation
+    const epicId = `test-epic-${Date.now()}`;
+    const subtasks = [
+      { title: "Subtask 1", files: ["src/a.ts"] },
+      { title: "Subtask 2", files: ["src/b.ts", "src/c.ts"] },
+      { title: "Subtask 3", files: ["src/d.ts"] },
+    ];
+    
+    // Build files_per_subtask map (same logic as hive.ts)
+    const filesPerSubtask: Record<number, string[]> = {};
+    subtasks.forEach((subtask, index) => {
+      if (subtask.files && subtask.files.length > 0) {
+        filesPerSubtask[index] = subtask.files;
+      }
+    });
+
+    // WHEN: decomposition_complete event is captured
+    captureCoordinatorEvent({
+      session_id: sessionId,
+      epic_id: epicId,
+      timestamp: new Date().toISOString(),
+      event_type: "DECISION",
+      decision_type: "decomposition_complete",
+      payload: {
+        subtask_count: subtasks.length,
+        strategy_used: "file-based",
+        files_per_subtask: filesPerSubtask,
+        epic_title: "Test Epic for Event Capture",
+        task: "Original task description",
+      },
+    });
+
+    // THEN: Event should be written to session file
+    const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+    expect(fs.existsSync(sessionPath)).toBe(true);
+
+    const content = fs.readFileSync(sessionPath, "utf-8");
+    const lines = content.trim().split("\n").filter(Boolean);
+    expect(lines.length).toBe(1);
+
+    // Verify event structure
+    const event = JSON.parse(lines[0]);
+    expect(event.session_id).toBe(sessionId);
+    expect(event.epic_id).toBe(epicId);
+    expect(event.event_type).toBe("DECISION");
+    expect(event.decision_type).toBe("decomposition_complete");
+    expect(event.payload.subtask_count).toBe(3);
+    expect(event.payload.strategy_used).toBe("file-based");
+    expect(event.payload.files_per_subtask).toEqual({
+      0: ["src/a.ts"],
+      1: ["src/b.ts", "src/c.ts"],
+      2: ["src/d.ts"],
+    });
+    expect(event.payload.epic_title).toBe("Test Epic for Event Capture");
+    expect(event.payload.task).toBe("Original task description");
+  });
+});