opencode-swarm-plugin 0.48.0 → 0.49.0

package/dist/swarm-prompts.js

@@ -18210,11 +18210,16 @@ echo "Project directory: $1"
 // src/swarm-insights.ts
 var exports_swarm_insights = {};
 __export(exports_swarm_insights, {
+  trackCoordinatorViolation: () => trackCoordinatorViolation,
+  getViolationAnalytics: () => getViolationAnalytics,
   getStrategyInsights: () => getStrategyInsights,
+  getRejectionAnalytics: () => getRejectionAnalytics,
   getPatternInsights: () => getPatternInsights,
   getFileInsights: () => getFileInsights,
+  getFileFailureHistory: () => getFileFailureHistory,
   getCachedInsights: () => getCachedInsights,
   formatInsightsForPrompt: () => formatInsightsForPrompt,
+  formatFileHistoryWarnings: () => formatFileHistoryWarnings,
   clearInsightsCache: () => clearInsightsCache
 });
 async function getStrategyInsights(swarmMail, _task) {
@@ -18286,6 +18291,136 @@ async function getFileInsights(swarmMail, files) {
 async function getFileGotchas(_swarmMail, _file2) {
   return [];
 }
+async function getFileFailureHistory(swarmMail, files) {
+  if (files.length === 0)
+    return [];
+  const db = await swarmMail.getDatabase();
+  const histories = [];
+  for (const file2 of files) {
+    const query = `
+			SELECT data
+			FROM events
+			WHERE type = 'review_feedback'
+			AND json_extract(data, '$.status') = 'needs_changes'
+			AND json_extract(data, '$.issues') LIKE ?
+		`;
+    const result = await db.query(query, [`%${file2}%`]);
+    if (!result.rows || result.rows.length === 0) {
+      continue;
+    }
+    const issueTexts = [];
+    for (const row of result.rows) {
+      try {
+        const data = JSON.parse(row.data);
+        const issuesStr = data.issues;
+        if (!issuesStr)
+          continue;
+        const issues = JSON.parse(issuesStr);
+        for (const issue2 of issues) {
+          if (issue2.file === file2) {
+            issueTexts.push(issue2.issue);
+          }
+        }
+      } catch (e) {
+        continue;
+      }
+    }
+    if (issueTexts.length === 0) {
+      continue;
+    }
+    const issueCounts = new Map;
+    for (const text of issueTexts) {
+      issueCounts.set(text, (issueCounts.get(text) || 0) + 1);
+    }
+    const topIssues = Array.from(issueCounts.entries()).sort((a, b) => b[1] - a[1]).slice(0, 3).map(([text]) => text);
+    histories.push({
+      file: file2,
+      rejectionCount: issueTexts.length,
+      topIssues
+    });
+  }
+  return histories;
+}
+async function getRejectionAnalytics(swarmMail) {
+  const db = await swarmMail.getDatabase();
+  const query = `
+		SELECT data
+		FROM events
+		WHERE type = 'review_feedback'
+		ORDER BY timestamp DESC
+	`;
+  const result = await db.query(query, []);
+  if (!result.rows || result.rows.length === 0) {
+    return {
+      totalReviews: 0,
+      approved: 0,
+      rejected: 0,
+      approvalRate: 0,
+      topReasons: []
+    };
+  }
+  let approved = 0;
+  let rejected = 0;
+  const reasonCounts = new Map;
+  for (const row of result.rows) {
+    try {
+      const data = JSON.parse(row.data);
+      if (data.status === "approved") {
+        approved++;
+      } else if (data.status === "needs_changes") {
+        rejected++;
+        if (data.issues) {
+          const issues = JSON.parse(data.issues);
+          for (const issue2 of issues) {
+            const category = categorizeRejectionReason(issue2.issue);
+            reasonCounts.set(category, (reasonCounts.get(category) || 0) + 1);
+          }
+        }
+      }
+    } catch (e) {
+      continue;
+    }
+  }
+  const totalReviews = approved + rejected;
+  const approvalRate = totalReviews > 0 ? approved / totalReviews * 100 : 0;
+  const topReasons = Array.from(reasonCounts.entries()).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([category, count]) => ({
+    category,
+    count,
+    percentage: rejected > 0 ? count / rejected * 100 : 0
+  }));
+  return {
+    totalReviews,
+    approved,
+    rejected,
+    approvalRate,
+    topReasons
+  };
+}
+function categorizeRejectionReason(reason) {
+  const lowerReason = reason.toLowerCase();
+  if (lowerReason.includes("test") || lowerReason.includes("spec") || lowerReason.includes("coverage")) {
+    return "Missing tests";
+  }
+  if (lowerReason.includes("type") || lowerReason.includes("undefined") || lowerReason.includes("null") || lowerReason.includes("assignable")) {
+    return "Type errors";
+  }
+  if (lowerReason.includes("incomplete") || lowerReason.includes("missing") || lowerReason.includes("forgot") || lowerReason.includes("didn't implement")) {
+    return "Incomplete implementation";
+  }
+  if (lowerReason.includes("wrong file") || lowerReason.includes("modified incorrect") || lowerReason.includes("shouldn't have changed")) {
+    return "Wrong file modified";
+  }
+  if (lowerReason.includes("performance") || lowerReason.includes("slow") || lowerReason.includes("inefficient")) {
+    return "Performance issue";
+  }
+  if (lowerReason.includes("security") || lowerReason.includes("vulnerability") || lowerReason.includes("unsafe")) {
+    return "Security vulnerability";
+  }
+  if (lowerReason.includes("error handling") || lowerReason.includes("try/catch") || lowerReason.includes("exception")) {
+    return "Missing error handling";
+  }
+  return "Other";
+}
 async function getPatternInsights(swarmMail) {
   const db = await swarmMail.getDatabase();
   const patterns = [];
@@ -18373,6 +18508,107 @@ async function getCachedInsights(_swarmMail, cacheKey, computeFn) {
 function clearInsightsCache() {
   insightsCache.clear();
 }
+async function trackCoordinatorViolation(swarmMail, violation) {
+  const db = await swarmMail.getDatabase();
+  const query = `
+		INSERT INTO events (type, project_key, timestamp, data)
+		VALUES (?, ?, ?, ?)
+		RETURNING id
+	`;
+  const data = JSON.stringify({
+    session_id: violation.session_id,
+    epic_id: violation.epic_id,
+    event_type: "VIOLATION",
+    violation_type: violation.violation_type,
+    payload: violation.payload
+  });
+  const result = await db.query(query, [
+    "coordinator_violation",
+    violation.project_key,
+    Date.now(),
+    data
+  ]);
+  return result.rows[0].id;
+}
+async function getViolationAnalytics(swarmMail, projectKey) {
+  const db = await swarmMail.getDatabase();
+  const violationsQuery = projectKey ? `
+		SELECT data
+		FROM events
+		WHERE type = 'coordinator_violation'
+		AND project_key = ?
+		ORDER BY timestamp DESC
+	` : `
+		SELECT data
+		FROM events
+		WHERE type = 'coordinator_violation'
+		ORDER BY timestamp DESC
+	`;
+  const params = projectKey ? [projectKey] : [];
+  const result = await db.query(violationsQuery, params);
+  if (!result.rows || result.rows.length === 0) {
+    return {
+      totalViolations: 0,
+      byType: [],
+      violationRate: 0
+    };
+  }
+  const violationCounts = new Map;
+  let totalViolations = 0;
+  for (const row of result.rows) {
+    try {
+      const data = JSON.parse(row.data);
+      const violationType = data.violation_type;
+      if (violationType) {
+        violationCounts.set(violationType, (violationCounts.get(violationType) || 0) + 1);
+        totalViolations++;
+      }
+    } catch (e) {
+      continue;
+    }
+  }
+  const byType = Array.from(violationCounts.entries()).sort((a, b) => b[1] - a[1]).map(([violationType, count]) => ({
+    violationType,
+    count,
+    percentage: count / totalViolations * 100
+  }));
+  const coordinationQuery = projectKey ? `
+		SELECT COUNT(*) as count
+		FROM events
+		WHERE type IN ('worker_spawned', 'review_feedback', 'message_sent')
+		AND project_key = ?
+	` : `
+		SELECT COUNT(*) as count
+		FROM events
+		WHERE type IN ('worker_spawned', 'review_feedback', 'message_sent')
+	`;
+  const coordResult = await db.query(coordinationQuery, params);
+  const coordinationCount = coordResult.rows[0]?.count || 0;
+  const violationRate = coordinationCount > 0 ? totalViolations / coordinationCount * 100 : 0;
+  return {
+    totalViolations,
+    byType,
+    violationRate
+  };
+}
+function formatFileHistoryWarnings(histories) {
+  if (histories.length === 0) {
+    return "";
+  }
+  const lines = ["⚠️ FILE HISTORY WARNINGS:"];
+  for (const history of histories) {
+    const workerText = history.rejectionCount === 1 ? "1 previous worker rejected" : `${history.rejectionCount} previous workers rejected`;
+    const issuesText = history.topIssues.join(", ");
+    lines.push(`- ${history.file}: ${workerText} for ${issuesText}`);
+  }
+  let result = lines.join(`
+`);
+  const maxChars = 300 * 4;
+  if (result.length > maxChars) {
+    result = result.slice(0, maxChars - 3) + "...";
+  }
+  return result;
+}
 var insightsCache, CACHE_TTL_MS;
 var init_swarm_insights = __esm(() => {
   insightsCache = new Map;
@@ -20281,7 +20517,8 @@ var CellTreeSchema = exports_external.object({
     title: exports_external.string().min(1),
     description: exports_external.string().optional().default("")
   }),
-  subtasks: exports_external.array(SubtaskSpecSchema).min(1)
+  subtasks: exports_external.array(SubtaskSpecSchema).min(1),
+  strategy: exports_external.enum(["file-based", "feature-based", "risk-based", "research-based"]).optional().describe("Decomposition strategy from swarm_select_strategy. If not provided, defaults to feature-based.")
 });
 var EpicCreateArgsSchema = exports_external.object({
   epic_title: exports_external.string().min(1),
@@ -21188,13 +21425,13 @@ async function autoMigrateFromJSONL(adapter, projectKey) {
       skipExisting: true
     });
     if (result.created > 0 || result.updated > 0) {
-      console.log(`[hive] Auto-migrated ${result.created} cells from ${jsonlPath} (${result.skipped} skipped, ${result.errors.length} errors)`);
+      console.error(`[hive] Auto-migrated ${result.created} cells from ${jsonlPath} (${result.skipped} skipped, ${result.errors.length} errors)`);
     }
     if (result.errors.length > 0) {
-      console.warn(`[hive] Migration errors:`, result.errors.slice(0, 5).map((e) => `${e.cellId}: ${e.error}`));
+      console.error(`[hive] Migration errors:`, result.errors.slice(0, 5).map((e) => `${e.cellId}: ${e.error}`));
     }
   } catch (error45) {
-    console.warn(`[hive] Failed to auto-migrate from ${jsonlPath}:`, error45 instanceof Error ? error45.message : String(error45));
+    console.error(`[hive] Failed to auto-migrate from ${jsonlPath}:`, error45 instanceof Error ? error45.message : String(error45));
   }
 }
 function formatCellForOutput(adapterCell) {
@@ -23364,7 +23601,7 @@ var swarm_complete = tool({
     files_touched: tool.schema.array(tool.schema.string()).optional().describe("Files modified - will be verified (typecheck, tests)"),
     skip_verification: tool.schema.boolean().optional().describe("Skip ALL verification (typecheck, tests). Use sparingly! (default: false)"),
     planned_files: tool.schema.array(tool.schema.string()).optional().describe("Files that were originally planned to be modified"),
-    start_time: tool.schema.number().optional().describe("Task start timestamp (Unix ms) for duration calculation"),
+    start_time: tool.schema.number().describe("Task start timestamp (Unix ms) for duration calculation - REQUIRED for accurate analytics"),
     error_count: tool.schema.number().optional().describe("Number of errors encountered during task"),
     retry_count: tool.schema.number().optional().describe("Number of retry attempts during task"),
     skip_review: tool.schema.boolean().optional().describe("Skip review gate check (default: false). Use only for tasks that don't require coordinator review.")
@@ -23568,7 +23805,7 @@ This will be recorded as a negative learning signal.`;
         syncError = error45 instanceof Error ? error45.message : String(error45);
         console.warn(`[swarm_complete] Auto-sync failed (non-fatal): ${syncError}`);
       }
-      const completionDurationMs = args.start_time ? Date.now() - args.start_time : 0;
+      const completionDurationMs = Date.now() - args.start_time;
       const eventEpicId = cell.parent_id || (args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id);
       try {
         const event = createEvent3("subtask_outcome", {
@@ -23624,12 +23861,18 @@ This will be recorded as a negative learning signal.`;
         memoryError = `Failed to store memory: ${error45 instanceof Error ? error45.message : String(error45)}`;
         console.warn(`[swarm_complete] ${memoryError}`);
       }
+      let reservationsReleased = false;
+      let reservationsReleasedCount = 0;
+      let reservationsReleaseError;
       try {
-        await releaseSwarmFiles({
+        const releaseResult = await releaseSwarmFiles({
           projectPath: args.project_key,
           agentName: args.agent_name
         });
+        reservationsReleased = true;
+        reservationsReleasedCount = releaseResult.released;
       } catch (error45) {
+        reservationsReleaseError = error45 instanceof Error ? error45.message : String(error45);
         console.warn(`[swarm] Failed to release file reservations for ${args.agent_name}:`, error45);
       }
       const epicId2 = args.bead_id.includes(".") ? args.bead_id.split(".")[0] : args.bead_id;
@@ -23665,7 +23908,9 @@ This will be recorded as a negative learning signal.`;
         success: true,
         bead_id: args.bead_id,
         closed: true,
-        reservations_released: true,
+        reservations_released: reservationsReleased,
+        reservations_released_count: reservationsReleasedCount,
+        reservations_release_error: reservationsReleaseError,
         synced: syncSuccess,
         sync_error: syncError,
         message_sent: messageSent,
@@ -37885,14 +38130,14 @@ async function maybeAutoMigrate(db) {
     if (memoryCount > 0) {
       return;
     }
-    console.log("[memory] Legacy database detected, starting auto-migration...");
+    console.error("[memory] Legacy database detected, starting auto-migration...");
     const result = await migrateLegacyMemories({
       targetDb: db,
       dryRun: false,
-      onProgress: console.log
+      onProgress: (msg) => console.error(msg)
     });
     if (result.migrated > 0) {
-      console.log(`[memory] Auto-migrated ${result.migrated} memories from legacy database`);
+      console.error(`[memory] Auto-migrated ${result.migrated} memories from legacy database`);
     }
     if (result.failed > 0) {
       console.warn(`[memory] ${result.failed} memories failed to migrate. See errors above.`);
@@ -37961,6 +38206,7 @@ Linked to ${result.links.length} related memor${result.links.length === 1 ? "y"
     async find(args2) {
       const limit = args2.limit ?? 10;
       let results;
+      let usedFallback = false;
       if (args2.fts) {
         results = await store.ftsSearch(args2.query, {
           limit,
@@ -37971,14 +38217,23 @@ Linked to ${result.links.length} related memor${result.links.length === 1 ? "y"
           const ollama = yield* Ollama;
           return yield* ollama.embed(args2.query);
         });
-        const queryEmbedding = await exports_Effect.runPromise(program.pipe(exports_Effect.provide(ollamaLayer)));
-        results = await store.search(queryEmbedding, {
-          limit,
-          threshold: 0.3,
-          collection: args2.collection
-        });
+        try {
+          const queryEmbedding = await exports_Effect.runPromise(program.pipe(exports_Effect.provide(ollamaLayer)));
+          results = await store.search(queryEmbedding, {
+            limit,
+            threshold: 0.3,
+            collection: args2.collection
+          });
+        } catch (e) {
+          console.warn("[hivemind] Ollama unavailable, falling back to full-text search");
+          usedFallback = true;
+          results = await store.ftsSearch(args2.query, {
+            limit,
+            collection: args2.collection
+          });
+        }
       }
-      return {
+      const response = {
         results: results.map((r) => ({
           id: r.memory.id,
           content: args2.expand ? r.memory.content : truncateContent(r.memory.content),
@@ -37989,6 +38244,10 @@ Linked to ${result.links.length} related memor${result.links.length === 1 ? "y"
         })),
         count: results.length
       };
+      if (usedFallback) {
+        response.fallback_used = true;
+      }
+      return response;
     },
     async get(args2) {
       return store.get(args2.id);
@@ -38811,6 +39070,74 @@ Your role is **ONLY** to:
 
 **ALWAYS spawn workers, even for sequential tasks.** Sequential just means spawn them in order and wait for each to complete before spawning the next.
 
+### Explicit NEVER Rules (With Examples)
+
+\`\`\`
+╔═══════════════════════════════════════════════════════════════════════════╗
+║                                                                           ║
+║   ❌ COORDINATORS NEVER DO THIS:                                          ║
+║                                                                           ║
+║   - Read implementation files (read(), glob src/**, grep for patterns)   ║
+║   - Edit code (edit(), write() any .ts/.js/.tsx files)                  ║
+║   - Run tests (bash "bun test", "npm test", pytest)                     ║
+║   - Implement features (adding functions, components, logic)             ║
+║   - Fix bugs (changing code to fix errors)                               ║
+║   - Install packages (bash "bun add", "npm install")                     ║
+║   - Commit changes (bash "git add", "git commit")                        ║
+║   - Reserve files (swarmmail_reserve - workers do this)                  ║
+║                                                                           ║
+║   ✅ COORDINATORS ONLY DO THIS:                                           ║
+║                                                                           ║
+║   - Clarify task scope (ask questions, understand requirements)          ║
+║   - Read package.json/tsconfig.json for structure (metadata only)        ║
+║   - Decompose into subtasks (swarm_plan_prompt, validate_decomposition)  ║
+║   - Spawn workers (swarm_spawn_subtask, Task(subagent_type="worker"))    ║
+║   - Monitor progress (swarmmail_inbox, swarm_status)                     ║
+║   - Review completed work (swarm_review, swarm_review_feedback)          ║
+║   - Verify final state (check all workers completed, hive_sync)          ║
+║                                                                           ║
+╚═══════════════════════════════════════════════════════════════════════════╝
+\`\`\`
+
+**Examples of Violations:**
+
+❌ **WRONG** - Coordinator reading implementation:
+\`\`\`
+read("src/auth/login.ts")           // NO - spawn worker to analyze
+glob("src/components/**/*.tsx")     // NO - spawn worker to inventory
+grep(pattern="export", include="*.ts")  // NO - spawn worker to search
+\`\`\`
+
+❌ **WRONG** - Coordinator editing code:
+\`\`\`
+edit("src/types.ts", ...)    // NO - spawn worker to fix
+write("src/new.ts", ...)     // NO - spawn worker to create
+\`\`\`
+
+❌ **WRONG** - Coordinator running tests:
+\`\`\`
+bash("bun test src/auth.test.ts")  // NO - worker runs tests
+\`\`\`
+
+❌ **WRONG** - Coordinator reserving files:
+\`\`\`
+swarmmail_reserve(paths=["src/auth.ts"])  // NO - worker reserves their own files
+swarm_spawn_subtask(bead_id="...", files=["src/auth.ts"])
+\`\`\`
+
+✅ **CORRECT** - Coordinator spawning worker:
+\`\`\`
+// Coordinator delegates ALL work
+swarm_spawn_subtask(
+  bead_id="fix-auth-bug",
+  epic_id="epic-123",
+  subtask_title="Fix null check in login handler",
+  files=["src/auth/login.ts", "src/auth/login.test.ts"],
+  shared_context="Bug: login fails when username is null"
+)
+Task(subagent_type="swarm-worker", prompt="<from above>")
+\`\`\`
+
 ### Why This Matters
 
 | Coordinator Work | Worker Work | Consequence of Mixing |

package/dist/swarm-strategies.d.ts

@@ -22,8 +22,8 @@ export declare const DecompositionStrategySchema: z.ZodEnum<{
     "file-based": "file-based";
     "feature-based": "feature-based";
     "risk-based": "risk-based";
-    auto: "auto";
     "research-based": "research-based";
+    auto: "auto";
 }>;
 /**
  * Marker words that indicate positive directives

package/dist/swarm.d.ts

@@ -123,7 +123,7 @@ export declare const swarmTools: {
             files_touched: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
             skip_verification: import("zod").ZodOptional<import("zod").ZodBoolean>;
             planned_files: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-            start_time: import("zod").ZodOptional<import("zod").ZodNumber>;
+            start_time: import("zod").ZodNumber;
             error_count: import("zod").ZodOptional<import("zod").ZodNumber>;
             retry_count: import("zod").ZodOptional<import("zod").ZodNumber>;
             skip_review: import("zod").ZodOptional<import("zod").ZodBoolean>;
@@ -133,11 +133,11 @@ export declare const swarmTools: {
             agent_name: string;
             bead_id: string;
             summary: string;
+            start_time: number;
             evaluation?: string | undefined;
             files_touched?: string[] | undefined;
             skip_verification?: boolean | undefined;
             planned_files?: string[] | undefined;
-            start_time?: number | undefined;
             error_count?: number | undefined;
             retry_count?: number | undefined;
             skip_review?: boolean | undefined;

package/examples/plugin-wrapper-template.ts

@@ -2775,8 +2775,9 @@ const SwarmPlugin: Plugin = async (
           has_projection: !!sessionScan.projection?.isSwarm,
         });
 
-        // Hoist snapshot outside try block so it's available in fallback path
+        // Hoist snapshot and queryDuration outside try block so they're available in fallback path
         let snapshot: SwarmStateSnapshot | undefined;
+        let queryDuration = 0; // 0 if using projection, actual duration if using hive query
         
         try {
           // =======================================================================
@@ -2821,7 +2822,7 @@ const SwarmPlugin: Plugin = async (
             // Fallback to hive query (may be stale)
             const queryStart = Date.now();
             snapshot = await querySwarmState(input.sessionID);
-            const queryDuration = Date.now() - queryStart;
+            queryDuration = Date.now() - queryStart;
             
             logCompaction("info", "fallback_to_hive_query", {
               session_id: input.sessionID,
@@ -2967,6 +2968,16 @@ const SwarmPlugin: Plugin = async (
           });
         }
 
+        // Guard: Don't double-inject if LLM prompt was already set
+        // This can happen if the error occurred after setting output.prompt but before return
+        if ("prompt" in output && output.prompt) {
+          logCompaction("info", "skipping_static_fallback_prompt_already_set", {
+            session_id: input.sessionID,
+            prompt_length: output.prompt.length,
+          });
+          return;
+        }
+
         // Level 3: Fall back to static context WITH dynamic state from snapshot
         const header = `[Swarm detected: ${detection.reasons.join(", ")}]\n\n`;
         

package/package.json

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