opencode-swarm-plugin 0.38.0 → 0.39.1

package/src/eval-capture.test.ts

@@ -11,6 +11,7 @@ import {
   type CoordinatorSession,
   CoordinatorSessionSchema,
   captureCoordinatorEvent,
+  captureCompactionEvent,
   saveSession,
 } from "./eval-capture.js";
 
@@ -336,6 +337,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 +510,303 @@ 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");
+  });
+});

package/src/eval-capture.ts

@@ -9,9 +9,15 @@
  * 2. swarm_complete captures: outcome signals per subtask
  * 3. swarm_record_outcome captures: learning signals
  * 4. Human feedback (optional): accept/reject/modify
- * 5. Coordinator events: decisions, violations, outcomes
+ * 5. Coordinator events: decisions, violations, outcomes, compaction
  * 6. Session capture: full coordinator session to ~/.config/swarm-tools/sessions/
  *
+ * Event types:
+ * - DECISION: strategy_selected, worker_spawned, review_completed, decomposition_complete
+ * - VIOLATION: coordinator_edited_file, coordinator_ran_tests, coordinator_reserved_files, no_worker_spawned
+ * - OUTCOME: subtask_success, subtask_retry, subtask_failed, epic_complete
+ * - COMPACTION: detection_complete, prompt_generated, context_injected, resumption_started, tool_call_tracked
+ *
  * @module eval-capture
  */
 import * as fs from "node:fs";
@@ -123,7 +129,7 @@ export type PartialEvalRecord = Partial<EvalRecord> & {
 };
 
 /**
- * Coordinator Event - captures coordinator decisions, violations, and outcomes
+ * Coordinator Event - captures coordinator decisions, violations, outcomes, and compaction
  */
 export const CoordinatorEventSchema = z.discriminatedUnion("event_type", [
   // DECISION events
@@ -168,6 +174,21 @@ export const CoordinatorEventSchema = z.discriminatedUnion("event_type", [
     ]),
     payload: z.any(),
   }),
+  // COMPACTION events
+  z.object({
+    session_id: z.string(),
+    epic_id: z.string(),
+    timestamp: z.string(),
+    event_type: z.literal("COMPACTION"),
+    compaction_type: z.enum([
+      "detection_complete",
+      "prompt_generated",
+      "context_injected",
+      "resumption_started",
+      "tool_call_tracked",
+    ]),
+    payload: z.any(),
+  }),
 ]);
 export type CoordinatorEvent = z.infer<typeof CoordinatorEventSchema>;
 
@@ -595,6 +616,77 @@ export function captureCoordinatorEvent(event: CoordinatorEvent): void {
   fs.appendFileSync(sessionPath, line, "utf-8");
 }
 
+/**
+ * Capture a compaction event to the session file
+ *
+ * Helper for capturing COMPACTION events with automatic timestamp generation.
+ * Tracks compaction hook lifecycle: detection → prompt generation → context injection → resumption.
+ *
+ * **Part of eval-driven development pipeline:** Compaction events are used by `compaction-prompt.eval.ts`
+ * to score prompt quality (ID specificity, actionability, coordinator identity).
+ *
+ * **Lifecycle stages:**
+ * - `detection_complete` - Compaction detected (confidence level, context type)
+ * - `prompt_generated` - Continuation prompt created (FULL content stored for eval)
+ * - `context_injected` - Prompt injected into OpenCode context
+ * - `resumption_started` - Coordinator resumed from checkpoint
+ * - `tool_call_tracked` - First tool called post-compaction (measures discipline)
+ *
+ * @param params - Compaction event parameters
+ * @param params.session_id - Coordinator session ID
+ * @param params.epic_id - Epic ID being coordinated
+ * @param params.compaction_type - Stage of compaction lifecycle
+ * @param params.payload - Event-specific data (full prompt content, detection results, etc.)
+ *
+ * @example
+ * // Capture detection complete
+ * captureCompactionEvent({
+ *   session_id: "session-123",
+ *   epic_id: "bd-456",
+ *   compaction_type: "detection_complete",
+ *   payload: {
+ *     confidence: "high",
+ *     context_type: "full",
+ *     epic_id: "bd-456",
+ *   },
+ * });
+ *
+ * @example
+ * // Capture prompt generated (with full content for eval)
+ * captureCompactionEvent({
+ *   session_id: "session-123",
+ *   epic_id: "bd-456",
+ *   compaction_type: "prompt_generated",
+ *   payload: {
+ *     prompt_length: 5000,
+ *     full_prompt: "You are a coordinator...", // Full prompt, not truncated - used for quality scoring
+ *     context_type: "full",
+ *   },
+ * });
+ */
+export function captureCompactionEvent(params: {
+  session_id: string;
+  epic_id: string;
+  compaction_type:
+    | "detection_complete"
+    | "prompt_generated"
+    | "context_injected"
+    | "resumption_started"
+    | "tool_call_tracked";
+  payload: any;
+}): void {
+  const event: CoordinatorEvent = {
+    session_id: params.session_id,
+    epic_id: params.epic_id,
+    timestamp: new Date().toISOString(),
+    event_type: "COMPACTION",
+    compaction_type: params.compaction_type,
+    payload: params.payload,
+  };
+
+  captureCoordinatorEvent(event);
+}
+
 /**
  * Read all events from a session file
  */