opencode-swarm-plugin 0.44.2 → 0.45.0

package/dist/index.js

@@ -22560,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,
@@ -22588,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.`;
@@ -22596,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) {
@@ -22810,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 += `
@@ -22834,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);
     }
   });
@@ -39017,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";
@@ -40408,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);
@@ -40433,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");
       }
@@ -42883,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
@@ -43314,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;
     }
@@ -43356,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
@@ -43493,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",
@@ -43512,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",
@@ -43607,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,
@@ -43634,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",
@@ -45705,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;
@@ -45759,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";
@@ -61939,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, ""),
@@ -61969,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 = "";
@@ -61986,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) {
@@ -62195,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");
@@ -62424,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;
     }
@@ -66530,6 +66798,242 @@ 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);
@@ -66722,6 +67226,7 @@ export {
   recordPatternSkipped,
   recordPatternExtracted,
   recordEvalRun,
+  projectSwarmState,
   parseFrontmatter,
   migrateBeadsToHive,
   mergeHistoricBeads,
@@ -66732,6 +67237,7 @@ export {
   logger,
   listSkills,
   isToolAvailable,
+  isSwarmActive,
   isStateTransitionEvent,
   isSemanticMemoryAvailable,
   isProjectNotFoundError,
@@ -66754,9 +67260,11 @@ export {
   hive_close,
   hive_cells,
   hiveTools,
+  hasSwarmSignature,
   guardrailOutput,
   groupByTransition,
   getToolAvailability,
+  getSwarmSummary,
   getSwarmMailProjectDirectory,
   getStorage,
   getStatusChanges,