opencode-swarm-plugin 0.38.0 → 0.39.1

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

@@ -12,7 +12,7 @@ import {
 } from "./coordinator-discipline.js";
 
 describe("violationCount", () => {
-	it("scores 1.0 for zero violations", () => {
+	it("scores 1.0 for zero violations", async () => {
 		const session: CoordinatorSession = {
 			session_id: "test-session",
 			epic_id: "test-epic",
@@ -30,9 +30,10 @@ describe("violationCount", () => {
 			],
 		};
 
-		const result = violationCount.scorer({
+		const result = await violationCount({
 			output: JSON.stringify(session),
 			expected: {},
+			input: undefined,
 		});
 
 		expect(result.score).toBe(1.0);

package/evals/scorers/coordinator-discipline.ts

@@ -270,14 +270,14 @@ export const timeToFirstSpawn = createScorer({
 export const overallDiscipline = createScorer({
   name: "Overall Coordinator Discipline",
   description: "Composite score for coordinator protocol adherence",
-  scorer: ({ output, expected }) => {
+  scorer: async ({ output, expected, input }) => {
     try {
       // Run all scorers
       const scores = {
-        violations: violationCount.scorer({ output, expected }),
-        spawn: spawnEfficiency.scorer({ output, expected }),
-        review: reviewThoroughness.scorer({ output, expected }),
-        speed: timeToFirstSpawn.scorer({ output, expected }),
+        violations: await violationCount({ output, expected, input }),
+        spawn: await spawnEfficiency({ output, expected, input }),
+        review: await reviewThoroughness({ output, expected, input }),
+        speed: await timeToFirstSpawn({ output, expected, input }),
       };
 
       // Weighted average
@@ -289,16 +289,16 @@ export const overallDiscipline = createScorer({
       };
 
       const totalScore =
-        scores.violations.score * weights.violations +
-        scores.spawn.score * weights.spawn +
-        scores.review.score * weights.review +
-        scores.speed.score * weights.speed;
+        (scores.violations.score ?? 0) * weights.violations +
+        (scores.spawn.score ?? 0) * weights.spawn +
+        (scores.review.score ?? 0) * weights.review +
+        (scores.speed.score ?? 0) * weights.speed;
 
       const details = [
-        `Violations: ${(scores.violations.score * 100).toFixed(0)}%`,
-        `Spawn: ${(scores.spawn.score * 100).toFixed(0)}%`,
-        `Review: ${(scores.review.score * 100).toFixed(0)}%`,
-        `Speed: ${(scores.speed.score * 100).toFixed(0)}%`,
+        `Violations: ${((scores.violations.score ?? 0) * 100).toFixed(0)}%`,
+        `Spawn: ${((scores.spawn.score ?? 0) * 100).toFixed(0)}%`,
+        `Review: ${((scores.review.score ?? 0) * 100).toFixed(0)}%`,
+        `Speed: ${((scores.speed.score ?? 0) * 100).toFixed(0)}%`,
       ].join(", ");
 
       return {

package/examples/plugin-wrapper-template.ts

@@ -65,6 +65,42 @@ function logCompaction(
   }
 }
 
+/**
+ * Capture compaction event for evals (non-fatal dynamic import)
+ * 
+ * Uses dynamic import to avoid circular dependencies and keep the plugin wrapper
+ * self-contained. Captures COMPACTION events to session JSONL for eval analysis.
+ * 
+ * @param sessionID - Session ID
+ * @param epicID - Epic ID (or "unknown" if not detected)
+ * @param compactionType - Event type (detection_complete, prompt_generated, context_injected)
+ * @param payload - Event-specific data (full prompts, detection results, etc.)
+ */
+async function captureCompaction(
+  sessionID: string,
+  epicID: string,
+  compactionType: "detection_complete" | "prompt_generated" | "context_injected",
+  payload: any,
+): Promise<void> {
+  try {
+    // Dynamic import to avoid circular deps (plugin wrapper → src → plugin wrapper)
+    const { captureCompactionEvent } = await import("../src/eval-capture");
+    captureCompactionEvent({
+      session_id: sessionID,
+      epic_id: epicID,
+      compaction_type: compactionType,
+      payload,
+    });
+  } catch (err) {
+    // Non-fatal - capture failures shouldn't break compaction
+    logCompaction("warn", "compaction_capture_failed", {
+      session_id: sessionID,
+      compaction_type: compactionType,
+      error: err instanceof Error ? err.message : String(err),
+    });
+  }
+}
+
 // Module-level project directory - set during plugin initialization
 // This is CRITICAL: without it, the CLI uses process.cwd() which may be wrong
 let projectDirectory: string = process.cwd();
@@ -2152,6 +2188,25 @@ const SwarmPlugin: Plugin = async (
             full_snapshot: snapshot, // Log the entire snapshot
           });
 
+          // =======================================================================
+          // CAPTURE POINT 1: Detection complete - record confidence and reasons
+          // =======================================================================
+          await captureCompaction(
+            input.sessionID,
+            snapshot.epic?.id || "unknown",
+            "detection_complete",
+            {
+              confidence: snapshot.detection.confidence,
+              detected: detection.detected,
+              reasons: snapshot.detection.reasons,
+              session_scan_contributed: sessionScan.swarmDetected,
+              session_scan_reasons: sessionScan.reasons,
+              epic_id: snapshot.epic?.id,
+              epic_title: snapshot.epic?.title,
+              subtask_count: snapshot.epic?.subtasks?.length ?? 0,
+            },
+          );
+
           // Level 2: Generate prompt with LLM
           const llmStart = Date.now();
           const llmPrompt = await generateCompactionPrompt(snapshot);
@@ -2165,6 +2220,23 @@ const SwarmPlugin: Plugin = async (
             prompt_preview: llmPrompt?.substring(0, 500),
           });
 
+          // =======================================================================
+          // CAPTURE POINT 2: Prompt generated - record FULL prompt content
+          // =======================================================================
+          if (llmPrompt) {
+            await captureCompaction(
+              input.sessionID,
+              snapshot.epic?.id || "unknown",
+              "prompt_generated",
+              {
+                prompt_length: llmPrompt.length,
+                full_prompt: llmPrompt, // FULL content, not truncated
+                context_type: "llm_generated",
+                duration_ms: llmDuration,
+              },
+            );
+          }
+
           if (llmPrompt) {
             // SUCCESS: Use LLM-generated prompt
             const header = `[Swarm compaction: LLM-generated, ${detection.reasons.join(", ")}]\n\n`;
@@ -2188,6 +2260,21 @@ const SwarmPlugin: Plugin = async (
               });
             }
 
+            // =======================================================================
+            // CAPTURE POINT 3a: Context injected (LLM path) - record FULL content
+            // =======================================================================
+            await captureCompaction(
+              input.sessionID,
+              snapshot.epic?.id || "unknown",
+              "context_injected",
+              {
+                full_content: fullContent, // FULL content, not truncated
+                content_length: fullContent.length,
+                injection_method: "prompt" in output ? "output.prompt" : "output.context.push",
+                context_type: "llm_generated",
+              },
+            );
+
             const totalDuration = Date.now() - startTime;
             logCompaction("info", "compaction_complete_llm_success", {
               session_id: input.sessionID,
@@ -2223,6 +2310,21 @@ const SwarmPlugin: Plugin = async (
         const staticContent = header + SWARM_COMPACTION_CONTEXT;
         output.context.push(staticContent);
 
+        // =======================================================================
+        // CAPTURE POINT 3b: Context injected (static fallback) - record FULL content
+        // =======================================================================
+        await captureCompaction(
+          input.sessionID,
+          "unknown", // No snapshot available in this path
+          "context_injected",
+          {
+            full_content: staticContent,
+            content_length: staticContent.length,
+            injection_method: "output.context.push",
+            context_type: "static_swarm_context",
+          },
+        );
+
         const totalDuration = Date.now() - startTime;
         logCompaction("info", "compaction_complete_static_fallback", {
           session_id: input.sessionID,
@@ -2238,6 +2340,21 @@ const SwarmPlugin: Plugin = async (
         const fallbackContent = header + SWARM_DETECTION_FALLBACK;
         output.context.push(fallbackContent);
 
+        // =======================================================================
+        // CAPTURE POINT 3c: Context injected (detection fallback) - record FULL content
+        // =======================================================================
+        await captureCompaction(
+          input.sessionID,
+          "unknown", // No snapshot for low confidence
+          "context_injected",
+          {
+            full_content: fallbackContent,
+            content_length: fallbackContent.length,
+            injection_method: "output.context.push",
+            context_type: "detection_fallback",
+          },
+        );
+
         const totalDuration = Date.now() - startTime;
         logCompaction("info", "compaction_complete_detection_fallback", {
           session_id: input.sessionID,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.38.0",
+  "version": "0.39.1",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "./dist/index.js",
@@ -30,9 +30,11 @@
     "test:all": "bun test --timeout 60000 src/",
     "test:watch": "bun test --watch src/",
     "typecheck": "tsc --noEmit",
-    "eval:run": "bunx evalite run evals/",
-    "eval:decomposition": "bunx evalite run evals/swarm-decomposition.eval.ts",
-    "eval:coordinator": "bunx evalite run evals/coordinator-session.eval.ts",
+    "eval:run": "bun --env-file=.env run bunx evalite run evals/",
+    "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",
+    "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')\""
   },
   "dependencies": {
@@ -44,7 +46,7 @@
     "minimatch": "^10.1.1",
     "pino": "^9.6.0",
     "pino-roll": "^1.3.0",
-    "swarm-mail": "1.5.1",
+    "swarm-mail": "1.5.2",
     "yaml": "^2.8.2",
     "zod": "4.1.8"
   },

package/scripts/migrate-unknown-sessions.ts

@@ -0,0 +1,349 @@
+#!/usr/bin/env bun
+
+/**
+ * Migration script to re-attribute unknown.jsonl events to proper session files
+ * 
+ * Strategy:
+ * 1. Read all events from unknown.jsonl
+ * 2. For each event, find matching session by epic_id
+ * 3. Append to existing session or create new session file
+ * 4. Rename unknown.jsonl to unknown.jsonl.migrated
+ * 
+ * Usage:
+ *   bun run scripts/migrate-unknown-sessions.ts [--dry-run]
+ */
+
+import { execSync } from "node:child_process";
+import { readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+interface SessionEvent {
+  session_id: string;
+  epic_id: string;
+  timestamp: string;
+  event_type: string;
+  [key: string]: unknown;
+}
+
+interface MigrationStats {
+  totalEvents: number;
+  migratedEvents: number;
+  sessionsUpdated: number;
+  sessionsCreated: number;
+  unattributableEvents: number;
+  eventsByEpic: Map<string, number>;
+}
+
+const SESSIONS_DIR = join(process.env.HOME || "~", ".config/swarm-tools/sessions");
+const UNKNOWN_FILE = join(SESSIONS_DIR, "unknown.jsonl");
+const MIGRATED_FILE = join(SESSIONS_DIR, "unknown.jsonl.migrated");
+
+/**
+ * Atomic file write using temp file + rename
+ * Based on learned pattern for crash-safe state persistence
+ */
+function atomicWriteFile(path: string, content: string): void {
+    const dir = join(path, "..");
+    const tempFile = `${dir}/.${Date.now()}.tmp`;
+  
+  try {
+    // Write to temp file in same directory (required for atomic rename)
+    writeFileSync(tempFile, content, "utf-8");
+    
+    // Atomic rename (POSIX guarantees atomicity on same filesystem)
+    renameSync(tempFile, path);
+    
+    // Sync directory entry (ensures rename is flushed)
+    execSync(`sync "${dir}"`, { stdio: "ignore" });
+  } catch (error) {
+    // Cleanup temp file on error
+    try {
+      execSync(`rm -f "${tempFile}"`, { stdio: "ignore" });
+    } catch {
+      // Ignore cleanup errors
+    }
+    throw error;
+  }
+}
+
+/**
+ * Read JSONL file and parse events
+ */
+function readJSONL(path: string): SessionEvent[] {
+  try {
+    const content = readFileSync(path, "utf-8");
+    return content
+      .trim()
+      .split("\n")
+      .filter((line) => line.trim())
+      .map((line) => JSON.parse(line));
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+
+/**
+ * Build index of epic_id -> session_id from all existing session files
+ */
+function buildEpicIndex(): Map<string, string> {
+  const epicIndex = new Map<string, string>();
+  
+  try {
+    const files = execSync(`ls "${SESSIONS_DIR}"/ses_*.jsonl 2>/dev/null || true`, {
+      encoding: "utf-8",
+    })
+      .trim()
+      .split("\n")
+      .filter((f) => f);
+    
+    for (const sessionFile of files) {
+      const events = readJSONL(sessionFile);
+      const sessionId = events[0]?.session_id;
+      
+      if (!sessionId) continue;
+      
+      // Index all epic_ids in this session
+      for (const event of events) {
+        if (event.epic_id && !epicIndex.has(event.epic_id)) {
+          epicIndex.set(event.epic_id, sessionId);
+        }
+      }
+    }
+  } catch (error) {
+    console.error("Error building epic index:", error);
+  }
+  
+  return epicIndex;
+}
+
+/**
+ * Generate a new session ID
+ * Format: ses_<base58-like-id>
+ */
+function generateSessionId(): string {
+  // Generate random base58-like suffix (avoiding 0, O, I, l for readability)
+  const chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+  let suffix = "";
+  for (let i = 0; i < 22; i++) {
+    suffix += chars[Math.floor(Math.random() * chars.length)];
+  }
+  
+  return `ses_${suffix}`;
+}
+
+/**
+ * Append events to a session file atomically
+ */
+function appendToSession(sessionId: string, events: SessionEvent[], dryRun: boolean): void {
+  const sessionFile = `${SESSIONS_DIR}/${sessionId}.jsonl`;
+  
+  // Read existing events (if file exists)
+  const existingEvents = readJSONL(sessionFile);
+  
+  // Create set of existing event fingerprints for idempotency check
+  const existingFingerprints = new Set(
+    existingEvents.map((e) => 
+      JSON.stringify({ epic_id: e.epic_id, timestamp: e.timestamp, event_type: e.event_type })
+    )
+  );
+  
+  // Filter out events that already exist (idempotency)
+  const newEvents = events.filter((e) => {
+    const fingerprint = JSON.stringify({
+      epic_id: e.epic_id,
+      timestamp: e.timestamp,
+      event_type: e.event_type,
+    });
+    return !existingFingerprints.has(fingerprint);
+  });
+  
+  if (newEvents.length === 0) {
+    console.log(`  → No new events to add to ${sessionId}.jsonl (all already exist)`);
+    return;
+  }
+  
+  // Update session_id for all events
+  const updatedEvents = newEvents.map((e) => ({ ...e, session_id: sessionId }));
+  
+  // Combine and write
+  const allEvents = [...existingEvents, ...updatedEvents];
+  const content = allEvents.map((e) => JSON.stringify(e)).join("\n") + "\n";
+  
+  if (dryRun) {
+    console.log(`  → Would write ${newEvents.length} events to ${sessionId}.jsonl`);
+  } else {
+    atomicWriteFile(sessionFile, content);
+    console.log(`  → Wrote ${newEvents.length} events to ${sessionId}.jsonl`);
+  }
+}
+
+/**
+ * Main migration logic
+ */
+function migrate(dryRun: boolean = false): MigrationStats {
+  const stats: MigrationStats = {
+    totalEvents: 0,
+    migratedEvents: 0,
+    sessionsUpdated: 0,
+    sessionsCreated: 0,
+    unattributableEvents: 0,
+    eventsByEpic: new Map(),
+  };
+  
+  console.log("🔍 Reading unknown.jsonl...");
+  const unknownEvents = readJSONL(UNKNOWN_FILE);
+  stats.totalEvents = unknownEvents.length;
+  
+  if (stats.totalEvents === 0) {
+    console.log("✅ No events to migrate (unknown.jsonl is empty)");
+    return stats;
+  }
+  
+  console.log(`📊 Found ${stats.totalEvents} events in unknown.jsonl`);
+  
+  console.log("🗂️  Building epic_id index from existing sessions...");
+  const epicIndex = buildEpicIndex();
+  console.log(`📇 Indexed ${epicIndex.size} epic_ids across existing sessions`);
+  
+  // Group events by target session
+  const eventsBySession = new Map<string, SessionEvent[]>();
+  const newSessions = new Set<string>();
+  
+  for (const event of unknownEvents) {
+    const { epic_id } = event;
+    
+    if (!epic_id) {
+      console.warn(`⚠️  Event without epic_id: ${JSON.stringify(event)}`);
+      stats.unattributableEvents++;
+      continue;
+    }
+    
+    // Track events per epic
+    stats.eventsByEpic.set(epic_id, (stats.eventsByEpic.get(epic_id) || 0) + 1);
+    
+    // Find or create session
+    let sessionId = epicIndex.get(epic_id);
+    
+    if (!sessionId) {
+      // Create new session for this epic_id
+      sessionId = generateSessionId();
+      epicIndex.set(epic_id, sessionId);
+      newSessions.add(sessionId);
+      console.log(`🆕 Creating new session ${sessionId} for epic ${epic_id}`);
+    }
+    
+    // Group events by session
+    if (!eventsBySession.has(sessionId)) {
+      eventsBySession.set(sessionId, []);
+    }
+    const sessionEvents = eventsBySession.get(sessionId);
+    if (sessionEvents) {
+      sessionEvents.push(event);
+    }
+  }
+  
+  // Write events to sessions
+  console.log(`\n📝 Writing events to ${eventsBySession.size} session files...`);
+  
+  for (const [sessionId, events] of eventsBySession) {
+    const isNew = newSessions.has(sessionId);
+    console.log(`\n${isNew ? "🆕" : "➕"} Session ${sessionId} (${events.length} events)`);
+    
+    appendToSession(sessionId, events, dryRun);
+    
+    stats.migratedEvents += events.length;
+    if (isNew) {
+      stats.sessionsCreated++;
+    } else {
+      stats.sessionsUpdated++;
+    }
+  }
+  
+  // Rename unknown.jsonl to .migrated
+  if (!dryRun) {
+    console.log(`\n🏷️  Renaming unknown.jsonl to unknown.jsonl.migrated...`);
+    renameSync(UNKNOWN_FILE, MIGRATED_FILE);
+  } else {
+    console.log(`\n🏷️  Would rename unknown.jsonl to unknown.jsonl.migrated`);
+  }
+  
+  return stats;
+}
+
+/**
+ * Print summary
+ */
+function printSummary(stats: MigrationStats, dryRun: boolean): void {
+  console.log("\n" + "=".repeat(60));
+  console.log(dryRun ? "DRY RUN SUMMARY" : "MIGRATION SUMMARY");
+  console.log("=".repeat(60));
+  console.log(`Total events in unknown.jsonl:    ${stats.totalEvents}`);
+  console.log(`Events migrated:                   ${stats.migratedEvents}`);
+  console.log(`Sessions updated:                  ${stats.sessionsUpdated}`);
+  console.log(`Sessions created:                  ${stats.sessionsCreated}`);
+  console.log(`Unattributable events:             ${stats.unattributableEvents}`);
+  console.log(`Unique epic_ids:                   ${stats.eventsByEpic.size}`);
+  
+  if (stats.eventsByEpic.size > 0 && stats.eventsByEpic.size <= 10) {
+    console.log("\nEvents by epic_id:");
+    for (const [epicId, count] of Array.from(stats.eventsByEpic.entries()).sort((a, b) => b[1] - a[1])) {
+      console.log(`  ${epicId}: ${count} events`);
+    }
+  }
+  
+  console.log("=".repeat(60));
+  
+  if (dryRun) {
+    console.log("\n💡 Run without --dry-run to perform actual migration");
+  } else {
+    console.log("\n✅ Migration complete!");
+  }
+}
+
+// Show help
+if (process.argv.includes("--help") || process.argv.includes("-h")) {
+  console.log(`
+Migration script to re-attribute unknown.jsonl events to proper session files
+
+USAGE:
+  bun run scripts/migrate-unknown-sessions.ts [OPTIONS]
+
+OPTIONS:
+  --dry-run    Preview changes without modifying files
+  --help, -h   Show this help message
+
+DESCRIPTION:
+  This script reads events from unknown.jsonl and re-attributes them to the
+  correct session files based on their epic_id. Events are matched to existing
+  sessions, or new session files are created as needed.
+
+  The script is idempotent - running it multiple times will not duplicate events.
+
+EXAMPLES:
+  # Preview migration
+  bun run scripts/migrate-unknown-sessions.ts --dry-run
+
+  # Perform migration
+  bun run scripts/migrate-unknown-sessions.ts
+`);
+  process.exit(0);
+}
+
+// Main execution
+const dryRun = process.argv.includes("--dry-run");
+
+if (dryRun) {
+  console.log("🧪 DRY RUN MODE - No files will be modified\n");
+}
+
+try {
+  const stats = migrate(dryRun);
+  printSummary(stats, dryRun);
+  process.exit(0);
+} catch (error) {
+  console.error("\n❌ Migration failed:", error);
+  process.exit(1);
+}