opencode-swarm-plugin 0.36.0 → 0.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.36.0",
+  "version": "0.37.0",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "./dist/index.js",
@@ -41,7 +41,7 @@
     "minimatch": "^10.1.1",
     "pino": "^9.6.0",
     "pino-roll": "^1.3.0",
-    "swarm-mail": "1.5.0",
+    "swarm-mail": "1.5.1",
     "yaml": "^2.8.2",
     "zod": "4.1.8"
   },

package/src/compaction-hook.test.ts

@@ -64,7 +64,14 @@ describe("Compaction Hook", () => {
   describe("SWARM_COMPACTION_CONTEXT", () => {
     it("contains coordinator instructions", () => {
       expect(SWARM_COMPACTION_CONTEXT).toContain("COORDINATOR");
-      expect(SWARM_COMPACTION_CONTEXT).toContain("Keep Cooking");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("You Are The COORDINATOR");
+    });
+
+    it("contains prohibition-first anti-patterns", () => {
+      expect(SWARM_COMPACTION_CONTEXT).toContain("NEVER");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("edit");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("write");
+      expect(SWARM_COMPACTION_CONTEXT).toContain("SPAWN A WORKER");
     });
 
     it("contains resume instructions", () => {

package/src/compaction-hook.ts

@@ -68,11 +68,31 @@ function getLog() {
  * This is NOT about preserving state for a human - it's about the swarm continuing
  * autonomously after context compression.
  */
-export const SWARM_COMPACTION_CONTEXT = `## 🐝 SWARM ACTIVE - Keep Cooking
+export const SWARM_COMPACTION_CONTEXT = `## 🐝 SWARM ACTIVE - You Are The COORDINATOR
 
-You are the **COORDINATOR** of an active swarm. Context was compacted but the swarm is still running.
+Context was compacted but the swarm is still running. You are the **COORDINATOR**.
 
-**YOUR JOB:** Keep orchestrating. Spawn agents. Monitor progress. Unblock work. Ship it.
+### ⛔ NEVER DO THESE (Coordinator Anti-Patterns)
+
+**CRITICAL: Coordinators NEVER do implementation work. ALWAYS spawn workers.**
+
+- ❌ **NEVER** use \`edit\` or \`write\` tools - SPAWN A WORKER
+- ❌ **NEVER** run tests with \`bash\` - SPAWN A WORKER  
+- ❌ **NEVER** implement features yourself - SPAWN A WORKER
+- ❌ **NEVER** "just do it myself to save time" - NO. SPAWN A WORKER.
+- ❌ **NEVER** reserve files with \`swarmmail_reserve\` - Workers reserve files
+
+**If you catch yourself about to edit a file, STOP. Use \`swarm_spawn_subtask\` instead.**
+
+### ✅ ALWAYS DO THESE (Coordinator Checklist)
+
+On resume, execute this checklist IN ORDER:
+
+1. \`swarm_status(epic_id="<epic>", project_key="<path>")\` - Get current state
+2. \`swarmmail_inbox(limit=5)\` - Check for agent messages
+3. For completed work: \`swarm_review\` → \`swarm_review_feedback\`
+4. For open subtasks: \`swarm_spawn_subtask\` (NOT "do it yourself")
+5. For blocked work: Investigate, unblock, reassign
 
 ### Preserve in Summary
 
@@ -89,41 +109,31 @@ Extract from session context:
 \`\`\`
 ## 🐝 Swarm State
 
-**Epic:** <bd-xxx> - <title>
+**Epic:** <cell-xxx> - <title>
 **Project:** <path>
 **Progress:** X/Y subtasks complete
 
 **Active:**
-- <bd-xxx>: <title> [in_progress] → <agent> working on <files>
+- <cell-xxx>: <title> [in_progress] → <agent> working on <files>
 
 **Blocked:**
-- <bd-xxx>: <title> - BLOCKED: <reason>
+- <cell-xxx>: <title> - BLOCKED: <reason>
 
 **Completed:**
-- <bd-xxx>: <title> ✓
+- <cell-xxx>: <title> ✓
 
 **Ready to Spawn:**
-- <bd-xxx>: <title> (files: <...>)
+- <cell-xxx>: <title> (files: <...>)
 \`\`\`
 
-### On Resume - IMMEDIATELY
-
-1. \`swarm_status(epic_id="<epic>", project_key="<path>")\` - Get current state
-2. \`swarmmail_inbox(limit=5)\` - Check for agent messages
-3. \`swarm_review(project_key, epic_id, task_id, files_touched)\` - Review any completed work
-4. \`swarm_review_feedback(project_key, task_id, worker_id, status, issues)\` - Approve or request changes
-5. **Spawn ready subtasks** - Don't wait, fire them off
-6. **Unblock blocked work** - Resolve dependencies, reassign if needed
-7. **Collect completed work** - Close done subtasks, verify quality
-
-### Keep the Swarm Cooking
+### Your Role
 
 - **Spawn aggressively** - If a subtask is ready and unblocked, spawn an agent
 - **Monitor actively** - Check status, read messages, respond to blockers
+- **Review work** - Use \`swarm_review\` and \`swarm_review_feedback\` for completed work
 - **Close the loop** - When all subtasks done, verify and close the epic
-- **Don't stop** - The swarm runs until the epic is closed
 
-**You are not waiting for instructions. You are the coordinator. Coordinate.**
+**You are the COORDINATOR. You orchestrate. You do NOT implement. Spawn workers.**
 `;
 
 /**

package/src/eval-capture.test.ts

@@ -0,0 +1,390 @@
+/**
+ * Tests for eval-capture coordinator event schemas and session capture
+ */
+import { type Mock, afterEach, beforeEach, describe, expect, test } from "bun:test";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import {
+  type CoordinatorEvent,
+  CoordinatorEventSchema,
+  type CoordinatorSession,
+  CoordinatorSessionSchema,
+  captureCoordinatorEvent,
+  saveSession,
+} from "./eval-capture.js";
+
+describe("CoordinatorEvent schemas", () => {
+  describe("DECISION events", () => {
+    test("validates strategy_selected event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "strategy_selected",
+        payload: {
+          strategy: "file-based",
+          reasoning: "Files are well isolated",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates worker_spawned event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "worker_spawned",
+        payload: {
+          worker_id: "GreenStorm",
+          subtask_id: "bd-123.1",
+          files: ["src/test.ts"],
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates review_completed event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "review_completed",
+        payload: {
+          subtask_id: "bd-123.1",
+          approved: true,
+          issues_found: 0,
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates decomposition_complete event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "DECISION",
+        decision_type: "decomposition_complete",
+        payload: {
+          subtask_count: 3,
+          strategy: "feature-based",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+  });
+
+  describe("VIOLATION events", () => {
+    test("validates coordinator_edited_file event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "VIOLATION",
+        violation_type: "coordinator_edited_file",
+        payload: {
+          file: "src/bad.ts",
+          operation: "edit",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates coordinator_ran_tests event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "VIOLATION",
+        violation_type: "coordinator_ran_tests",
+        payload: {
+          command: "bun test",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates coordinator_reserved_files event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "VIOLATION",
+        violation_type: "coordinator_reserved_files",
+        payload: {
+          files: ["src/auth.ts"],
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates no_worker_spawned event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "VIOLATION",
+        violation_type: "no_worker_spawned",
+        payload: {
+          subtask_id: "bd-123.1",
+          reason: "Did work directly",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+  });
+
+  describe("OUTCOME events", () => {
+    test("validates subtask_success event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "OUTCOME",
+        outcome_type: "subtask_success",
+        payload: {
+          subtask_id: "bd-123.1",
+          duration_ms: 45000,
+          files_touched: ["src/auth.ts"],
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates subtask_retry event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "OUTCOME",
+        outcome_type: "subtask_retry",
+        payload: {
+          subtask_id: "bd-123.1",
+          retry_count: 2,
+          reason: "Review rejected",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates subtask_failed event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "OUTCOME",
+        outcome_type: "subtask_failed",
+        payload: {
+          subtask_id: "bd-123.1",
+          error: "Type error in auth.ts",
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+
+    test("validates epic_complete event", () => {
+      const event: CoordinatorEvent = {
+        session_id: "test-session",
+        epic_id: "bd-123",
+        timestamp: new Date().toISOString(),
+        event_type: "OUTCOME",
+        outcome_type: "epic_complete",
+        payload: {
+          success: true,
+          total_duration_ms: 180000,
+          subtasks_completed: 3,
+        },
+      };
+
+      expect(() => CoordinatorEventSchema.parse(event)).not.toThrow();
+    });
+  });
+});
+
+describe("CoordinatorSession schema", () => {
+  test("validates complete session", () => {
+    const session: CoordinatorSession = {
+      session_id: "test-session",
+      epic_id: "bd-123",
+      start_time: new Date().toISOString(),
+      end_time: new Date().toISOString(),
+      events: [
+        {
+          session_id: "test-session",
+          epic_id: "bd-123",
+          timestamp: new Date().toISOString(),
+          event_type: "DECISION",
+          decision_type: "strategy_selected",
+          payload: { strategy: "file-based" },
+        },
+      ],
+    };
+
+    expect(() => CoordinatorSessionSchema.parse(session)).not.toThrow();
+  });
+
+  test("validates session without end_time", () => {
+    const session: Partial<CoordinatorSession> = {
+      session_id: "test-session",
+      epic_id: "bd-123",
+      start_time: new Date().toISOString(),
+      events: [],
+    };
+
+    expect(() => CoordinatorSessionSchema.parse(session)).not.toThrow();
+  });
+});
+
+describe("captureCoordinatorEvent", () => {
+  let sessionDir: string;
+  let sessionId: string;
+
+  beforeEach(() => {
+    sessionDir = path.join(os.homedir(), ".config", "swarm-tools", "sessions");
+    sessionId = `test-${Date.now()}`;
+  });
+
+  afterEach(() => {
+    // Clean up test session file
+    const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+    if (fs.existsSync(sessionPath)) {
+      fs.unlinkSync(sessionPath);
+    }
+  });
+
+  test("creates session directory if not exists", () => {
+    const event: CoordinatorEvent = {
+      session_id: sessionId,
+      epic_id: "bd-123",
+      timestamp: new Date().toISOString(),
+      event_type: "DECISION",
+      decision_type: "strategy_selected",
+      payload: { strategy: "file-based" },
+    };
+
+    captureCoordinatorEvent(event);
+
+    expect(fs.existsSync(sessionDir)).toBe(true);
+  });
+
+  test("appends event to session file", () => {
+    const event: CoordinatorEvent = {
+      session_id: sessionId,
+      epic_id: "bd-123",
+      timestamp: new Date().toISOString(),
+      event_type: "DECISION",
+      decision_type: "strategy_selected",
+      payload: { strategy: "file-based" },
+    };
+
+    captureCoordinatorEvent(event);
+
+    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.session_id).toBe(sessionId);
+    expect(parsed.event_type).toBe("DECISION");
+  });
+
+  test("appends multiple events to same session", () => {
+    const event1: CoordinatorEvent = {
+      session_id: sessionId,
+      epic_id: "bd-123",
+      timestamp: new Date().toISOString(),
+      event_type: "DECISION",
+      decision_type: "strategy_selected",
+      payload: { strategy: "file-based" },
+    };
+
+    const event2: CoordinatorEvent = {
+      session_id: sessionId,
+      epic_id: "bd-123",
+      timestamp: new Date().toISOString(),
+      event_type: "VIOLATION",
+      violation_type: "coordinator_edited_file",
+      payload: { file: "src/bad.ts" },
+    };
+
+    captureCoordinatorEvent(event1);
+    captureCoordinatorEvent(event2);
+
+    const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+    const content = fs.readFileSync(sessionPath, "utf-8");
+    const lines = content.trim().split("\n");
+    expect(lines).toHaveLength(2);
+  });
+});
+
+describe("saveSession", () => {
+  let sessionDir: string;
+  let sessionId: string;
+
+  beforeEach(() => {
+    sessionDir = path.join(os.homedir(), ".config", "swarm-tools", "sessions");
+    sessionId = `test-${Date.now()}`;
+  });
+
+  afterEach(() => {
+    // Clean up test session file
+    const sessionPath = path.join(sessionDir, `${sessionId}.jsonl`);
+    if (fs.existsSync(sessionPath)) {
+      fs.unlinkSync(sessionPath);
+    }
+  });
+
+  test("wraps events in session structure", () => {
+    // Capture some events
+    const event1: CoordinatorEvent = {
+      session_id: sessionId,
+      epic_id: "bd-123",
+      timestamp: new Date().toISOString(),
+      event_type: "DECISION",
+      decision_type: "strategy_selected",
+      payload: { strategy: "file-based" },
+    };
+
+    captureCoordinatorEvent(event1);
+
+    // Save session
+    const session = saveSession({
+      session_id: sessionId,
+      epic_id: "bd-123",
+    });
+
+    expect(session).toBeDefined();
+    expect(session.session_id).toBe(sessionId);
+    expect(session.events).toHaveLength(1);
+    expect(session.start_time).toBeDefined();
+    expect(session.end_time).toBeDefined();
+  });
+
+  test("returns null if session file does not exist", () => {
+    const session = saveSession({
+      session_id: "nonexistent",
+      epic_id: "bd-999",
+    });
+
+    expect(session).toBeNull();
+  });
+});