opencode-swarm-plugin 0.40.0 → 0.42.1

package/evals/example.eval.ts

@@ -14,19 +14,18 @@ evalite("Example: Basic scorer test", {
   data: async () => {
     return [
       {
-        input: "Test task",
-        output: JSON.stringify({
+        input: {
           epic: { title: "Test Epic", description: "Test" },
           subtasks: [
             { title: "Subtask 1", files: ["a.ts"], estimated_complexity: 1 },
             { title: "Subtask 2", files: ["b.ts"], estimated_complexity: 1 },
           ],
-        }),
+        },
       },
     ];
   },
   task: async (input) => {
-    return input; // passthrough for testing
+    return JSON.stringify(input);
   },
   scorers: [subtaskIndependence],
 });

package/evals/fixtures/compaction-prompt-cases.ts

@@ -78,6 +78,8 @@ Coordinators do NOT edit code directly. These tools are FORBIDDEN:
 - edit
 - write
 - bash (for file modifications)
+- swarmmail_reserve (only workers reserve)
+- git commit (workers commit)
 
 Use swarm_spawn_subtask to delegate work to workers.
 
@@ -249,6 +251,8 @@ You are the COORDINATOR of epic mjkweh7q9n4.
 - edit
 - write
 - bash (for file mods)
+- swarmmail_reserve (only workers)
+- git commit (workers only)
 
 NEVER edit files yourself.
 ALWAYS delegate to workers.
@@ -289,6 +293,8 @@ You are coordinating epics:
 - edit
 - write  
 - bash
+- swarmmail_reserve
+- git commit
 
 ALWAYS check status first.
 NEVER edit files directly.

package/evals/scorers/coordinator-discipline.evalite-test.ts

@@ -5,7 +5,7 @@ import { describe, expect, it } from "bun:test";
 import type { CoordinatorSession } from "../../src/eval-capture.js";
 import {
 	overallDiscipline,
-	reviewEfficiency,
+
 	reviewThoroughness,
 	spawnEfficiency,
 	timeToFirstSpawn,
@@ -537,164 +537,3 @@ describe("overallDiscipline", () => {
 	});
 });
 
-describe("reviewEfficiency", () => {
-	it("scores 1.0 for ideal 1:1 ratio (one review per spawn)", async () => {
-		const session: CoordinatorSession = {
-			session_id: "test-session",
-			epic_id: "test-epic",
-			start_time: "2025-01-01T00:00:00Z",
-			events: [
-				{
-					session_id: "test-session",
-					epic_id: "test-epic",
-					timestamp: "2025-01-01T00:00:10Z",
-					event_type: "DECISION",
-					decision_type: "worker_spawned",
-					payload: { bead_id: "bd-1" },
-				},
-				{
-					session_id: "test-session",
-					epic_id: "test-epic",
-					timestamp: "2025-01-01T00:00:20Z",
-					event_type: "DECISION",
-					decision_type: "worker_spawned",
-					payload: { bead_id: "bd-2" },
-				},
-				{
-					session_id: "test-session",
-					epic_id: "test-epic",
-					timestamp: "2025-01-01T00:10:00Z",
-					event_type: "DECISION",
-					decision_type: "review_completed",
-					payload: { bead_id: "bd-1" },
-				},
-				{
-					session_id: "test-session",
-					epic_id: "test-epic",
-					timestamp: "2025-01-01T00:10:10Z",
-					event_type: "DECISION",
-					decision_type: "review_completed",
-					payload: { bead_id: "bd-2" },
-				},
-			],
-		};
-
-		const result = await reviewEfficiency({
-			output: JSON.stringify(session),
-			expected: {},
-			input: undefined,
-		});
-
-		expect(result.score).toBe(1.0);
-		expect(result.message).toContain("2 reviews / 2 spawns");
-	});
-
-	it("penalizes over-reviewing (>2:1 ratio)", async () => {
-		// 6 reviews for 2 spawns = 3:1 ratio (over-reviewing)
-		const session: CoordinatorSession = {
-			session_id: "test-session",
-			epic_id: "test-epic",
-			start_time: "2025-01-01T00:00:00Z",
-			events: [
-				{
-					session_id: "test-session",
-					epic_id: "test-epic",
-					timestamp: "2025-01-01T00:00:10Z",
-					event_type: "DECISION",
-					decision_type: "worker_spawned",
-					payload: { bead_id: "bd-1" },
-				},
-				{
-					session_id: "test-session",
-					epic_id: "test-epic",
-					timestamp: "2025-01-01T00:00:20Z",
-					event_type: "DECISION",
-					decision_type: "worker_spawned",
-					payload: { bead_id: "bd-2" },
-				},
-				...Array.from({ length: 6 }, (_, i) => ({
-					session_id: "test-session",
-					epic_id: "test-epic",
-					timestamp: `2025-01-01T00:10:${String(i * 10).padStart(2, "0")}Z`,
-					event_type: "DECISION" as const,
-					decision_type: "review_completed" as const,
-					payload: { bead_id: `bd-${(i % 2) + 1}` },
-				})),
-			],
-		};
-
-		const result = await reviewEfficiency({
-			output: JSON.stringify(session),
-			expected: {},
-			input: undefined,
-		});
-
-		// 3:1 ratio should be penalized (score < 0.5)
-		expect(result.score).toBeLessThan(0.5);
-		expect(result.message).toContain("6 reviews / 2 spawns");
-	});
-
-	it("handles no spawns gracefully", async () => {
-		const session: CoordinatorSession = {
-			session_id: "test-session",
-			epic_id: "test-epic",
-			start_time: "2025-01-01T00:00:00Z",
-			events: [
-				{
-					session_id: "test-session",
-					epic_id: "test-epic",
-					timestamp: "2025-01-01T00:00:00Z",
-					event_type: "DECISION",
-					decision_type: "strategy_selected",
-					payload: { strategy: "file-based" },
-				},
-			],
-		};
-
-		const result = await reviewEfficiency({
-			output: JSON.stringify(session),
-			expected: {},
-			input: undefined,
-		});
-
-		expect(result.score).toBe(1.0);
-		expect(result.message).toContain("No workers spawned");
-	});
-
-	it("handles no reviews gracefully (0:N ratio)", async () => {
-		const session: CoordinatorSession = {
-			session_id: "test-session",
-			epic_id: "test-epic",
-			start_time: "2025-01-01T00:00:00Z",
-			events: [
-				{
-					session_id: "test-session",
-					epic_id: "test-epic",
-					timestamp: "2025-01-01T00:00:10Z",
-					event_type: "DECISION",
-					decision_type: "worker_spawned",
-					payload: { bead_id: "bd-1" },
-				},
-				{
-					session_id: "test-session",
-					epic_id: "test-epic",
-					timestamp: "2025-01-01T00:00:20Z",
-					event_type: "DECISION",
-					decision_type: "worker_spawned",
-					payload: { bead_id: "bd-2" },
-				},
-			],
-		};
-
-		const result = await reviewEfficiency({
-			output: JSON.stringify(session),
-			expected: {},
-			input: undefined,
-		});
-
-		// No reviews is bad (should use reviewThoroughness for this)
-		// But this scorer focuses on over-reviewing, so no reviews = 1.0 (not over-reviewing)
-		expect(result.score).toBe(1.0);
-		expect(result.message).toContain("0 reviews / 2 spawns");
-	});
-});

package/evals/scorers/coordinator-discipline.ts

@@ -132,76 +132,6 @@ export const spawnEfficiency = createScorer({
   },
 });
 
-/**
- * Review Efficiency Scorer
- *
- * Measures review-to-spawn ratio to detect over-reviewing.
- * Ideal ratio is 1:1 (one review per spawned worker).
- * Penalizes >2:1 ratio (over-reviewing wastes context).
- *
- * Scoring:
- * - 0:N or 1:1 ratio = 1.0 (perfect)
- * - 2:1 ratio = 0.5 (threshold)
- * - >2:1 ratio = linear penalty toward 0.0
- *
- * Score: normalized to 0-1 (lower ratio is better)
- */
-export const reviewEfficiency = createScorer({
-  name: "Review Efficiency",
-  description: "Review-to-spawn ratio (penalize over-reviewing >2:1)",
-  scorer: ({ output }) => {
-    try {
-      const session = JSON.parse(String(output)) as CoordinatorSession;
-
-      // Count worker_spawned events
-      const spawned = session.events.filter(
-        (e) =>
-          e.event_type === "DECISION" && e.decision_type === "worker_spawned"
-      ).length;
-
-      if (spawned === 0) {
-        return {
-          score: 1.0,
-          message: "No workers spawned",
-        };
-      }
-
-      // Count review_completed events
-      const reviewed = session.events.filter(
-        (e) =>
-          e.event_type === "DECISION" && e.decision_type === "review_completed"
-      ).length;
-
-      const ratio = reviewed / spawned;
-
-      // Scoring:
-      // - ratio <= 1.0: perfect (1.0)
-      // - ratio <= 2.0: linear decay from 1.0 to 0.5
-      // - ratio > 2.0: linear penalty from 0.5 toward 0.0
-      let score: number;
-      if (ratio <= 1.0) {
-        score = 1.0;
-      } else if (ratio <= 2.0) {
-        // Linear decay: 1.0 at ratio=1.0, 0.5 at ratio=2.0
-        score = 1.0 - (ratio - 1.0) * 0.5;
-      } else {
-        // Penalty for extreme over-reviewing: 0.5 at ratio=2.0, 0.0 at ratio=4.0
-        score = Math.max(0, 0.5 - (ratio - 2.0) * 0.25);
-      }
-
-      return {
-        score,
-        message: `${reviewed} reviews / ${spawned} spawns (${ratio.toFixed(1)}:1 ratio)`,
-      };
-    } catch (error) {
-      return {
-        score: 0,
-        message: `Failed to parse CoordinatorSession: ${error}`,
-      };
-    }
-  },
-});
-
 /**
  * Review Thoroughness Scorer
  *
@@ -334,259 +264,6 @@ export const timeToFirstSpawn = createScorer({
   },
 });
 
-/**
- * Researcher Spawn Rate Scorer
- *
- * Measures whether coordinator spawns researchers for unfamiliar technology.
- * Coordinators should delegate research instead of calling pdf-brain/context7 directly.
- *
- * Score: 1.0 if researcher_spawned events exist, 0.0 otherwise
- */
-export const researcherSpawnRate = createScorer({
-  name: "Researcher Spawn Rate",
-  description: "Coordinator spawned researchers for unfamiliar tech",
-  scorer: ({ output }) => {
-    try {
-      const session = JSON.parse(String(output)) as CoordinatorSession;
-
-      // Count researcher_spawned events
-      const researchers = session.events.filter(
-        (e) =>
-          e.event_type === "DECISION" && e.decision_type === "researcher_spawned"
-      );
-
-      const count = researchers.length;
-
-      if (count === 0) {
-        return {
-          score: 0.0,
-          message: "No researchers spawned (may indicate coordinator queried docs directly)",
-        };
-      }
-
-      return {
-        score: 1.0,
-        message: `${count} researcher(s) spawned`,
-      };
-    } catch (error) {
-      return {
-        score: 0,
-        message: `Failed to parse CoordinatorSession: ${error}`,
-      };
-    }
-  },
-});
-
-/**
- * Skill Loading Rate Scorer
- *
- * Measures whether coordinator loads relevant skills via skills_use().
- * Shows knowledge-seeking behavior.
- *
- * Score: 1.0 if skill_loaded events exist, 0.5 otherwise (not critical, but helpful)
- */
-export const skillLoadingRate = createScorer({
-  name: "Skill Loading Rate",
-  description: "Coordinator loaded relevant skills for domain knowledge",
-  scorer: ({ output }) => {
-    try {
-      const session = JSON.parse(String(output)) as CoordinatorSession;
-
-      // Count skill_loaded events
-      const skills = session.events.filter(
-        (e) =>
-          e.event_type === "DECISION" && e.decision_type === "skill_loaded"
-      );
-
-      const count = skills.length;
-
-      if (count === 0) {
-        return {
-          score: 0.5,
-          message: "No skills loaded (not critical, but helpful)",
-        };
-      }
-
-      return {
-        score: 1.0,
-        message: `${count} skill(s) loaded`,
-      };
-    } catch (error) {
-      return {
-        score: 0,
-        message: `Failed to parse CoordinatorSession: ${error}`,
-      };
-    }
-  },
-});
-
-/**
- * Inbox Monitoring Rate Scorer
- *
- * Measures how frequently coordinator checks inbox for worker messages.
- * Regular monitoring (every ~15min or when workers finish) shows good coordination.
- *
- * Score based on inbox_checked events relative to worker activity:
- * - 0 checks = 0.0 (coordinator not monitoring)
- * - 1+ checks = 1.0 (coordinator is responsive)
- */
-export const inboxMonitoringRate = createScorer({
-  name: "Inbox Monitoring Rate",
-  description: "Coordinator checked inbox regularly for worker messages",
-  scorer: ({ output }) => {
-    try {
-      const session = JSON.parse(String(output)) as CoordinatorSession;
-
-      // Count inbox_checked events
-      const checks = session.events.filter(
-        (e) =>
-          e.event_type === "DECISION" && e.decision_type === "inbox_checked"
-      );
-
-      // Count worker activity (spawns + outcomes)
-      const workerActivity = session.events.filter(
-        (e) =>
-          (e.event_type === "DECISION" && e.decision_type === "worker_spawned") ||
-          (e.event_type === "OUTCOME" &&
-            ["subtask_success", "subtask_failed", "blocker_detected"].includes(
-              e.outcome_type
-            ))
-      );
-
-      const checkCount = checks.length;
-      const activityCount = workerActivity.length;
-
-      if (activityCount === 0) {
-        return {
-          score: 1.0,
-          message: "No worker activity to monitor",
-        };
-      }
-
-      if (checkCount === 0) {
-        return {
-          score: 0.0,
-          message: `${activityCount} worker events, 0 inbox checks (not monitoring)`,
-        };
-      }
-
-      return {
-        score: 1.0,
-        message: `${checkCount} inbox check(s) for ${activityCount} worker events`,
-      };
-    } catch (error) {
-      return {
-        score: 0,
-        message: `Failed to parse CoordinatorSession: ${error}`,
-      };
-    }
-  },
-});
-
-/**
- * Blocker Response Time Scorer
- *
- * Measures how quickly coordinator responds to blocked workers.
- * Time between blocker_detected (OUTCOME) and blocker_resolved (DECISION).
- *
- * Normalization:
- * - < 5min: 1.0 (excellent)
- * - 5-15min: linear decay to 0.5
- * - > 15min: 0.0 (too slow, worker is idle)
- *
- * Score: Average response time across all blockers
- */
-export const blockerResponseTime = createScorer({
-  name: "Blocker Response Time",
-  description: "Coordinator unblocked workers quickly",
-  scorer: ({ output }) => {
-    try {
-      const session = JSON.parse(String(output)) as CoordinatorSession;
-
-      // Find blocker_detected events
-      const blockers = session.events.filter(
-        (e) =>
-          e.event_type === "OUTCOME" && e.outcome_type === "blocker_detected"
-      );
-
-      if (blockers.length === 0) {
-        return {
-          score: 1.0,
-          message: "No blockers detected",
-        };
-      }
-
-      // Find blocker_resolved events
-      const resolutions = session.events.filter(
-        (e) =>
-          e.event_type === "DECISION" && e.decision_type === "blocker_resolved"
-      );
-
-      if (resolutions.length === 0) {
-        return {
-          score: 0.0,
-          message: `${blockers.length} blocker(s) detected, 0 resolved (workers still blocked)`,
-        };
-      }
-
-      // Match blockers to resolutions by subtask_id and calculate response times
-      const responseTimes: number[] = [];
-      for (const blocker of blockers) {
-        const subtaskId = (blocker.payload as any).subtask_id;
-        const blockerTime = new Date(blocker.timestamp).getTime();
-
-        // Find resolution for this subtask
-        const resolution = resolutions.find(
-          (r) => (r.payload as any).subtask_id === subtaskId
-        );
-
-        if (resolution) {
-          const resolutionTime = new Date(resolution.timestamp).getTime();
-          const deltaMs = resolutionTime - blockerTime;
-          responseTimes.push(deltaMs);
-        }
-      }
-
-      if (responseTimes.length === 0) {
-        return {
-          score: 0.5,
-          message: `${blockers.length} blocker(s) detected, ${resolutions.length} resolution(s), but no matches by subtask_id`,
-        };
-      }
-
-      // Calculate average response time
-      const avgResponseMs =
-        responseTimes.reduce((sum, t) => sum + t, 0) / responseTimes.length;
-
-      // Normalize: < 5min = 1.0, > 15min = 0.0, linear in between
-      const EXCELLENT_MS = 5 * 60 * 1000; // 5 min
-      const POOR_MS = 15 * 60 * 1000; // 15 min
-
-      let score: number;
-      if (avgResponseMs < EXCELLENT_MS) {
-        score = 1.0;
-      } else if (avgResponseMs > POOR_MS) {
-        score = 0.0;
-      } else {
-        // Linear decay from 1.0 to 0.0
-        score = 1.0 - (avgResponseMs - EXCELLENT_MS) / (POOR_MS - EXCELLENT_MS);
-      }
-
-      const avgMinutes = Math.round(avgResponseMs / 1000 / 60);
-
-      return {
-        score,
-        message: `Avg response time: ${avgMinutes}min (${responseTimes.length}/${blockers.length} blockers resolved)`,
-      };
-    } catch (error) {
-      return {
-        score: 0,
-        message: `Failed to parse CoordinatorSession: ${error}`,
-      };
-    }
-  },
-});
-
 /**
  * Overall Discipline Scorer
  *

package/evals/swarm-decomposition.eval.ts

@@ -34,7 +34,9 @@ import {
 } from "./lib/data-loader.js";
 
 // Determine project key from current directory
-const PROJECT_KEY = "opencode-swarm-plugin";
+// NOTE: project_key in eval_records is the full path (from getHiveWorkingDirectory),
+// not a short name. Use process.cwd() to match.
+const PROJECT_KEY = process.cwd();
 const PROJECT_PATH = process.cwd();
 
 // Check if we have enough real data to use instead of fixtures
@@ -42,7 +44,7 @@ const useRealData = await hasRealEvalData(PROJECT_KEY, 5, PROJECT_PATH);
 
 // Load data based on availability
 const evalCases = useRealData
-  ? await loadEvalCases(PROJECT_KEY, { limit: 20, projectPath: PROJECT_PATH })
+  ? await loadEvalCases(PROJECT_KEY, { limit: 20, projectPath: PROJECT_PATH })  // PROJECT_KEY is now process.cwd()
   : decompositionCases.map((testCase) => ({
       input: testCase.input,
       expected: testCase.expected,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.40.0",
+  "version": "0.42.1",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "./dist/index.js",
@@ -23,7 +23,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target node --external @electric-sql/pglite --external swarm-mail && bun build ./src/plugin.ts --outfile ./dist/plugin.js --target node --external @electric-sql/pglite --external swarm-mail && tsc",
+    "build": "bun build ./src/index.ts --outdir ./dist --target node --external @electric-sql/pglite --external swarm-mail --external vitest --external @vitest/ui --external lightningcss && bun build ./src/plugin.ts --outfile ./dist/plugin.js --target node --external @electric-sql/pglite --external swarm-mail --external vitest --external @vitest/ui --external lightningcss && tsc",
     "dev": "bun --watch src/index.ts",
     "test": "bun test --timeout 10000 src/anti-patterns.test.ts src/mandate-promotion.test.ts src/mandate-storage.test.ts src/output-guardrails.test.ts src/pattern-maturity.test.ts src/skills.test.ts src/structured.test.ts src/schemas/",
     "test:integration": "bun test --timeout 60000 src/*.integration.test.ts",
@@ -34,6 +34,7 @@
     "eval:decomposition": "bun --env-file=.env run bunx evalite run evals/swarm-decomposition.eval.ts",
     "eval:coordinator": "bun --env-file=.env run bunx evalite run evals/coordinator-session.eval.ts",
     "eval:compaction": "bun --env-file=.env run bunx evalite run evals/compaction-prompt.eval.ts",
+    "eval:gate": "bun run bin/eval-gate.ts",
     "migrate:sessions": "bun run scripts/migrate-unknown-sessions.ts",
     "postinstall": "node -e \"console.log('\\n\\x1b[33m  Run \\x1b[36mswarm setup\\x1b[33m to configure OpenCode integration\\x1b[0m\\n')\""
   },
@@ -46,7 +47,7 @@
     "minimatch": "^10.1.1",
     "pino": "^9.6.0",
     "pino-roll": "^1.3.0",
-    "swarm-mail": "1.5.2",
+    "swarm-mail": "1.5.4",
     "yaml": "^2.8.2",
     "zod": "4.1.8"
   },