opencode-swarm-plugin 0.44.1 → 0.45.0

package/dist/index.js

@@ -13177,6 +13177,74 @@ var init_eval_capture = __esm(() => {
   inProgressRecords = new Map;
 });
 
+// src/swarm-validation.ts
+var exports_swarm_validation = {};
+__export(exports_swarm_validation, {
+  runPostSwarmValidation: () => runPostSwarmValidation,
+  reportIssue: () => reportIssue,
+  ValidationIssueSeverity: () => ValidationIssueSeverity,
+  ValidationIssueSchema: () => ValidationIssueSchema,
+  ValidationIssueCategory: () => ValidationIssueCategory
+});
+async function runPostSwarmValidation(ctx, events) {
+  const startTime = Date.now();
+  const issues = [];
+  await ctx.emit({
+    type: "validation_started",
+    project_key: ctx.project_key,
+    timestamp: startTime,
+    epic_id: ctx.epic_id,
+    swarm_id: ctx.swarm_id,
+    started_at: ctx.started_at.getTime()
+  });
+  const duration_ms = Date.now() - startTime;
+  await ctx.emit({
+    type: "validation_completed",
+    project_key: ctx.project_key,
+    timestamp: Date.now(),
+    epic_id: ctx.epic_id,
+    swarm_id: ctx.swarm_id,
+    passed: issues.length === 0,
+    issue_count: issues.length,
+    duration_ms
+  });
+  return { passed: issues.length === 0, issues };
+}
+async function reportIssue(ctx, issue2) {
+  await ctx.emit({
+    type: "validation_issue",
+    project_key: ctx.project_key,
+    timestamp: new Date().toISOString(),
+    epic_id: ctx.epic_id,
+    severity: issue2.severity,
+    category: issue2.category,
+    message: issue2.message,
+    location: issue2.location
+  });
+}
+var ValidationIssueSeverity, ValidationIssueCategory, ValidationIssueSchema;
+var init_swarm_validation = __esm(() => {
+  init_zod();
+  ValidationIssueSeverity = exports_external.enum(["error", "warning", "info"]);
+  ValidationIssueCategory = exports_external.enum([
+    "schema_mismatch",
+    "missing_event",
+    "undefined_value",
+    "dashboard_render",
+    "websocket_delivery"
+  ]);
+  ValidationIssueSchema = exports_external.object({
+    severity: ValidationIssueSeverity,
+    category: ValidationIssueCategory,
+    message: exports_external.string(),
+    location: exports_external.object({
+      event_type: exports_external.string().optional(),
+      field: exports_external.string().optional(),
+      component: exports_external.string().optional()
+    }).optional()
+  });
+});
+
 // ../../node_modules/.bun/@ioredis+commands@1.4.0/node_modules/@ioredis/commands/built/commands.json
 var require_commands = __commonJS((exports, module) => {
   module.exports = {
@@ -22492,7 +22560,7 @@ __export(exports_swarm_strategies, {
   NEGATIVE_MARKERS: () => NEGATIVE_MARKERS,
   DecompositionStrategySchema: () => DecompositionStrategySchema
 });
-function selectStrategy(task) {
+async function selectStrategy(task, projectKey) {
   const taskLower = task.toLowerCase();
   const scores = {
     "file-based": 0,
@@ -22520,7 +22588,8 @@ function selectStrategy(task) {
   const [winner, winnerScore] = entries[0];
   const [, runnerUpScore] = entries[1] || [null, 0];
   const totalScore = entries.reduce((sum, [, score]) => sum + score, 0);
-  const confidence = totalScore > 0 ? Math.min(0.95, 0.5 + (winnerScore - runnerUpScore) / totalScore) : 0.5;
+  let confidence = totalScore > 0 ? Math.min(0.95, 0.5 + (winnerScore - runnerUpScore) / totalScore) : 0.5;
+  const finalStrategy = winnerScore === 0 ? "feature-based" : winner;
   let reasoning;
   if (winnerScore === 0) {
     reasoning = `No strong keyword signals. Defaulting to feature-based as it's most versatile.`;
@@ -22528,12 +22597,73 @@ function selectStrategy(task) {
     const matchedKeywords = STRATEGIES[winner].keywords.filter((k) => taskLower.includes(k));
     reasoning = `Matched keywords: ${matchedKeywords.join(", ")}. ${STRATEGIES[winner].description}`;
   }
-  const finalStrategy = winnerScore === 0 ? "feature-based" : winner;
+  let precedent;
+  if (projectKey) {
+    try {
+      const {
+        createLibSQLAdapter,
+        getDatabasePath,
+        findSimilarDecisions,
+        getStrategySuccessRates
+      } = await import("swarm-mail");
+      const dbPath = getDatabasePath(projectKey);
+      const db = await createLibSQLAdapter({ url: `file:${dbPath}` });
+      const similarDecisions = await findSimilarDecisions(db, task, 5);
+      const successRates = await getStrategySuccessRates(db);
+      precedent = {
+        similar_decisions: similarDecisions.length
+      };
+      if (similarDecisions.length > 0) {
+        const epicIds = [];
+        for (const decision of similarDecisions) {
+          try {
+            const decisionData = typeof decision.decision === "string" ? JSON.parse(decision.decision) : decision.decision;
+            if (decisionData.epic_id) {
+              epicIds.push(decisionData.epic_id);
+            }
+          } catch {}
+        }
+        if (epicIds.length > 0) {
+          precedent.cited_epics = epicIds;
+        }
+        const precedentStrategies = similarDecisions.map((d) => {
+          try {
+            const data = typeof d.decision === "string" ? JSON.parse(d.decision) : d.decision;
+            return data.strategy;
+          } catch {
+            return null;
+          }
+        }).filter(Boolean);
+        const agreesWithKeywords = precedentStrategies.includes(finalStrategy);
+        if (agreesWithKeywords) {
+          confidence = Math.min(0.95, confidence + 0.1);
+          reasoning += ` Precedent confirms: ${precedent.similar_decisions} similar decision(s) also chose ${finalStrategy}.`;
+        }
+      }
+      const strategyRate = successRates.find((r) => r.strategy === finalStrategy);
+      if (strategyRate) {
+        precedent.strategy_success_rate = strategyRate.success_rate;
+        if (strategyRate.success_rate >= 0.7) {
+          confidence = Math.min(0.95, confidence + 0.05);
+          reasoning += ` ${finalStrategy} has ${Math.round(strategyRate.success_rate * 100)}% success rate.`;
+        } else if (strategyRate.success_rate < 0.3) {
+          confidence = Math.max(0.1, confidence - 0.1);
+          reasoning += ` Warning: ${finalStrategy} has low success rate (${Math.round(strategyRate.success_rate * 100)}%).`;
+        }
+      }
+      if (db.close) {
+        await db.close();
+      }
+    } catch (error45) {
+      console.warn("Failed to query precedent data:", error45);
+    }
+  }
   return {
     strategy: finalStrategy,
     confidence,
     reasoning,
-    alternatives: entries.filter(([s]) => s !== finalStrategy).map(([strategy, score]) => ({ strategy, score }))
+    alternatives: entries.filter(([s]) => s !== finalStrategy).map(([strategy, score]) => ({ strategy, score })),
+    precedent
   };
 }
 function formatStrategyGuidelines(strategy) {
@@ -22742,13 +22872,14 @@ var init_swarm_strategies = __esm(() => {
     }
   };
   swarm_select_strategy = tool({
-    description: "Analyze task and recommend decomposition strategy (file-based, feature-based, or risk-based)",
+    description: "Analyze task and recommend decomposition strategy (file-based, feature-based, or risk-based) with optional precedent data",
     args: {
       task: tool.schema.string().min(1).describe("Task description to analyze"),
-      codebase_context: tool.schema.string().optional().describe("Optional codebase context (file structure, tech stack, etc.)")
+      codebase_context: tool.schema.string().optional().describe("Optional codebase context (file structure, tech stack, etc.)"),
+      projectKey: tool.schema.string().optional().describe("Optional project path for precedent-aware strategy selection")
     },
     async execute(args) {
-      const result = selectStrategy(args.task);
+      const result = await selectStrategy(args.task, args.projectKey);
       let enhancedReasoning = result.reasoning;
       if (args.codebase_context) {
         enhancedReasoning += `
@@ -22766,7 +22897,8 @@ Codebase context considered: ${args.codebase_context.slice(0, 200)}...`;
           strategy: alt.strategy,
           description: STRATEGIES[alt.strategy].description,
           score: alt.score
-        }))
+        })),
+        precedent: result.precedent
       }, null, 2);
     }
   });
@@ -38949,7 +39081,8 @@ import {
   importFromJSONL,
   syncMemories,
   getSwarmMailLibSQL,
-  resolvePartialId
+  resolvePartialId,
+  findCellsByPartialId
 } from "swarm-mail";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 import { join as join2 } from "node:path";
@@ -40216,6 +40349,37 @@ var hive_close = tool({
             total_files_touched: totalFilesTouched
           });
           await appendEvent2(swarmCompletedEvent, projectKey);
+          try {
+            const { runPostSwarmValidation: runPostSwarmValidation2 } = await Promise.resolve().then(() => (init_swarm_validation(), exports_swarm_validation));
+            const { readEvents } = await import("swarm-mail");
+            const swarmEvents = await readEvents({
+              projectKey,
+              types: [
+                "swarm_started",
+                "swarm_completed",
+                "worker_spawned",
+                "subtask_outcome",
+                "decomposition_generated"
+              ]
+            }, projectKey);
+            runPostSwarmValidation2({
+              project_key: projectKey,
+              epic_id: cellId,
+              swarm_id: cellId,
+              started_at: new Date,
+              emit: async (event) => {
+                await appendEvent2(event, projectKey);
+              }
+            }, swarmEvents).then((result) => {
+              if (!result.passed) {
+                console.warn(`[Validation] Found ${result.issues.length} issues in swarm ${cellId}`);
+              }
+            }).catch((err) => {
+              console.error(`[Validation] Failed:`, err);
+            });
+          } catch (error45) {
+            console.warn("[hive_close] Validation hook failed (non-fatal):", error45);
+          }
         } catch (error45) {
           console.warn("[hive_close] Failed to emit SwarmCompletedEvent:", error45);
         }
@@ -40309,13 +40473,12 @@ PREFER THIS OVER hive_query when you need to:
     const adapter = await getHiveAdapter(projectKey);
     try {
       if (args.id) {
-        const fullId = await resolvePartialId(adapter, projectKey, args.id) || args.id;
-        const cell = await adapter.getCell(projectKey, fullId);
-        if (!cell) {
+        const matchingCells = await findCellsByPartialId(adapter, projectKey, args.id);
+        if (matchingCells.length === 0) {
           throw new HiveError(`No cell found matching ID '${args.id}'`, "hive_cells");
         }
-        const formatted2 = formatCellForOutput(cell);
-        return JSON.stringify([formatted2], null, 2);
+        const formatted2 = matchingCells.map((c) => formatCellForOutput(c));
+        return JSON.stringify(formatted2, null, 2);
       }
       if (args.ready) {
         const ready = await adapter.getNextReadyCell(projectKey);
@@ -40334,10 +40497,10 @@ PREFER THIS OVER hive_query when you need to:
       const formatted = cells.map((c) => formatCellForOutput(c));
       return JSON.stringify(formatted, null, 2);
     } catch (error45) {
-      const message = error45 instanceof Error ? error45.message : String(error45);
-      if (message.includes("Ambiguous hash")) {
-        throw new HiveError(`Ambiguous ID '${args.id}': multiple cells match. Please provide more characters.`, "hive_cells");
+      if (error45 instanceof HiveError) {
+        throw error45;
       }
+      const message = error45 instanceof Error ? error45.message : String(error45);
       if (message.includes("Bead not found") || message.includes("Cell not found")) {
         throw new HiveError(`No cell found matching ID '${args.id || "unknown"}'`, "hive_cells");
       }
@@ -42784,6 +42947,139 @@ init_dist();
 init_zod();
 init_swarm_strategies();
 init_eval_capture();
+
+// src/decision-trace-integration.ts
+import {
+  createDecisionTrace,
+  createEntityLink
+} from "swarm-mail";
+import { createLibSQLAdapter } from "swarm-mail";
+import { getDatabasePath } from "swarm-mail";
+async function getTraceDb(projectPath) {
+  const dbPath = getDatabasePath(projectPath);
+  return createLibSQLAdapter({ url: `file:${dbPath}` });
+}
+function extractMemoryIds(precedentCited) {
+  if (!precedentCited) {
+    return [];
+  }
+  if (precedentCited.memoryIds && Array.isArray(precedentCited.memoryIds)) {
+    return precedentCited.memoryIds;
+  }
+  if (precedentCited.memoryId) {
+    return [precedentCited.memoryId];
+  }
+  return [];
+}
+async function traceStrategySelection(input) {
+  try {
+    const db = await getTraceDb(input.projectKey);
+    const trace = await createDecisionTrace(db, {
+      decision_type: "strategy_selection",
+      epic_id: input.epicId,
+      bead_id: input.beadId,
+      agent_name: input.agentName,
+      project_key: input.projectKey,
+      decision: {
+        strategy: input.strategy,
+        confidence: input.confidence,
+        task_preview: input.taskPreview
+      },
+      rationale: input.reasoning,
+      inputs_gathered: input.inputsGathered,
+      alternatives: input.alternatives,
+      precedent_cited: input.precedentCited
+    });
+    const memoryIds = extractMemoryIds(input.precedentCited);
+    for (const memoryId of memoryIds) {
+      await createEntityLink(db, {
+        source_decision_id: trace.id,
+        target_entity_type: "memory",
+        target_entity_id: memoryId,
+        link_type: "cites_precedent",
+        strength: input.precedentCited?.similarity ?? 1,
+        context: "Cited as precedent for strategy selection"
+      });
+    }
+    await db.close?.();
+    return trace.id;
+  } catch (error45) {
+    console.warn("[decision-trace] Failed to trace strategy_selection:", error45);
+    return "";
+  }
+}
+async function traceWorkerSpawn(input) {
+  try {
+    const db = await getTraceDb(input.projectKey);
+    const trace = await createDecisionTrace(db, {
+      decision_type: "worker_spawn",
+      epic_id: input.epicId,
+      bead_id: input.beadId,
+      agent_name: input.agentName,
+      project_key: input.projectKey,
+      decision: {
+        worker: input.workerName || "worker",
+        subtask_title: input.subtaskTitle,
+        files: input.files,
+        model: input.model,
+        spawn_order: input.spawnOrder,
+        is_parallel: input.isParallel
+      },
+      rationale: input.rationale || `Spawning worker for: ${input.subtaskTitle}`
+    });
+    for (const file2 of input.files) {
+      await createEntityLink(db, {
+        source_decision_id: trace.id,
+        target_entity_type: "file",
+        target_entity_id: file2,
+        link_type: "assigns_file",
+        strength: 1,
+        context: `File assigned to worker ${input.workerName || "worker"}`
+      });
+    }
+    await db.close?.();
+    return trace.id;
+  } catch (error45) {
+    console.warn("[decision-trace] Failed to trace worker_spawn:", error45);
+    return "";
+  }
+}
+async function traceReviewDecision(input) {
+  try {
+    const db = await getTraceDb(input.projectKey);
+    const trace = await createDecisionTrace(db, {
+      decision_type: "review_decision",
+      epic_id: input.epicId,
+      bead_id: input.beadId,
+      agent_name: input.agentName,
+      project_key: input.projectKey,
+      decision: {
+        status: input.status,
+        worker_id: input.workerId,
+        issues_count: input.issues?.length || 0,
+        attempt_number: input.attemptNumber,
+        remaining_attempts: input.remainingAttempts
+      },
+      rationale: input.rationale || input.summary || `Review ${input.status}`,
+      inputs_gathered: input.issues ? [{ source: "code_review", issues: input.issues }] : undefined
+    });
+    await createEntityLink(db, {
+      source_decision_id: trace.id,
+      target_entity_type: "agent",
+      target_entity_id: input.workerId,
+      link_type: "reviewed_work_by",
+      strength: 1,
+      context: `Review ${input.status} for ${input.workerId}`
+    });
+    await db.close?.();
+    return trace.id;
+  } catch (error45) {
+    console.warn("[decision-trace] Failed to trace review_decision:", error45);
+    return "";
+  }
+}
+
+// src/swarm-decompose.ts
 var DECOMPOSITION_PROMPT = `You are decomposing a task into parallelizable subtasks for a swarm of agents.
 
 ## Task
@@ -43215,7 +43511,7 @@ var swarm_delegate_planning = tool({
       selectedStrategy = args.strategy;
       strategyReasoning = `User-specified strategy: ${selectedStrategy}`;
     } else {
-      const selection = selectStrategy2(args.task);
+      const selection = await selectStrategy2(args.task);
       selectedStrategy = selection.strategy;
       strategyReasoning = selection.reasoning;
     }
@@ -43257,6 +43553,27 @@ var swarm_delegate_planning = tool({
     } else {
       cassResultInfo = { queried: false, reason: "disabled" };
     }
+    try {
+      await traceStrategySelection({
+        projectKey: args.context?.includes("/") ? args.context.split(" ")[0] : process.cwd(),
+        agentName: "coordinator",
+        epicId: undefined,
+        strategy: selectedStrategy,
+        reasoning: strategyReasoning,
+        confidence: undefined,
+        taskPreview: args.task.slice(0, 200),
+        inputsGathered: cassResultInfo.queried ? [
+          {
+            source: "cass",
+            query: args.task,
+            results: cassResultInfo.results_found ?? 0
+          }
+        ] : undefined,
+        alternatives: undefined
+      });
+    } catch (error45) {
+      console.warn("[swarm_delegate_planning] Failed to trace strategy_selection:", error45);
+    }
     let skillsContext = "";
     let skillsInfo = {
       included: false
@@ -43394,7 +43711,7 @@ Limit: ${memoryQuery.limit}`;
       }
     } catch (error45) {}
     if (mode === "fast") {
-      const strategyResult = selectStrategy2(args.task);
+      const strategyResult = await selectStrategy2(args.task);
       const guidelines = formatStrategyGuidelines2(strategyResult.strategy);
       const output = {
         mode: "fast",
@@ -43413,7 +43730,7 @@ ${guidelines}`
       return JSON.stringify(output, null, 2);
     }
     if (mode === "auto") {
-      const strategyResult = selectStrategy2(args.task);
+      const strategyResult = await selectStrategy2(args.task);
       const output = {
         mode: "auto",
         phase: "ready",
@@ -43508,7 +43825,7 @@ ${guidelines}`
       return JSON.stringify(output, null, 2);
     }
     if (currentPhase === "alternatives") {
-      const strategyResult = selectStrategy2(args.task);
+      const strategyResult = await selectStrategy2(args.task);
       const alternatives = [];
       alternatives.push({
         name: strategyResult.strategy,
@@ -43535,7 +43852,7 @@ ${guidelines}`
       return JSON.stringify(output, null, 2);
     }
     if (currentPhase === "recommendation") {
-      const strategyResult = selectStrategy2(args.task);
+      const strategyResult = await selectStrategy2(args.task);
       const guidelines = formatStrategyGuidelines2(strategyResult.strategy);
       const output = {
         mode: "socratic",
@@ -45606,6 +45923,22 @@ var swarm_review_feedback = tool({
       } catch (error45) {
         console.warn("[swarm_review_feedback] Failed to capture review_completed:", error45);
       }
+      try {
+        await traceReviewDecision({
+          projectKey: args.project_key,
+          agentName: "coordinator",
+          epicId,
+          beadId: args.task_id,
+          workerId: args.worker_id,
+          status: "approved",
+          summary: args.summary,
+          attemptNumber: 1,
+          remainingAttempts: MAX_REVIEW_ATTEMPTS,
+          rationale: args.summary || "Review approved"
+        });
+      } catch (error45) {
+        console.warn("[swarm_review_feedback] Failed to trace review_decision:", error45);
+      }
       try {
         const { createEvent: createEvent2, appendEvent: appendEvent2 } = await import("swarm-mail");
         const attempt = getReviewStatus(args.task_id).attempt_count || 1;
@@ -45660,6 +45993,23 @@ You may now complete the task with \`swarm_complete\`.`,
     } catch (error45) {
       console.warn("[swarm_review_feedback] Failed to capture review_completed:", error45);
     }
+    try {
+      await traceReviewDecision({
+        projectKey: args.project_key,
+        agentName: "coordinator",
+        epicId,
+        beadId: args.task_id,
+        workerId: args.worker_id,
+        status: "needs_changes",
+        summary: args.summary,
+        issues: parsedIssues,
+        attemptNumber,
+        remainingAttempts: remaining,
+        rationale: args.summary || `Review rejected: ${parsedIssues.length} issue(s) found`
+      });
+    } catch (error45) {
+      console.warn("[swarm_review_feedback] Failed to trace review_decision:", error45);
+    }
     try {
       const { createEvent: createEvent2, appendEvent: appendEvent2 } = await import("swarm-mail");
       const status = remaining <= 0 ? "blocked" : "needs_changes";
@@ -61840,9 +62190,9 @@ async function getPromptInsights(options2) {
 }
 async function getCoordinatorInsights(project_key) {
   try {
-    const { createLibSQLAdapter, createSwarmMailAdapter: createSwarmMailAdapter2 } = await import("swarm-mail");
+    const { createLibSQLAdapter: createLibSQLAdapter2, createSwarmMailAdapter: createSwarmMailAdapter2 } = await import("swarm-mail");
     const { getStrategyInsights: getStrategyInsights2, getPatternInsights: getPatternInsights2, formatInsightsForPrompt: formatInsightsForPrompt2 } = await Promise.resolve().then(() => (init_swarm_insights(), exports_swarm_insights));
-    const dbAdapter = await createLibSQLAdapter({ url: "file:./.swarm-mail/streams.db" });
+    const dbAdapter = await createLibSQLAdapter2({ url: "file:./.swarm-mail/streams.db" });
     const adapter = createSwarmMailAdapter2(dbAdapter, project_key || "default");
     const [strategies, patterns] = await Promise.all([
       getStrategyInsights2(adapter, ""),
@@ -61870,7 +62220,7 @@ ${formatted}
 }
 async function getWorkerInsights(files, domain2) {
   try {
-    const { createLibSQLAdapter, createSwarmMailAdapter: createSwarmMailAdapter2 } = await import("swarm-mail");
+    const { createLibSQLAdapter: createLibSQLAdapter2, createSwarmMailAdapter: createSwarmMailAdapter2 } = await import("swarm-mail");
     const { getFileInsights: getFileInsights2, formatInsightsForPrompt: formatInsightsForPrompt2 } = await Promise.resolve().then(() => (init_swarm_insights(), exports_swarm_insights));
     const memoryAdapter = await getMemoryAdapter();
     let query = "";
@@ -61887,7 +62237,7 @@ async function getWorkerInsights(files, domain2) {
         if (!files || files.length === 0)
           return [];
         try {
-          const dbAdapter = await createLibSQLAdapter({ url: "file:./.swarm-mail/streams.db" });
+          const dbAdapter = await createLibSQLAdapter2({ url: "file:./.swarm-mail/streams.db" });
           const swarmMail = createSwarmMailAdapter2(dbAdapter, "default");
           return await getFileInsights2(swarmMail, files);
         } catch (e) {
@@ -62096,6 +62446,23 @@ var swarm_spawn_subtask = tool({
     } catch (error45) {
       console.warn("[swarm_spawn_subtask] Failed to capture worker_spawned:", error45);
     }
+    try {
+      await traceWorkerSpawn({
+        projectKey: args2.project_path || process.cwd(),
+        agentName: "coordinator",
+        epicId: args2.epic_id,
+        beadId: args2.bead_id,
+        workerName: "worker",
+        subtaskTitle: args2.subtask_title,
+        files: args2.files,
+        model: selectedModel,
+        spawnOrder: 0,
+        isParallel: false,
+        rationale: args2.subtask_description || `Spawning worker for: ${args2.subtask_title}`
+      });
+    } catch (error45) {
+      console.warn("[swarm_spawn_subtask] Failed to trace worker_spawn:", error45);
+    }
     if (args2.project_path) {
       try {
         const { createEvent: createEvent3, appendEvent: appendEvent3 } = await import("swarm-mail");
@@ -62325,7 +62692,7 @@ var swarm_plan_prompt = tool({
       selectedStrategy = args2.strategy;
       strategyReasoning = `User-specified strategy: ${selectedStrategy}`;
     } else {
-      const selection = selectStrategy2(args2.task);
+      const selection = await selectStrategy2(args2.task);
       selectedStrategy = selection.strategy;
       strategyReasoning = selection.reasoning;
     }
@@ -66430,6 +66797,243 @@ async function resetStorage() {
 
 // src/index.ts
 init_skills();
+init_swarm_validation();
+
+// src/swarm-signature.ts
+function projectSwarmState(events) {
+  const state = {
+    isSwarm: false,
+    subtasks: new Map,
+    counts: {
+      total: 0,
+      created: 0,
+      spawned: 0,
+      inProgress: 0,
+      completed: 0,
+      closed: 0
+    }
+  };
+  let hasEpic = false;
+  let hasSpawn = false;
+  for (const event of events) {
+    state.lastEventAt = event.timestamp;
+    switch (event.tool) {
+      case "hive_create_epic": {
+        const epicId = parseEpicId(event.output);
+        const epicTitle = typeof event.input.epic_title === "string" ? event.input.epic_title : undefined;
+        if (epicId) {
+          state.epic = {
+            id: epicId,
+            title: epicTitle || "Unknown Epic",
+            status: "open",
+            createdAt: event.timestamp
+          };
+          hasEpic = true;
+          const subtasks = event.input.subtasks;
+          if (Array.isArray(subtasks)) {
+            for (const subtask of subtasks) {
+              if (typeof subtask === "object" && subtask !== null) {
+                const st = subtask;
+                const title = typeof st.title === "string" ? st.title : "Unknown";
+                const files = Array.isArray(st.files) ? st.files : [];
+                state.counts.created++;
+                state.counts.total++;
+              }
+            }
+          }
+          const subtaskIds = parseSubtaskIds(event.output);
+          for (const id of subtaskIds) {
+            if (!state.subtasks.has(id)) {
+              state.subtasks.set(id, {
+                id,
+                title: "Unknown",
+                status: "created",
+                files: []
+              });
+              state.counts.total++;
+              state.counts.created++;
+            }
+          }
+        }
+        break;
+      }
+      case "swarm_spawn_subtask": {
+        const beadId = typeof event.input.bead_id === "string" ? event.input.bead_id : undefined;
+        const epicId = typeof event.input.epic_id === "string" ? event.input.epic_id : undefined;
+        const title = typeof event.input.subtask_title === "string" ? event.input.subtask_title : "Unknown";
+        const files = Array.isArray(event.input.files) ? event.input.files : [];
+        if (beadId) {
+          hasSpawn = true;
+          const existing = state.subtasks.get(beadId);
+          if (existing) {
+            if (existing.status === "created") {
+              state.counts.created--;
+              state.counts.spawned++;
+            }
+            existing.status = "spawned";
+            existing.title = title;
+            existing.files = files;
+            existing.spawnedAt = event.timestamp;
+          } else {
+            state.subtasks.set(beadId, {
+              id: beadId,
+              title,
+              status: "spawned",
+              files,
+              spawnedAt: event.timestamp
+            });
+            state.counts.total++;
+            state.counts.spawned++;
+          }
+          if (epicId && !state.epic) {
+            state.epic = {
+              id: epicId,
+              title: "Unknown Epic",
+              status: "in_progress",
+              createdAt: event.timestamp
+            };
+          }
+        }
+        break;
+      }
+      case "hive_start": {
+        const id = typeof event.input.id === "string" ? event.input.id : undefined;
+        if (id) {
+          const subtask = state.subtasks.get(id);
+          if (subtask && subtask.status !== "completed" && subtask.status !== "closed") {
+            if (subtask.status === "created")
+              state.counts.created--;
+            else if (subtask.status === "spawned")
+              state.counts.spawned--;
+            subtask.status = "in_progress";
+            state.counts.inProgress++;
+          }
+          if (state.epic && state.epic.id === id) {
+            state.epic.status = "in_progress";
+          }
+        }
+        break;
+      }
+      case "swarm_complete": {
+        const beadId = typeof event.input.bead_id === "string" ? event.input.bead_id : undefined;
+        if (beadId) {
+          const subtask = state.subtasks.get(beadId);
+          if (subtask && subtask.status !== "closed") {
+            if (subtask.status === "created")
+              state.counts.created--;
+            else if (subtask.status === "spawned")
+              state.counts.spawned--;
+            else if (subtask.status === "in_progress")
+              state.counts.inProgress--;
+            subtask.status = "completed";
+            subtask.completedAt = event.timestamp;
+            state.counts.completed++;
+          }
+        }
+        break;
+      }
+      case "hive_close": {
+        const id = typeof event.input.id === "string" ? event.input.id : undefined;
+        if (id) {
+          const subtask = state.subtasks.get(id);
+          if (subtask) {
+            if (subtask.status === "created")
+              state.counts.created--;
+            else if (subtask.status === "spawned")
+              state.counts.spawned--;
+            else if (subtask.status === "in_progress")
+              state.counts.inProgress--;
+            else if (subtask.status === "completed")
+              state.counts.completed--;
+            subtask.status = "closed";
+            state.counts.closed++;
+          }
+          if (state.epic && state.epic.id === id) {
+            state.epic.status = "closed";
+          }
+        }
+        break;
+      }
+      case "swarmmail_init": {
+        try {
+          const parsed = JSON.parse(event.output);
+          if (parsed.agent_name) {
+            state.coordinatorName = parsed.agent_name;
+          }
+          if (parsed.project_key) {
+            state.projectPath = parsed.project_key;
+          }
+        } catch {}
+        break;
+      }
+    }
+  }
+  state.isSwarm = hasEpic && hasSpawn;
+  return state;
+}
+function parseEpicId(output) {
+  try {
+    const parsed = JSON.parse(output);
+    return parsed.epic?.id || parsed.id;
+  } catch {
+    return;
+  }
+}
+function parseSubtaskIds(output) {
+  try {
+    const parsed = JSON.parse(output);
+    const subtasks = parsed.subtasks || parsed.epic?.subtasks || [];
+    return subtasks.map((s) => {
+      if (typeof s === "object" && s !== null && "id" in s) {
+        return s.id;
+      }
+      return;
+    }).filter((id) => typeof id === "string");
+  } catch {
+    return [];
+  }
+}
+function hasSwarmSignature(events) {
+  let hasEpic = false;
+  let hasSpawn = false;
+  for (const event of events) {
+    if (event.tool === "hive_create_epic") {
+      hasEpic = true;
+    } else if (event.tool === "swarm_spawn_subtask") {
+      hasSpawn = true;
+    }
+    if (hasEpic && hasSpawn) {
+      return true;
+    }
+  }
+  return false;
+}
+function isSwarmActive(projection) {
+  if (!projection.isSwarm) {
+    return false;
+  }
+  return projection.counts.created > 0 || projection.counts.spawned > 0 || projection.counts.inProgress > 0 || projection.counts.completed > 0;
+}
+function getSwarmSummary(projection) {
+  if (!projection.isSwarm) {
+    return "No swarm detected";
+  }
+  const { counts, epic } = projection;
+  const parts2 = [];
+  if (epic) {
+    parts2.push(`Epic: ${epic.id} - ${epic.title} [${epic.status}]`);
+  }
+  parts2.push(`Subtasks: ${counts.total} total (${counts.spawned} spawned, ${counts.inProgress} in_progress, ${counts.completed} completed, ${counts.closed} closed)`);
+  if (isSwarmActive(projection)) {
+    parts2.push("Status: ACTIVE - has pending work");
+  } else {
+    parts2.push("Status: COMPLETE - all work closed");
+  }
+  return parts2.join(`
+`);
+}
+
+// src/index.ts
 var SwarmPlugin = async (input) => {
   const { $, directory, client } = input;
   setHiveWorkingDirectory(directory);
@@ -66608,18 +67212,21 @@ export {
   setAgentMailProjectDirectory,
   selectStrategy,
   scanSessionMessages,
+  runPostSwarmValidation,
   resetToolCache,
   resetStorage,
   resetMemoryCache,
   resetMandateStorage,
   researchTools,
   requireTool,
+  reportIssue,
   repoCrawlTools,
   recordPhaseStart,
   recordPhaseComplete,
   recordPatternSkipped,
   recordPatternExtracted,
   recordEvalRun,
+  projectSwarmState,
   parseFrontmatter,
   migrateBeadsToHive,
   mergeHistoricBeads,
@@ -66630,6 +67237,7 @@ export {
   logger,
   listSkills,
   isToolAvailable,
+  isSwarmActive,
   isStateTransitionEvent,
   isSemanticMemoryAvailable,
   isProjectNotFoundError,
@@ -66652,9 +67260,11 @@ export {
   hive_close,
   hive_cells,
   hiveTools,
+  hasSwarmSignature,
   guardrailOutput,
   groupByTransition,
   getToolAvailability,
+  getSwarmSummary,
   getSwarmMailProjectDirectory,
   getStorage,
   getStatusChanges,
@@ -66729,6 +67339,9 @@ export {
   VoteTypeSchema,
   VoteSchema,
   ValidationResultSchema,
+  ValidationIssueSeverity,
+  ValidationIssueSchema,
+  ValidationIssueCategory,
   VARIANCE_THRESHOLD,
   UpdateSwarmContextArgsSchema,
   TaskDecompositionSchema,