opencode-swarm-plugin 0.38.0 → 0.39.1

package/src/compaction-capture.integration.test.ts

@@ -0,0 +1,257 @@
+/**
+ * Integration test for compaction event capture
+ * 
+ * Verifies that captureCompactionEvent writes events to session JSONL
+ * and that all event types are captured with correct data.
+ */
+
+import { describe, expect, it, afterAll } from "bun:test";
+import { existsSync, unlinkSync } from "node:fs";
+import {
+  captureCompactionEvent,
+  readSessionEvents,
+  getSessionPath,
+} from "./eval-capture";
+
+describe("Compaction Event Capture Integration", () => {
+  const testSessionId = `test-compaction-${Date.now()}`;
+  const sessionPath = getSessionPath(testSessionId);
+
+  afterAll(() => {
+    // Clean up test session file
+    if (existsSync(sessionPath)) {
+      unlinkSync(sessionPath);
+    }
+  });
+
+  it("captures detection_complete event with confidence and reasons", () => {
+    captureCompactionEvent({
+      session_id: testSessionId,
+      epic_id: "bd-test-123",
+      compaction_type: "detection_complete",
+      payload: {
+        confidence: "high",
+        detected: true,
+        reasons: ["3 cells in_progress", "2 open subtasks"],
+        session_scan_contributed: true,
+        session_scan_reasons: ["swarm tool calls found in session"],
+        epic_id: "bd-test-123",
+        epic_title: "Test Epic",
+        subtask_count: 5,
+      },
+    });
+
+    // Verify event was written to session file
+    expect(existsSync(sessionPath)).toBe(true);
+
+    // Read events from session
+    const events = readSessionEvents(testSessionId);
+    expect(events.length).toBe(1);
+
+    const event = events[0];
+    expect(event.session_id).toBe(testSessionId);
+    expect(event.epic_id).toBe("bd-test-123");
+    expect(event.event_type).toBe("COMPACTION");
+    expect(event.compaction_type).toBe("detection_complete");
+    
+    // Verify payload structure
+    expect(event.payload.confidence).toBe("high");
+    expect(event.payload.detected).toBe(true);
+    expect(event.payload.reasons).toEqual(["3 cells in_progress", "2 open subtasks"]);
+    expect(event.payload.epic_id).toBe("bd-test-123");
+    expect(event.payload.epic_title).toBe("Test Epic");
+    expect(event.payload.subtask_count).toBe(5);
+  });
+
+  it("captures prompt_generated event with FULL prompt content", () => {
+    const fullPrompt = `
+┌─────────────────────────────────────────┐
+│   🐝  YOU ARE THE COORDINATOR  🐝       │
+└─────────────────────────────────────────┘
+
+# Swarm Continuation
+
+**NON-NEGOTIABLE: YOU ARE THE COORDINATOR.**
+
+## Epic State
+**ID:** bd-epic-456
+**Title:** Refactor authentication
+**Status:** 2/5 subtasks complete
+
+## Next Actions
+1. Check swarm_status(epic_id="bd-epic-456")
+2. Review completed work
+3. Spawn remaining subtasks
+`.trim();
+
+    captureCompactionEvent({
+      session_id: testSessionId,
+      epic_id: "bd-epic-456",
+      compaction_type: "prompt_generated",
+      payload: {
+        prompt_length: fullPrompt.length,
+        full_prompt: fullPrompt, // FULL content, not truncated
+        context_type: "llm_generated",
+        duration_ms: 1234,
+      },
+    });
+
+    const events = readSessionEvents(testSessionId);
+    const promptEvent = events.find((e) => e.compaction_type === "prompt_generated");
+    
+    expect(promptEvent).toBeDefined();
+    if (promptEvent) {
+      expect(promptEvent.payload.full_prompt).toBe(fullPrompt);
+      expect(promptEvent.payload.prompt_length).toBe(fullPrompt.length);
+      expect(promptEvent.payload.context_type).toBe("llm_generated");
+      expect(promptEvent.payload.duration_ms).toBe(1234);
+    }
+  });
+
+  it("captures context_injected event with FULL content", () => {
+    const fullContent = `[Swarm compaction: LLM-generated, high confidence]
+
+# 🐝 Swarm State
+
+**Epic:** bd-epic-789 - Add user permissions
+**Project:** /Users/test/project
+
+**Subtasks:**
+  - 2 closed
+  - 1 in_progress
+  - 2 open
+
+## COORDINATOR MANDATES
+
+⛔ NEVER use edit/write directly - SPAWN A WORKER
+✅ ALWAYS use swarm_spawn_subtask for implementation
+✅ ALWAYS review with swarm_review
+`;
+
+    captureCompactionEvent({
+      session_id: testSessionId,
+      epic_id: "bd-epic-789",
+      compaction_type: "context_injected",
+      payload: {
+        full_content: fullContent, // FULL content, not truncated
+        content_length: fullContent.length,
+        injection_method: "output.prompt",
+        context_type: "llm_generated",
+      },
+    });
+
+    const events = readSessionEvents(testSessionId);
+    const injectEvent = events.find((e) => e.compaction_type === "context_injected");
+    
+    expect(injectEvent).toBeDefined();
+    if (injectEvent) {
+      expect(injectEvent.payload.full_content).toBe(fullContent);
+      expect(injectEvent.payload.content_length).toBe(fullContent.length);
+      expect(injectEvent.payload.injection_method).toBe("output.prompt");
+      expect(injectEvent.payload.context_type).toBe("llm_generated");
+    }
+  });
+
+  it("captures all three event types in sequence", () => {
+    const sequenceSessionId = `test-sequence-${Date.now()}`;
+    const sequencePath = getSessionPath(sequenceSessionId);
+
+    try {
+      // Simulate compaction lifecycle
+      
+      // 1. Detection
+      captureCompactionEvent({
+        session_id: sequenceSessionId,
+        epic_id: "bd-seq-123",
+        compaction_type: "detection_complete",
+        payload: {
+          confidence: "medium",
+          detected: true,
+          reasons: ["1 unclosed epic"],
+        },
+      });
+
+      // 2. Prompt generation
+      captureCompactionEvent({
+        session_id: sequenceSessionId,
+        epic_id: "bd-seq-123",
+        compaction_type: "prompt_generated",
+        payload: {
+          full_prompt: "Test prompt content",
+          prompt_length: 19,
+        },
+      });
+
+      // 3. Context injection
+      captureCompactionEvent({
+        session_id: sequenceSessionId,
+        epic_id: "bd-seq-123",
+        compaction_type: "context_injected",
+        payload: {
+          full_content: "Test context content",
+          content_length: 20,
+        },
+      });
+
+      // Verify all three events captured
+      const events = readSessionEvents(sequenceSessionId);
+      expect(events.length).toBe(3);
+
+      const types = events.map((e) => e.compaction_type);
+      expect(types).toContain("detection_complete");
+      expect(types).toContain("prompt_generated");
+      expect(types).toContain("context_injected");
+
+      // Verify order (chronological by timestamp)
+      const timestamps = events.map((e) => new Date(e.timestamp).getTime());
+      expect(timestamps[0]).toBeLessThanOrEqual(timestamps[1]);
+      expect(timestamps[1]).toBeLessThanOrEqual(timestamps[2]);
+    } finally {
+      // Clean up
+      if (existsSync(sequencePath)) {
+        unlinkSync(sequencePath);
+      }
+    }
+  });
+
+  it("validates event schema with Zod", () => {
+    // This should not throw - captureCompactionEvent validates internally
+    expect(() => {
+      captureCompactionEvent({
+        session_id: testSessionId,
+        epic_id: "bd-validate-123",
+        compaction_type: "detection_complete",
+        payload: { confidence: "high" },
+      });
+    }).not.toThrow();
+  });
+
+  it("rejects invalid compaction_type", () => {
+    expect(() => {
+      captureCompactionEvent({
+        session_id: testSessionId,
+        epic_id: "bd-invalid-123",
+        // @ts-expect-error - intentionally invalid type
+        compaction_type: "invalid_type",
+        payload: {},
+      });
+    }).toThrow();
+  });
+
+  it("handles empty epic_id gracefully", () => {
+    captureCompactionEvent({
+      session_id: testSessionId,
+      epic_id: "unknown",
+      compaction_type: "detection_complete",
+      payload: {
+        confidence: "none",
+        detected: false,
+        reasons: [],
+      },
+    });
+
+    const events = readSessionEvents(testSessionId);
+    const unknownEvent = events.find((e) => e.epic_id === "unknown");
+    expect(unknownEvent).toBeDefined();
+  });
+});

package/src/compaction-hook.test.ts

@@ -85,6 +85,48 @@ describe("Compaction Hook", () => {
       expect(SWARM_COMPACTION_CONTEXT).toContain("Blocked:");
       expect(SWARM_COMPACTION_CONTEXT).toContain("Completed:");
     });
+
+    // NEW: Full coordinator workflow must be present post-compaction
+    it("contains FULL coordinator workflow phases", () => {
+      // Phase 1.5: Research Phase
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarm_spawn_researcher");
+      
+      // Phase 3: Decompose
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarm_select_strategy");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarm_plan_prompt");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarm_validate_decomposition");
+      
+      // Phase 4: Create Cells
+      expect(SWARM_COMPACTION_CONTEXT).toContain("hive_create_epic");
+      
+      // Phase 6: Spawn Workers
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarm_spawn_subtask");
+      
+      // Phase 7: Review Loop
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarm_review");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarm_review_feedback");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("swarm_spawn_retry");
+    });
+
+    it("contains forbidden tools section with ALL forbidden tools", () => {
+      // Repository fetching
+      expect(SWARM_COMPACTION_CONTEXT).toContain("repo-crawl_file");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("repo-autopsy");
+      
+      // Web/documentation fetching
+      expect(SWARM_COMPACTION_CONTEXT).toContain("webfetch");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("fetch_fetch");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("context7");
+      
+      // Knowledge base
+      expect(SWARM_COMPACTION_CONTEXT).toContain("pdf-brain");
+    });
+
+    it("contains strategy reference table", () => {
+      expect(SWARM_COMPACTION_CONTEXT).toContain("file-based");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("feature-based");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("risk-based");
+    });
   });
 
   describe("SWARM_DETECTION_FALLBACK", () => {

package/src/compaction-hook.ts

@@ -163,6 +163,87 @@ Extract from session context:
 - **Review work** - Use \`swarm_review\` and \`swarm_review_feedback\` for completed work
 - **Close the loop** - When all subtasks done, verify and close the epic
 
+**You are the COORDINATOR. You orchestrate. You do NOT implement. Spawn workers.**
+
+---
+
+## 📋 FULL COORDINATOR WORKFLOW (Reference)
+
+You are ALWAYS swarming. Here is the complete workflow for any new work:
+
+### Phase 1.5: Research Phase (FOR COMPLEX TASKS)
+
+**If the task requires understanding unfamiliar technologies, spawn a researcher FIRST:**
+
+\`\`\`
+swarm_spawn_researcher(
+  research_id="research-<topic>",
+  epic_id="<epic-id>",
+  tech_stack=["<technology>"],
+  project_path="<path>"
+)
+// Then spawn with Task(subagent_type="swarm/researcher", prompt="<from above>")
+\`\`\`
+
+### Phase 2: Knowledge Gathering
+
+\`\`\`
+semantic-memory_find(query="<task keywords>", limit=5)   # Past learnings
+cass_search(query="<task description>", limit=5)         # Similar past tasks  
+skills_list()                                            # Available skills
+\`\`\`
+
+### Phase 3: Decompose
+
+\`\`\`
+swarm_select_strategy(task="<task>")
+swarm_plan_prompt(task="<task>", context="<synthesized knowledge>")
+swarm_validate_decomposition(response="<CellTree JSON>")
+\`\`\`
+
+### Phase 4: Create Cells
+
+\`hive_create_epic(epic_title="<task>", subtasks=[...])\`
+
+### Phase 5: DO NOT Reserve Files
+
+> **⚠️ Coordinator NEVER reserves files.** Workers reserve their own files.
+
+### Phase 6: Spawn Workers
+
+\`\`\`
+swarm_spawn_subtask(bead_id, epic_id, title, files, shared_context, project_path)
+Task(subagent_type="swarm/worker", prompt="<from above>")
+\`\`\`
+
+### Phase 7: MANDATORY Review Loop
+
+**AFTER EVERY Task() RETURNS:**
+
+1. \`swarmmail_inbox()\` - Check for messages
+2. \`swarm_review(project_key, epic_id, task_id, files_touched)\` - Generate review
+3. Evaluate against epic goals
+4. \`swarm_review_feedback(project_key, task_id, worker_id, status, issues)\`
+
+**If needs_changes:**
+\`\`\`
+swarm_spawn_retry(bead_id, epic_id, original_prompt, attempt, issues, diff, files, project_path)
+// Spawn NEW worker with Task() using retry prompt
+// Max 3 attempts before marking task blocked
+\`\`\`
+
+### Phase 8: Complete
+
+\`hive_sync()\` - Sync all cells to git
+
+## Strategy Reference
+
+| Strategy       | Best For                 | Keywords                               |
+| -------------- | ------------------------ | -------------------------------------- |
+| file-based     | Refactoring, migrations  | refactor, migrate, rename, update all  |
+| feature-based  | New features             | add, implement, build, create, feature |
+| risk-based     | Bug fixes, security      | fix, bug, security, critical, urgent   |
+
 **You are the COORDINATOR. You orchestrate. You do NOT implement. Spawn workers.**
 `;
 

package/src/compaction-prompt-scorers.test.ts

@@ -0,0 +1,299 @@
+/**
+ * Tests for compaction prompt quality scorers
+ *
+ * TDD approach - tests written FIRST to define scorer behavior
+ * Tests the PURE scoring functions (not evalite wrappers)
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { CompactionPrompt } from "./compaction-prompt-scoring.js";
+import {
+	scoreActionability,
+	scoreCoordinatorIdentity,
+	scoreEpicIdSpecificity,
+	scoreForbiddenToolsPresent,
+	scorePostCompactionDiscipline,
+} from "./compaction-prompt-scoring.js";
+
+describe("epicIdSpecificity scorer", () => {
+	test("scores 1.0 for real epic IDs", () => {
+		const prompt: CompactionPrompt = {
+			content: "Continue coordinating epic mjkw81rkq4c",
+		};
+
+		const result = scoreEpicIdSpecificity(prompt);
+
+		expect(result.score).toBe(1.0);
+		expect(result.message).toContain("real epic ID");
+	});
+
+	test("scores 0.0 for placeholder IDs like <epic-id>", () => {
+		const prompt: CompactionPrompt = {
+			content: "Continue coordinating epic <epic-id>",
+		};
+
+		const result = scoreEpicIdSpecificity(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("placeholder");
+	});
+
+	test("scores 0.0 for bd-xxx placeholders", () => {
+		const prompt: CompactionPrompt = {
+			content: "Check status of bd-xxx",
+		};
+
+		const result = scoreEpicIdSpecificity(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("placeholder");
+	});
+
+	test("scores 0.0 for generic <path> placeholders", () => {
+		const prompt: CompactionPrompt = {
+			content: "Project at <path>",
+		};
+
+		const result = scoreEpicIdSpecificity(prompt);
+
+		expect(result.score).toBe(0.0);
+	});
+
+	test("scores 0.0 when no epic ID found", () => {
+		const prompt: CompactionPrompt = {
+			content: "Continue working on the task",
+		};
+
+		const result = scoreEpicIdSpecificity(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("No epic ID");
+	});
+});
+
+describe("actionability scorer", () => {
+	test("scores 1.0 when swarm_status has real epic ID", () => {
+		const prompt: CompactionPrompt = {
+			content: `First action:
+swarm_status(epic_id='mjkw81rkq4c', project_key='/path/to/project')`,
+		};
+
+		const result = scoreActionability(prompt);
+
+		expect(result.score).toBe(1.0);
+		expect(result.message).toContain("actionable tool call");
+	});
+
+	test("scores 1.0 when swarmmail_inbox is present", () => {
+		const prompt: CompactionPrompt = {
+			content: `Check messages:
+swarmmail_inbox()`,
+		};
+
+		const result = scoreActionability(prompt);
+
+		expect(result.score).toBe(1.0);
+		expect(result.message).toContain("actionable tool call");
+	});
+
+	test("scores 0.0 for generic instructions without tool calls", () => {
+		const prompt: CompactionPrompt = {
+			content: "Check the status of workers and review progress",
+		};
+
+		const result = scoreActionability(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("No actionable");
+	});
+
+	test("scores 0.0 for swarm_status with placeholders", () => {
+		const prompt: CompactionPrompt = {
+			content: `swarm_status(epic_id='<epic-id>', project_key='<path>')`,
+		};
+
+		const result = scoreActionability(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("placeholder");
+	});
+});
+
+describe("coordinatorIdentity scorer", () => {
+	test("scores 1.0 with ASCII header and strong mandates", () => {
+		const prompt: CompactionPrompt = {
+			content: `┌─────────────────────────────────────────┐
+│     YOU ARE THE COORDINATOR             │
+│                                         │
+│  NEVER spawn workers yourself           │
+│  ALWAYS review worker output            │
+└─────────────────────────────────────────┘
+
+Continue coordinating the swarm.`,
+		};
+
+		const result = scoreCoordinatorIdentity(prompt);
+
+		expect(result.score).toBe(1.0);
+		expect(result.message).toContain("ASCII header");
+		expect(result.message).toContain("strong mandates");
+	});
+
+	test("scores 0.5 with ASCII header but weak language", () => {
+		const prompt: CompactionPrompt = {
+			content: `┌─────────────────────────────────────────┐
+│     COORDINATOR MODE                    │
+└─────────────────────────────────────────┘
+
+You should consider delegating work.`,
+		};
+
+		const result = scoreCoordinatorIdentity(prompt);
+
+		expect(result.score).toBe(0.5);
+		expect(result.message).toContain("weak language");
+	});
+
+	test("scores 0.0 without ASCII header", () => {
+		const prompt: CompactionPrompt = {
+			content: `You are the coordinator. NEVER do work directly. ALWAYS delegate.`,
+		};
+
+		const result = scoreCoordinatorIdentity(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("No ASCII header");
+	});
+});
+
+describe("forbiddenToolsPresent scorer", () => {
+	test("scores 1.0 when all forbidden tools listed", () => {
+		const prompt: CompactionPrompt = {
+			content: `🚫 FORBIDDEN TOOLS - NEVER call these:
+- Edit (use swarm_spawn_subtask)
+- Write (use swarm_spawn_subtask)
+- swarmmail_reserve (only workers reserve)
+- bash with git commit (workers commit)`,
+		};
+
+		const result = scoreForbiddenToolsPresent(prompt);
+
+		expect(result.score).toBe(1.0);
+		expect(result.message).toContain("All 4 forbidden tools");
+	});
+
+	test("scores 0.75 when 3 out of 4 tools listed", () => {
+		const prompt: CompactionPrompt = {
+			content: `🚫 FORBIDDEN TOOLS:
+- Edit
+- Write
+- swarmmail_reserve`,
+		};
+
+		const result = scoreForbiddenToolsPresent(prompt);
+
+		expect(result.score).toBe(0.75);
+		expect(result.message).toContain("3/4");
+	});
+
+	test("scores 0.5 when 2 out of 4 tools listed", () => {
+		const prompt: CompactionPrompt = {
+			content: `Don't use Edit or Write directly.`,
+		};
+
+		const result = scoreForbiddenToolsPresent(prompt);
+
+		expect(result.score).toBe(0.5);
+		expect(result.message).toContain("2/4");
+	});
+
+	test("scores 0.0 when no forbidden tools listed", () => {
+		const prompt: CompactionPrompt = {
+			content: "Continue coordinating the epic",
+		};
+
+		const result = scoreForbiddenToolsPresent(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("0/4");
+	});
+});
+
+describe("postCompactionDiscipline scorer", () => {
+	test("scores 1.0 when first tool is swarm_status", () => {
+		const prompt: CompactionPrompt = {
+			content: `Resume coordination:
+
+1. swarm_status(epic_id='mjkw81rkq4c')
+2. Check inbox
+3. Review progress`,
+		};
+
+		const result = scorePostCompactionDiscipline(prompt);
+
+		expect(result.score).toBe(1.0);
+		expect(result.message).toContain("swarm_status");
+		expect(result.message).toContain("correct");
+	});
+
+	test("scores 1.0 when first tool is swarmmail_inbox", () => {
+		const prompt: CompactionPrompt = {
+			content: `Next steps:
+1. swarmmail_inbox()
+2. Review messages`,
+		};
+
+		const result = scorePostCompactionDiscipline(prompt);
+
+		expect(result.score).toBe(1.0);
+		expect(result.message).toContain("inbox");
+		expect(result.message).toContain("correct");
+	});
+
+	test("scores 0.0 when first tool is Edit", () => {
+		const prompt: CompactionPrompt = {
+			content: `Resume:
+1. Edit(file='src/auth.ts', ...)
+2. Check status`,
+		};
+
+		const result = scorePostCompactionDiscipline(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("Edit");
+	});
+
+	test("scores 0.0 when first tool is Write", () => {
+		const prompt: CompactionPrompt = {
+			content: `1. Write(file='README.md', ...)`,
+		};
+
+		const result = scorePostCompactionDiscipline(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("Write");
+	});
+
+	test("scores 0.0 when first tool is Read", () => {
+		const prompt: CompactionPrompt = {
+			content: `1. Read(file='src/index.ts')
+2. swarm_status()`,
+		};
+
+		const result = scorePostCompactionDiscipline(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("Read");
+	});
+
+	test("scores 0.0 when no tool calls mentioned", () => {
+		const prompt: CompactionPrompt = {
+			content: "Continue coordinating the epic",
+		};
+
+		const result = scorePostCompactionDiscipline(prompt);
+
+		expect(result.score).toBe(0.0);
+		expect(result.message).toContain("No tool");
+	});
+});