opencode-swarm-plugin 0.44.2 → 0.45.0

package/dist/swarm-prompts.js

@@ -18332,7 +18332,7 @@ __export(exports_swarm_strategies, {
   NEGATIVE_MARKERS: () => NEGATIVE_MARKERS,
   DecompositionStrategySchema: () => DecompositionStrategySchema2
 });
-function selectStrategy(task) {
+async function selectStrategy(task, projectKey) {
   const taskLower = task.toLowerCase();
   const scores = {
     "file-based": 0,
@@ -18360,7 +18360,8 @@ function selectStrategy(task) {
   const [winner, winnerScore] = entries2[0];
   const [, runnerUpScore] = entries2[1] || [null, 0];
   const totalScore = entries2.reduce((sum2, [, score]) => sum2 + 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.`;
@@ -18368,12 +18369,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: createLibSQLAdapter2,
+        getDatabasePath: getDatabasePath2,
+        findSimilarDecisions,
+        getStrategySuccessRates
+      } = await import("swarm-mail");
+      const dbPath = getDatabasePath2(projectKey);
+      const db = await createLibSQLAdapter2({ 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: entries2.filter(([s]) => s !== finalStrategy).map(([strategy, score]) => ({ strategy, score }))
+    alternatives: entries2.filter(([s]) => s !== finalStrategy).map(([strategy, score]) => ({ strategy, score })),
+    precedent
   };
 }
 function formatStrategyGuidelines(strategy) {
@@ -18582,13 +18644,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(args2) {
-      const result = selectStrategy(args2.task);
+      const result = await selectStrategy(args2.task, args2.projectKey);
       let enhancedReasoning = result.reasoning;
       if (args2.codebase_context) {
         enhancedReasoning += `
@@ -18606,7 +18669,8 @@ Codebase context considered: ${args2.codebase_context.slice(0, 200)}...`;
           strategy: alt.strategy,
           description: STRATEGIES[alt.strategy].description,
           score: alt.score
-        }))
+        })),
+        precedent: result.precedent
       }, null, 2);
     }
   });
@@ -20869,7 +20933,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";
@@ -21455,13 +21520,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);
@@ -21480,10 +21544,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");
       }
@@ -21992,6 +22056,90 @@ init_dist();
 init_zod();
 import { sendSwarmMessage } from "swarm-mail";
 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}` });
+}
+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-review.ts
 var ReviewIssueSchema = exports_external.object({
   file: exports_external.string(),
   line: exports_external.number().optional(),
@@ -22266,6 +22414,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;
@@ -22320,6 +22484,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";
@@ -38822,9 +39003,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, ""),
@@ -38852,7 +39033,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 = "";
@@ -38869,7 +39050,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) {
@@ -39081,6 +39262,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");
@@ -39310,7 +39508,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;
     }

package/dist/swarm-review.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swarm-review.d.ts","sourceRoot":"","sources":["../src/swarm-review.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,iBAAiB;;;;;iBAK5B,CAAC;AAEH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,UAAU,GAAG,eAAe,CAAC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC;IACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;iBAkB5B,CAAC;AAEJ;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,sBAAsB,CAAC,EAAE,cAAc,EAAE,CAAC;IAC1C,gBAAgB,CAAC,EAAE,cAAc,EAAE,CAAC;CACrC;AAkDD;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,CAsGzE;AAmED;;;;;GAKG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;CA+HvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;CAoNhC,CAAC;AAMH;;GAEG;AACH,UAAU,gBAAgB;IACxB,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAOD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAGvD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAGxD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAQhE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAGtD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAEvD;AAMD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGvB,CAAC"}
+{"version":3,"file":"swarm-review.d.ts","sourceRoot":"","sources":["../src/swarm-review.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,iBAAiB;;;;;iBAK5B,CAAC;AAEH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,UAAU,GAAG,eAAe,CAAC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC;IACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;iBAkB5B,CAAC;AAEJ;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,sBAAsB,CAAC,EAAE,cAAc,EAAE,CAAC;IAC1C,gBAAgB,CAAC,EAAE,cAAc,EAAE,CAAC;CACrC;AAkDD;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,CAsGzE;AAmED;;;;;GAKG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;CA+HvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;CA2PhC,CAAC;AAMH;;GAEG;AACH,UAAU,gBAAgB;IACxB,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAOD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAGvD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAGxD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAQhE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAGtD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAEvD;AAMD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGvB,CAAC"}

package/dist/swarm-signature.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Swarm Signature Detection
+ *
+ * Deterministic, algorithmic detection of swarm coordination from session events.
+ * No heuristics, no confidence levels - a swarm either exists or it doesn't.
+ *
+ * A SWARM is defined by this event sequence:
+ * 1. hive_create_epic(epic_title, subtasks[]) → epic_id
+ * 2. swarm_spawn_subtask(bead_id, epic_id, ...) → prompt (at least one)
+ *
+ * The projection folds over events to produce ground truth state:
+ * - Which epic is being coordinated
+ * - Which subtasks exist and their lifecycle status
+ * - What files are assigned to each subtask
+ *
+ * @module swarm-signature
+ */
+/**
+ * Subtask lifecycle status derived from events
+ */
+export type SubtaskStatus = "created" | "spawned" | "in_progress" | "completed" | "closed";
+/**
+ * Subtask state projected from events
+ */
+export interface SubtaskState {
+    id: string;
+    title: string;
+    status: SubtaskStatus;
+    files: string[];
+    worker?: string;
+    spawnedAt?: number;
+    completedAt?: number;
+}
+/**
+ * Epic state projected from events
+ */
+export interface EpicState {
+    id: string;
+    title: string;
+    status: "open" | "in_progress" | "closed";
+    createdAt: number;
+}
+/**
+ * Complete swarm state projected from session events
+ */
+export interface SwarmProjection {
+    /** Whether a valid swarm signature was detected */
+    isSwarm: boolean;
+    /** Epic being coordinated (if any) */
+    epic?: EpicState;
+    /** Subtasks by ID */
+    subtasks: Map<string, SubtaskState>;
+    /** Project path from swarmmail_init */
+    projectPath?: string;
+    /** Coordinator agent name from swarmmail_init */
+    coordinatorName?: string;
+    /** Last event timestamp */
+    lastEventAt?: number;
+    /** Summary counts for quick access */
+    counts: {
+        total: number;
+        created: number;
+        spawned: number;
+        inProgress: number;
+        completed: number;
+        closed: number;
+    };
+}
+/**
+ * Tool call event extracted from session messages
+ */
+export interface ToolCallEvent {
+    tool: string;
+    input: Record<string, unknown>;
+    output: string;
+    timestamp: number;
+}
+/**
+ * Project swarm state from session tool call events
+ *
+ * This is a pure fold over events - deterministic and side-effect free.
+ * The resulting state is the ground truth for swarm coordination.
+ *
+ * @param events - Tool call events from session messages (chronological order)
+ * @returns Projected swarm state
+ */
+export declare function projectSwarmState(events: ToolCallEvent[]): SwarmProjection;
+/**
+ * Check if events contain a valid swarm signature
+ *
+ * A swarm signature requires:
+ * 1. hive_create_epic call
+ * 2. At least one swarm_spawn_subtask call
+ *
+ * This is a quick check without full projection.
+ */
+export declare function hasSwarmSignature(events: ToolCallEvent[]): boolean;
+/**
+ * Check if swarm is still active (has pending work)
+ */
+export declare function isSwarmActive(projection: SwarmProjection): boolean;
+/**
+ * Get human-readable swarm status summary
+ */
+export declare function getSwarmSummary(projection: SwarmProjection): string;
+//# sourceMappingURL=swarm-signature.d.ts.map

package/dist/swarm-signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swarm-signature.d.ts","sourceRoot":"","sources":["../src/swarm-signature.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAMH;;GAEG;AACH,MAAM,MAAM,aAAa,GACrB,SAAS,GACT,SAAS,GACT,aAAa,GACb,WAAW,GACX,QAAQ,CAAC;AAEb;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,aAAa,CAAC;IACtB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,QAAQ,CAAC;IAC1C,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,mDAAmD;IACnD,OAAO,EAAE,OAAO,CAAC;IAEjB,sCAAsC;IACtC,IAAI,CAAC,EAAE,SAAS,CAAC;IAEjB,qBAAqB;IACrB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAEpC,uCAAuC;IACvC,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,iDAAiD;IACjD,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,2BAA2B;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,sCAAsC;IACtC,MAAM,EAAE;QACN,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAMD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,eAAe,CAiO1E;AA0CD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,OAAO,CAkBlE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,eAAe,GAAG,OAAO,CAYlE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,eAAe,GAAG,MAAM,CAuBnE"}

package/dist/swarm-strategies.d.ts

@@ -52,9 +52,10 @@ export declare const STRATEGIES: Record<Exclude<DecompositionStrategy, "auto">,
  * Analyze task description and select best decomposition strategy
  *
  * @param task - Task description
- * @returns Selected strategy with reasoning
+ * @param projectKey - Optional project path for precedent-aware selection
+ * @returns Selected strategy with reasoning and optional precedent data
  */
-export declare function selectStrategy(task: string): {
+export declare function selectStrategy(task: string, projectKey?: string): Promise<{
     strategy: Exclude<DecompositionStrategy, "auto">;
     confidence: number;
     reasoning: string;
@@ -62,7 +63,12 @@ export declare function selectStrategy(task: string): {
         strategy: Exclude<DecompositionStrategy, "auto">;
         score: number;
     }>;
-};
+    precedent?: {
+        similar_decisions: number;
+        strategy_success_rate?: number;
+        cited_epics?: string[];
+    };
+}>;
 /**
  * Format strategy-specific guidelines for the decomposition prompt
  */
@@ -72,16 +78,21 @@ export declare function formatStrategyGuidelines(strategy: Exclude<Decomposition
  *
  * Analyzes task description and recommends a strategy with reasoning.
  * Use this before swarm_plan_prompt to understand the recommended approach.
+ *
+ * When projectKey is provided, queries past strategy decisions and success rates
+ * to provide precedent-aware recommendations with adjusted confidence.
  */
 export declare const swarm_select_strategy: {
     description: string;
     args: {
         task: z.ZodString;
         codebase_context: z.ZodOptional<z.ZodString>;
+        projectKey: z.ZodOptional<z.ZodString>;
     };
     execute(args: {
         task: string;
         codebase_context?: string | undefined;
+        projectKey?: string | undefined;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
 export declare const strategyTools: {
@@ -90,10 +101,12 @@ export declare const strategyTools: {
         args: {
             task: z.ZodString;
             codebase_context: z.ZodOptional<z.ZodString>;
+            projectKey: z.ZodOptional<z.ZodString>;
         };
         execute(args: {
             task: string;
             codebase_context?: string | undefined;
+            projectKey?: string | undefined;
         }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
     };
 };

package/dist/swarm-strategies.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swarm-strategies.d.ts","sourceRoot":"","sources":["../src/swarm-strategies.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAC7B,YAAY,GACZ,eAAe,GACf,YAAY,GACZ,gBAAgB,GAChB,MAAM,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,2BAA2B;;;;;;EAMtC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB,UAO5B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,UAQ5B,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,qBAAqB,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,CAC7B,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,EACtC,kBAAkB,CAgKnB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG;IAC5C,QAAQ,EAAE,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,KAAK,CAAC;QAClB,QAAQ,EAAE,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;QACjD,KAAK,EAAE,MAAM,CAAC;KACf,CAAC,CAAC;CACJ,CAoEA;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,GAC/C,MAAM,CAmBR;AAMD;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;CAqChC,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;CAEzB,CAAC"}
+{"version":3,"file":"swarm-strategies.d.ts","sourceRoot":"","sources":["../src/swarm-strategies.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAC7B,YAAY,GACZ,eAAe,GACf,YAAY,GACZ,gBAAgB,GAChB,MAAM,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,2BAA2B;;;;;;EAMtC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB,UAO5B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,UAQ5B,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,qBAAqB,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,CAC7B,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,EACtC,kBAAkB,CAgKnB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC;IACT,QAAQ,EAAE,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,KAAK,CAAC;QAClB,QAAQ,EAAE,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;QACjD,KAAK,EAAE,MAAM,CAAC;KACf,CAAC,CAAC;IACH,SAAS,CAAC,EAAE;QACV,iBAAiB,EAAE,MAAM,CAAC;QAC1B,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;KACxB,CAAC;CACH,CAAC,CAwKD;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,GAC/C,MAAM,CAmBR;AAMD;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;CA0ChC,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;CAEzB,CAAC"}

package/dist/swarm.d.ts

@@ -546,8 +546,8 @@ export declare const swarmTools: {
             user_response: import("zod").ZodOptional<import("zod").ZodString>;
             phase: import("zod").ZodOptional<import("zod").ZodEnum<{
                 ready: "ready";
-                questioning: "questioning";
                 alternatives: "alternatives";
+                questioning: "questioning";
                 recommendation: "recommendation";
             }>>;
         };
@@ -556,7 +556,7 @@ export declare const swarmTools: {
             mode: "auto" | "socratic" | "fast" | "confirm-only";
             context?: string | undefined;
             user_response?: string | undefined;
-            phase?: "ready" | "questioning" | "alternatives" | "recommendation" | undefined;
+            phase?: "ready" | "alternatives" | "questioning" | "recommendation" | undefined;
         }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
     };
     swarm_select_strategy: {
@@ -564,10 +564,12 @@ export declare const swarmTools: {
         args: {
             task: import("zod").ZodString;
             codebase_context: import("zod").ZodOptional<import("zod").ZodString>;
+            projectKey: import("zod").ZodOptional<import("zod").ZodString>;
         };
         execute(args: {
             task: string;
             codebase_context?: string | undefined;
+            projectKey?: string | undefined;
         }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
     };
 };

package/dist/swarm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swarm.d.ts","sourceRoot":"","sources":["../src/swarm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AASjC;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMtB,CAAC"}
+{"version":3,"file":"swarm.d.ts","sourceRoot":"","sources":["../src/swarm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AASjC;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMtB,CAAC"}