opencode-swarm-plugin 0.44.1 → 0.45.0

package/dist/plugin.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";
@@ -39972,6 +40105,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);
         }
@@ -40065,13 +40229,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);
@@ -40090,10 +40253,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");
       }
@@ -42402,6 +42565,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
@@ -42833,7 +43129,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;
     }
@@ -42875,6 +43171,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
@@ -42993,7 +43310,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",
@@ -43012,7 +43329,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",
@@ -43107,7 +43424,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,
@@ -43134,7 +43451,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",
@@ -45205,6 +45522,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;
@@ -45259,6 +45592,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";
@@ -61435,9 +61785,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, ""),
@@ -61465,7 +61815,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 = "";
@@ -61482,7 +61832,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) {
@@ -61691,6 +62041,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");
@@ -61920,7 +62287,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;
     }
@@ -65626,6 +65993,7 @@ var sessionStats = {
 
 // src/index.ts
 init_skills();
+init_swarm_validation();
 var SwarmPlugin = async (input) => {
   const { $, directory, client } = input;
   setHiveWorkingDirectory(directory);

package/dist/query-tools.d.ts

@@ -2,12 +2,11 @@
  * GREEN PHASE: SQL Query Tools Implementation
  *
  * Provides:
- * - 10 preset queries for observability insights
+ * - 13 preset queries for observability insights (10 base + 3 decision trace)
  * - Custom SQL execution with timing
  * - 3 output formats: Table (box-drawing), CSV, JSON
  */
-import type { DatabaseAdapter } from "swarm-mail";
-export type PresetQueryName = "failed_decompositions" | "duration_by_strategy" | "file_conflicts" | "worker_success_rate" | "review_rejections" | "blocked_tasks" | "agent_activity" | "event_frequency" | "error_patterns" | "compaction_stats";
+export type PresetQueryName = "failed_decompositions" | "duration_by_strategy" | "file_conflicts" | "worker_success_rate" | "review_rejections" | "blocked_tasks" | "agent_activity" | "event_frequency" | "error_patterns" | "compaction_stats" | "decision_quality" | "strategy_success_rates" | "decisions_by_pattern";
 export interface QueryResult {
     columns: string[];
     rows: Record<string, unknown>[];
@@ -16,14 +15,23 @@ export interface QueryResult {
 }
 export declare const presetQueries: Record<PresetQueryName, string>;
 /**
- * Execute custom SQL against the events table.
+ * Execute custom SQL query (CLI wrapper).
+ * Creates database adapter automatically.
  *
- * @param db - DatabaseAdapter instance
+ * @param projectPath - Project path (unused, queries global database)
  * @param sql - SQL query string
- * @param params - Optional parameterized query values
- * @returns QueryResult with rows, columns, timing
+ * @returns Raw rows array for CLI formatting
  */
-export declare function executeQuery(db: DatabaseAdapter, sql: string, params?: unknown[]): Promise<QueryResult>;
+export declare function executeQuery(projectPath: string, sql: string): Promise<any[]>;
+/**
+ * Execute a preset query by name (CLI wrapper).
+ * Creates database adapter automatically.
+ *
+ * @param projectPath - Project path (unused, queries global database)
+ * @param presetName - Name of the preset query
+ * @returns Raw rows array for CLI formatting
+ */
+export declare function executePreset(projectPath: string, presetName: string): Promise<any[]>;
 /**
  * Format query result as aligned table with box-drawing characters.
  *
@@ -34,9 +42,9 @@ export declare function executeQuery(db: DatabaseAdapter, sql: string, params?:
  * │ AgentA   │     5 │
  * │ AgentB   │     3 │
  * └──────────┴───────┘
- * 2 rows in 5.2ms
+ * 2 rows
  */
-export declare function formatAsTable(result: QueryResult): string;
+export declare function formatAsTable(rows: Record<string, unknown>[]): string;
 /**
  * Format query result as CSV with proper escaping.
  *
@@ -45,7 +53,7 @@ export declare function formatAsTable(result: QueryResult): string;
  * - Quotes → double them
  * - Newlines → wrap in quotes
  */
-export declare function formatAsCSV(result: QueryResult): string;
+export declare function formatAsCSV(rows: Record<string, unknown>[]): string;
 /**
  * Format query result as pretty-printed JSON array.
  *
@@ -55,5 +63,5 @@ export declare function formatAsCSV(result: QueryResult): string;
  *   { "name": "AgentB", "count": 3 }
  * ]
  */
-export declare function formatAsJSON(result: QueryResult): string;
+export declare function formatAsJSON(rows: Record<string, unknown>[]): string;
 //# sourceMappingURL=query-tools.d.ts.map

package/dist/query-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query-tools.d.ts","sourceRoot":"","sources":["../src/query-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAMlD,MAAM,MAAM,eAAe,GACxB,uBAAuB,GACvB,sBAAsB,GACtB,gBAAgB,GAChB,qBAAqB,GACrB,mBAAmB,GACnB,eAAe,GACf,gBAAgB,GAChB,iBAAiB,GACjB,gBAAgB,GAChB,kBAAkB,CAAC;AAEtB,MAAM,WAAW,WAAW;IAC3B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;CACxB;AAMD,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAoHzD,CAAC;AAMF;;;;;;;GAOG;AACH,wBAAsB,YAAY,CACjC,EAAE,EAAE,eAAe,EACnB,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,OAAO,EAAE,GAChB,OAAO,CAAC,WAAW,CAAC,CAiBtB;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAkEzD;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CA2BvD;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAExD"}
+{"version":3,"file":"query-tools.d.ts","sourceRoot":"","sources":["../src/query-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAWH,MAAM,MAAM,eAAe,GACxB,uBAAuB,GACvB,sBAAsB,GACtB,gBAAgB,GAChB,qBAAqB,GACrB,mBAAmB,GACnB,eAAe,GACf,gBAAgB,GAChB,iBAAiB,GACjB,gBAAgB,GAChB,kBAAkB,GAClB,kBAAkB,GAClB,wBAAwB,GACxB,sBAAsB,CAAC;AAE1B,MAAM,WAAW,WAAW;IAC3B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;CACxB;AAMD,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAgKzD,CAAC;AAgFF;;;;;;;GAOG;AACH,wBAAsB,YAAY,CACjC,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,MAAM,GACT,OAAO,CAAC,GAAG,EAAE,CAAC,CAIhB;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAClC,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,GAChB,OAAO,CAAC,GAAG,EAAE,CAAC,CAIhB;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,MAAM,CAmErE;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,MAAM,CA2BnE;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,MAAM,CAEpE"}