opencode-swarm-plugin 0.36.1 → 0.38.0

package/dist/plugin.js

@@ -22178,6 +22178,357 @@ Codebase context considered: ${args.codebase_context.slice(0, 200)}...`;
   };
 });
 
+// src/eval-capture.ts
+var exports_eval_capture = {};
+__export(exports_eval_capture, {
+  updateEvalRecord: () => updateEvalRecord,
+  saveSession: () => saveSession,
+  readSessionEvents: () => readSessionEvents,
+  readPartialRecords: () => readPartialRecords,
+  readEvalRecords: () => readEvalRecords,
+  getSessionPath: () => getSessionPath,
+  getSessionDir: () => getSessionDir,
+  getEvalDataStats: () => getEvalDataStats,
+  getEvalDataPath: () => getEvalDataPath,
+  finalizeEvalRecord: () => finalizeEvalRecord,
+  exportForEvalite: () => exportForEvalite,
+  ensureSessionDir: () => ensureSessionDir,
+  ensureEvalDataDir: () => ensureEvalDataDir,
+  captureSubtaskOutcome: () => captureSubtaskOutcome,
+  captureHumanFeedback: () => captureHumanFeedback,
+  captureDecomposition: () => captureDecomposition,
+  captureCoordinatorEvent: () => captureCoordinatorEvent,
+  appendEvalRecord: () => appendEvalRecord,
+  SubtaskOutcomeSchema: () => SubtaskOutcomeSchema,
+  EvalRecordSchema: () => EvalRecordSchema,
+  DEFAULT_EVAL_DATA_PATH: () => DEFAULT_EVAL_DATA_PATH,
+  CoordinatorSessionSchema: () => CoordinatorSessionSchema,
+  CoordinatorEventSchema: () => CoordinatorEventSchema
+});
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+function getEvalDataPath(projectPath) {
+  return path.join(projectPath, DEFAULT_EVAL_DATA_PATH);
+}
+function ensureEvalDataDir(projectPath) {
+  const evalPath = getEvalDataPath(projectPath);
+  const dir = path.dirname(evalPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+function appendEvalRecord(projectPath, record2) {
+  ensureEvalDataDir(projectPath);
+  const evalPath = getEvalDataPath(projectPath);
+  const line = `${JSON.stringify(record2)}
+`;
+  fs.appendFileSync(evalPath, line, "utf-8");
+}
+function readEvalRecords(projectPath) {
+  const evalPath = getEvalDataPath(projectPath);
+  if (!fs.existsSync(evalPath)) {
+    return [];
+  }
+  const content = fs.readFileSync(evalPath, "utf-8");
+  const lines = content.trim().split(`
+`).filter(Boolean);
+  return lines.map((line) => {
+    const parsed = JSON.parse(line);
+    return EvalRecordSchema.parse(parsed);
+  });
+}
+function readPartialRecords(projectPath) {
+  const evalPath = getEvalDataPath(projectPath);
+  if (!fs.existsSync(evalPath)) {
+    return [];
+  }
+  const content = fs.readFileSync(evalPath, "utf-8");
+  const lines = content.trim().split(`
+`).filter(Boolean);
+  return lines.map((line) => JSON.parse(line));
+}
+function updateEvalRecord(projectPath, id, updates) {
+  const records = readPartialRecords(projectPath);
+  const index = records.findIndex((r) => r.id === id);
+  if (index === -1) {
+    return false;
+  }
+  records[index] = { ...records[index], ...updates };
+  const evalPath = getEvalDataPath(projectPath);
+  const content = `${records.map((r) => JSON.stringify(r)).join(`
+`)}
+`;
+  fs.writeFileSync(evalPath, content, "utf-8");
+  return true;
+}
+function captureDecomposition(params) {
+  const record2 = {
+    id: params.epicId,
+    timestamp: new Date().toISOString(),
+    project_path: params.projectPath,
+    task: params.task,
+    context: params.context,
+    strategy: params.strategy,
+    subtask_count: params.subtasks.length,
+    epic_title: params.epicTitle,
+    epic_description: params.epicDescription,
+    subtasks: params.subtasks,
+    outcomes: []
+  };
+  inProgressRecords.set(params.epicId, record2);
+  appendEvalRecord(params.projectPath, record2);
+  return record2;
+}
+function captureSubtaskOutcome(params) {
+  const outcome = {
+    bead_id: params.beadId,
+    title: params.title,
+    planned_files: params.plannedFiles,
+    actual_files: params.actualFiles,
+    duration_ms: params.durationMs,
+    error_count: params.errorCount,
+    retry_count: params.retryCount,
+    success: params.success,
+    failure_mode: params.failureMode
+  };
+  const record2 = inProgressRecords.get(params.epicId);
+  if (record2) {
+    record2.outcomes = record2.outcomes || [];
+    record2.outcomes.push(outcome);
+  }
+  updateEvalRecord(params.projectPath, params.epicId, {
+    outcomes: record2?.outcomes
+  });
+}
+function finalizeEvalRecord(params) {
+  const record2 = inProgressRecords.get(params.epicId);
+  if (!record2 || !record2.outcomes || record2.outcomes.length === 0) {
+    return null;
+  }
+  const outcomes = record2.outcomes;
+  const overallSuccess = outcomes.every((o) => o.success);
+  const totalDurationMs = outcomes.reduce((sum, o) => sum + o.duration_ms, 0);
+  const totalErrors = outcomes.reduce((sum, o) => sum + o.error_count, 0);
+  const allPlannedFiles = record2.subtasks?.flatMap((s) => s.files) || [];
+  const fileOccurrences = new Map;
+  for (const file2 of allPlannedFiles) {
+    fileOccurrences.set(file2, (fileOccurrences.get(file2) || 0) + 1);
+  }
+  const fileOverlapCount = Array.from(fileOccurrences.values()).filter((count) => count > 1).length;
+  const plannedFileSet = new Set(allPlannedFiles);
+  const actualFileSet = new Set(outcomes.flatMap((o) => o.actual_files));
+  const scopeAccuracy = plannedFileSet.size > 0 ? actualFileSet.size / plannedFileSet.size : 1;
+  const durations = outcomes.map((o) => o.duration_ms).filter((d) => d > 0);
+  const timeBalanceRatio = durations.length > 1 ? Math.max(...durations) / Math.min(...durations) : 1;
+  const finalRecord = {
+    ...record2,
+    overall_success: overallSuccess,
+    total_duration_ms: totalDurationMs,
+    total_errors: totalErrors,
+    file_overlap_count: fileOverlapCount,
+    scope_accuracy: scopeAccuracy,
+    time_balance_ratio: timeBalanceRatio
+  };
+  updateEvalRecord(params.projectPath, params.epicId, finalRecord);
+  inProgressRecords.delete(params.epicId);
+  return finalRecord;
+}
+function captureHumanFeedback(params) {
+  updateEvalRecord(params.projectPath, params.epicId, {
+    human_accepted: params.accepted,
+    human_modified: params.modified,
+    human_notes: params.notes
+  });
+}
+function exportForEvalite(projectPath) {
+  const records = readEvalRecords(projectPath);
+  return records.filter((r) => r.outcomes && r.outcomes.length > 0).map((record2) => ({
+    input: {
+      task: record2.task,
+      context: record2.context
+    },
+    expected: {
+      minSubtasks: 2,
+      subtaskCount: record2.subtask_count,
+      requiredFiles: record2.subtasks.flatMap((s) => s.files),
+      overallSuccess: record2.overall_success
+    },
+    actual: record2
+  }));
+}
+function getEvalDataStats(projectPath) {
+  const records = readEvalRecords(projectPath);
+  const complete = records.filter((r) => r.outcomes && r.outcomes.length > 0);
+  if (complete.length === 0) {
+    return {
+      totalRecords: records.length,
+      completeRecords: 0,
+      successRate: 0,
+      avgSubtasks: 0,
+      avgDurationMs: 0,
+      avgScopeAccuracy: 0,
+      avgTimeBalance: 0
+    };
+  }
+  const successCount = complete.filter((r) => r.overall_success).length;
+  const avgSubtasks = complete.reduce((sum, r) => sum + (r.outcomes?.length || 0), 0) / complete.length;
+  const avgDurationMs = complete.reduce((sum, r) => sum + (r.total_duration_ms || 0), 0) / complete.length;
+  const avgScopeAccuracy = complete.reduce((sum, r) => sum + (r.scope_accuracy || 1), 0) / complete.length;
+  const avgTimeBalance = complete.reduce((sum, r) => sum + (r.time_balance_ratio || 1), 0) / complete.length;
+  return {
+    totalRecords: records.length,
+    completeRecords: complete.length,
+    successRate: successCount / complete.length,
+    avgSubtasks,
+    avgDurationMs,
+    avgScopeAccuracy,
+    avgTimeBalance
+  };
+}
+function getSessionDir() {
+  return path.join(os.homedir(), ".config", "swarm-tools", "sessions");
+}
+function getSessionPath(sessionId) {
+  return path.join(getSessionDir(), `${sessionId}.jsonl`);
+}
+function ensureSessionDir() {
+  const sessionDir = getSessionDir();
+  if (!fs.existsSync(sessionDir)) {
+    fs.mkdirSync(sessionDir, { recursive: true });
+  }
+}
+function captureCoordinatorEvent(event) {
+  CoordinatorEventSchema.parse(event);
+  ensureSessionDir();
+  const sessionPath = getSessionPath(event.session_id);
+  const line = `${JSON.stringify(event)}
+`;
+  fs.appendFileSync(sessionPath, line, "utf-8");
+}
+function readSessionEvents(sessionId) {
+  const sessionPath = getSessionPath(sessionId);
+  if (!fs.existsSync(sessionPath)) {
+    return [];
+  }
+  const content = fs.readFileSync(sessionPath, "utf-8");
+  const lines = content.trim().split(`
+`).filter(Boolean);
+  return lines.map((line) => {
+    const parsed = JSON.parse(line);
+    return CoordinatorEventSchema.parse(parsed);
+  });
+}
+function saveSession(params) {
+  const events = readSessionEvents(params.session_id);
+  if (events.length === 0) {
+    return null;
+  }
+  const timestamps = events.map((e) => new Date(e.timestamp).getTime());
+  const startTime = new Date(Math.min(...timestamps)).toISOString();
+  const endTime = new Date(Math.max(...timestamps)).toISOString();
+  const session = {
+    session_id: params.session_id,
+    epic_id: params.epic_id,
+    start_time: startTime,
+    end_time: endTime,
+    events
+  };
+  return session;
+}
+var SubtaskOutcomeSchema, EvalRecordSchema, CoordinatorEventSchema, CoordinatorSessionSchema, DEFAULT_EVAL_DATA_PATH = ".opencode/eval-data.jsonl", inProgressRecords;
+var init_eval_capture = __esm(() => {
+  init_zod();
+  SubtaskOutcomeSchema = exports_external.object({
+    bead_id: exports_external.string(),
+    title: exports_external.string(),
+    planned_files: exports_external.array(exports_external.string()),
+    actual_files: exports_external.array(exports_external.string()),
+    duration_ms: exports_external.number().int().min(0),
+    error_count: exports_external.number().int().min(0),
+    retry_count: exports_external.number().int().min(0),
+    success: exports_external.boolean(),
+    failure_mode: exports_external.string().optional()
+  });
+  EvalRecordSchema = exports_external.object({
+    id: exports_external.string(),
+    timestamp: exports_external.string(),
+    project_path: exports_external.string(),
+    task: exports_external.string(),
+    context: exports_external.string().optional(),
+    strategy: exports_external.enum(["file-based", "feature-based", "risk-based", "auto"]),
+    subtask_count: exports_external.number().int().min(1),
+    epic_title: exports_external.string(),
+    epic_description: exports_external.string().optional(),
+    subtasks: exports_external.array(exports_external.object({
+      title: exports_external.string(),
+      description: exports_external.string().optional(),
+      files: exports_external.array(exports_external.string()),
+      dependencies: exports_external.array(exports_external.number()).optional(),
+      estimated_complexity: exports_external.number().int().min(1).max(5).optional()
+    })),
+    outcomes: exports_external.array(SubtaskOutcomeSchema).optional(),
+    overall_success: exports_external.boolean().optional(),
+    total_duration_ms: exports_external.number().int().min(0).optional(),
+    total_errors: exports_external.number().int().min(0).optional(),
+    human_accepted: exports_external.boolean().optional(),
+    human_modified: exports_external.boolean().optional(),
+    human_notes: exports_external.string().optional(),
+    file_overlap_count: exports_external.number().int().min(0).optional(),
+    scope_accuracy: exports_external.number().min(0).max(2).optional(),
+    time_balance_ratio: exports_external.number().min(1).optional()
+  });
+  CoordinatorEventSchema = exports_external.discriminatedUnion("event_type", [
+    exports_external.object({
+      session_id: exports_external.string(),
+      epic_id: exports_external.string(),
+      timestamp: exports_external.string(),
+      event_type: exports_external.literal("DECISION"),
+      decision_type: exports_external.enum([
+        "strategy_selected",
+        "worker_spawned",
+        "review_completed",
+        "decomposition_complete"
+      ]),
+      payload: exports_external.any()
+    }),
+    exports_external.object({
+      session_id: exports_external.string(),
+      epic_id: exports_external.string(),
+      timestamp: exports_external.string(),
+      event_type: exports_external.literal("VIOLATION"),
+      violation_type: exports_external.enum([
+        "coordinator_edited_file",
+        "coordinator_ran_tests",
+        "coordinator_reserved_files",
+        "no_worker_spawned"
+      ]),
+      payload: exports_external.any()
+    }),
+    exports_external.object({
+      session_id: exports_external.string(),
+      epic_id: exports_external.string(),
+      timestamp: exports_external.string(),
+      event_type: exports_external.literal("OUTCOME"),
+      outcome_type: exports_external.enum([
+        "subtask_success",
+        "subtask_retry",
+        "subtask_failed",
+        "epic_complete"
+      ]),
+      payload: exports_external.any()
+    })
+  ]);
+  CoordinatorSessionSchema = exports_external.object({
+    session_id: exports_external.string(),
+    epic_id: exports_external.string(),
+    start_time: exports_external.string(),
+    end_time: exports_external.string().optional(),
+    events: exports_external.array(CoordinatorEventSchema)
+  });
+  inProgressRecords = new Map;
+});
+
 // src/learning.ts
 var exports_learning = {};
 __export(exports_learning, {
@@ -39165,6 +39516,71 @@ var hive_ready = tool({
     }
   }
 });
+var hive_cells = tool({
+  description: `Query cells from the hive database with flexible filtering.
+
+USE THIS TOOL TO:
+- List all open cells: hive_cells()
+- Find cells by status: hive_cells({ status: "in_progress" })
+- Find cells by type: hive_cells({ type: "bug" })
+- Get a specific cell by partial ID: hive_cells({ id: "mjkmd" })
+- Get the next ready (unblocked) cell: hive_cells({ ready: true })
+- Combine filters: hive_cells({ status: "open", type: "task" })
+
+RETURNS: Array of cells with id, title, status, priority, type, parent_id, created_at, updated_at
+
+PREFER THIS OVER hive_query when you need to:
+- See what work is available
+- Check status of multiple cells
+- Find cells matching criteria
+- Look up a cell by partial ID`,
+  args: {
+    id: tool.schema.string().optional().describe("Partial or full cell ID to look up"),
+    status: tool.schema.enum(["open", "in_progress", "blocked", "closed"]).optional().describe("Filter by status"),
+    type: tool.schema.enum(["task", "bug", "feature", "epic", "chore"]).optional().describe("Filter by type"),
+    ready: tool.schema.boolean().optional().describe("If true, return only the next unblocked cell"),
+    limit: tool.schema.number().optional().describe("Max cells to return (default 20)")
+  },
+  async execute(args, ctx) {
+    const projectKey = getHiveWorkingDirectory();
+    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) {
+          throw new HiveError(`No cell found matching ID '${args.id}'`, "hive_cells");
+        }
+        const formatted2 = formatCellForOutput(cell);
+        return JSON.stringify([formatted2], null, 2);
+      }
+      if (args.ready) {
+        const ready = await adapter.getNextReadyCell(projectKey);
+        if (!ready) {
+          return JSON.stringify([], null, 2);
+        }
+        const formatted2 = formatCellForOutput(ready);
+        return JSON.stringify([formatted2], null, 2);
+      }
+      const cells = await adapter.queryCells(projectKey, {
+        status: args.status,
+        type: args.type,
+        limit: args.limit || 20
+      });
+      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 (message.includes("Bead not found") || message.includes("Cell not found")) {
+        throw new HiveError(`No cell found matching ID '${args.id || "unknown"}'`, "hive_cells");
+      }
+      throw new HiveError(`Failed to query cells: ${message}`, "hive_cells");
+    }
+  }
+});
 var hive_sync = tool({
   description: "Sync hive to git and push (MANDATORY at session end)",
   args: {
@@ -39306,6 +39722,7 @@ var hiveTools = {
   hive_close,
   hive_start,
   hive_ready,
+  hive_cells,
   hive_sync,
   hive_link_thread
 };
@@ -41464,122 +41881,7 @@ init_swarm_strategies();
 init_dist();
 init_zod();
 init_swarm_strategies();
-
-// src/eval-capture.ts
-init_zod();
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-var SubtaskOutcomeSchema = exports_external.object({
-  bead_id: exports_external.string(),
-  title: exports_external.string(),
-  planned_files: exports_external.array(exports_external.string()),
-  actual_files: exports_external.array(exports_external.string()),
-  duration_ms: exports_external.number().int().min(0),
-  error_count: exports_external.number().int().min(0),
-  retry_count: exports_external.number().int().min(0),
-  success: exports_external.boolean(),
-  failure_mode: exports_external.string().optional()
-});
-var EvalRecordSchema = exports_external.object({
-  id: exports_external.string(),
-  timestamp: exports_external.string(),
-  project_path: exports_external.string(),
-  task: exports_external.string(),
-  context: exports_external.string().optional(),
-  strategy: exports_external.enum(["file-based", "feature-based", "risk-based", "auto"]),
-  subtask_count: exports_external.number().int().min(1),
-  epic_title: exports_external.string(),
-  epic_description: exports_external.string().optional(),
-  subtasks: exports_external.array(exports_external.object({
-    title: exports_external.string(),
-    description: exports_external.string().optional(),
-    files: exports_external.array(exports_external.string()),
-    dependencies: exports_external.array(exports_external.number()).optional(),
-    estimated_complexity: exports_external.number().int().min(1).max(5).optional()
-  })),
-  outcomes: exports_external.array(SubtaskOutcomeSchema).optional(),
-  overall_success: exports_external.boolean().optional(),
-  total_duration_ms: exports_external.number().int().min(0).optional(),
-  total_errors: exports_external.number().int().min(0).optional(),
-  human_accepted: exports_external.boolean().optional(),
-  human_modified: exports_external.boolean().optional(),
-  human_notes: exports_external.string().optional(),
-  file_overlap_count: exports_external.number().int().min(0).optional(),
-  scope_accuracy: exports_external.number().min(0).max(2).optional(),
-  time_balance_ratio: exports_external.number().min(1).optional()
-});
-var CoordinatorEventSchema = exports_external.discriminatedUnion("event_type", [
-  exports_external.object({
-    session_id: exports_external.string(),
-    epic_id: exports_external.string(),
-    timestamp: exports_external.string(),
-    event_type: exports_external.literal("DECISION"),
-    decision_type: exports_external.enum([
-      "strategy_selected",
-      "worker_spawned",
-      "review_completed",
-      "decomposition_complete"
-    ]),
-    payload: exports_external.any()
-  }),
-  exports_external.object({
-    session_id: exports_external.string(),
-    epic_id: exports_external.string(),
-    timestamp: exports_external.string(),
-    event_type: exports_external.literal("VIOLATION"),
-    violation_type: exports_external.enum([
-      "coordinator_edited_file",
-      "coordinator_ran_tests",
-      "coordinator_reserved_files",
-      "no_worker_spawned"
-    ]),
-    payload: exports_external.any()
-  }),
-  exports_external.object({
-    session_id: exports_external.string(),
-    epic_id: exports_external.string(),
-    timestamp: exports_external.string(),
-    event_type: exports_external.literal("OUTCOME"),
-    outcome_type: exports_external.enum([
-      "subtask_success",
-      "subtask_retry",
-      "subtask_failed",
-      "epic_complete"
-    ]),
-    payload: exports_external.any()
-  })
-]);
-var CoordinatorSessionSchema = exports_external.object({
-  session_id: exports_external.string(),
-  epic_id: exports_external.string(),
-  start_time: exports_external.string(),
-  end_time: exports_external.string().optional(),
-  events: exports_external.array(CoordinatorEventSchema)
-});
-var inProgressRecords = new Map;
-function getSessionDir() {
-  return path.join(os.homedir(), ".config", "swarm-tools", "sessions");
-}
-function getSessionPath(sessionId) {
-  return path.join(getSessionDir(), `${sessionId}.jsonl`);
-}
-function ensureSessionDir() {
-  const sessionDir = getSessionDir();
-  if (!fs.existsSync(sessionDir)) {
-    fs.mkdirSync(sessionDir, { recursive: true });
-  }
-}
-function captureCoordinatorEvent(event) {
-  CoordinatorEventSchema.parse(event);
-  ensureSessionDir();
-  const sessionPath = getSessionPath(event.session_id);
-  const line = `${JSON.stringify(event)}
-`;
-  fs.appendFileSync(sessionPath, line, "utf-8");
-}
-
-// src/swarm-decompose.ts
+init_eval_capture();
 var DECOMPOSITION_PROMPT = `You are decomposing a task into parallelizable subtasks for a swarm of agents.
 
 ## Task
@@ -41897,9 +42199,14 @@ ${fullContext}` : `## Additional Context
   }
 });
 var swarm_validate_decomposition = tool({
-  description: "Validate a decomposition response against CellTreeSchema",
+  description: "Validate a decomposition response against CellTreeSchema and capture for eval",
   args: {
-    response: tool.schema.string().describe("JSON response from agent (CellTree format)")
+    response: tool.schema.string().describe("JSON response from agent (CellTree format)"),
+    project_path: tool.schema.string().optional().describe("Project path for eval capture"),
+    task: tool.schema.string().optional().describe("Original task description for eval capture"),
+    context: tool.schema.string().optional().describe("Context provided for decomposition"),
+    strategy: tool.schema.enum(["file-based", "feature-based", "risk-based", "auto"]).optional().describe("Decomposition strategy used"),
+    epic_id: tool.schema.string().optional().describe("Epic ID for eval capture")
   },
   async execute(args) {
     try {
@@ -41933,6 +42240,29 @@ var swarm_validate_decomposition = tool({
         }
       }
       const instructionConflicts = detectInstructionConflicts(validated.subtasks);
+      if (args.project_path && args.task && args.strategy && args.epic_id) {
+        try {
+          const { captureDecomposition: captureDecomposition2 } = await Promise.resolve().then(() => (init_eval_capture(), exports_eval_capture));
+          captureDecomposition2({
+            epicId: args.epic_id,
+            projectPath: args.project_path,
+            task: args.task,
+            context: args.context,
+            strategy: args.strategy,
+            epicTitle: validated.epic.title,
+            epicDescription: validated.epic.description,
+            subtasks: validated.subtasks.map((s) => ({
+              title: s.title,
+              description: s.description,
+              files: s.files,
+              dependencies: s.dependencies,
+              estimated_complexity: s.estimated_complexity
+            }))
+          });
+        } catch (error45) {
+          console.warn("[swarm_validate_decomposition] Failed to capture decomposition:", error45);
+        }
+      }
       return JSON.stringify({
         valid: true,
         cell_tree: validated,
@@ -44080,6 +44410,7 @@ var worktreeTools = {
 init_dist();
 init_zod();
 import { sendSwarmMessage as sendSwarmMessage2 } from "swarm-mail";
+init_eval_capture();
 var ReviewIssueSchema = exports_external.object({
   file: exports_external.string(),
   line: exports_external.number().optional(),
@@ -44436,6 +44767,7 @@ var reviewTools = {
 };
 
 // src/swarm-orchestrate.ts
+init_eval_capture();
 function generateWorkerHandoff(params) {
   const handoff = {
     contract: {
@@ -46024,6 +46356,7 @@ var orchestrateTools = {
 };
 
 // src/swarm-prompts.ts
+init_eval_capture();
 var STRATEGY_DECOMPOSITION_PROMPT2 = `You are decomposing a task into parallelizable subtasks for a swarm of agents.
 
 ## Task
@@ -62712,6 +63045,7 @@ function guardrailOutput(toolName, output, config2 = DEFAULT_GUARDRAIL_CONFIG) {
 }
 
 // src/planning-guardrails.ts
+init_eval_capture();
 var FILE_MODIFICATION_PATTERNS = [
   /\bimplement\b/i,
   /\bcreate\b.*\.(ts|js|tsx|jsx|py|rs|go|java|rb|swift|kt)/i,

package/dist/swarm-decompose.d.ts

@@ -78,9 +78,24 @@ export declare const swarm_validate_decomposition: {
     description: string;
     args: {
         response: z.ZodString;
+        project_path: z.ZodOptional<z.ZodString>;
+        task: z.ZodOptional<z.ZodString>;
+        context: z.ZodOptional<z.ZodString>;
+        strategy: z.ZodOptional<z.ZodEnum<{
+            "file-based": "file-based";
+            "feature-based": "feature-based";
+            "risk-based": "risk-based";
+            auto: "auto";
+        }>>;
+        epic_id: z.ZodOptional<z.ZodString>;
     };
     execute(args: {
         response: string;
+        project_path?: string | undefined;
+        task?: string | undefined;
+        context?: string | undefined;
+        strategy?: "file-based" | "feature-based" | "risk-based" | "auto" | undefined;
+        epic_id?: string | undefined;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };
 /**
@@ -211,9 +226,24 @@ export declare const decomposeTools: {
         description: string;
         args: {
             response: z.ZodString;
+            project_path: z.ZodOptional<z.ZodString>;
+            task: z.ZodOptional<z.ZodString>;
+            context: z.ZodOptional<z.ZodString>;
+            strategy: z.ZodOptional<z.ZodEnum<{
+                "file-based": "file-based";
+                "feature-based": "feature-based";
+                "risk-based": "risk-based";
+                auto: "auto";
+            }>>;
+            epic_id: z.ZodOptional<z.ZodString>;
         };
         execute(args: {
             response: string;
+            project_path?: string | undefined;
+            task?: string | undefined;
+            context?: string | undefined;
+            strategy?: "file-based" | "feature-based" | "risk-based" | "auto" | undefined;
+            epic_id?: string | undefined;
         }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
     };
     swarm_delegate_planning: {

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

@@ -1 +1 @@
-{"version":3,"file":"swarm-decompose.d.ts","sourceRoot":"","sources":["../src/swarm-decompose.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAyJxB;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,mBAAmB,GAAG,eAAe,CAAC;IACrD,WAAW,EAAE,MAAM,CAAC;CACrB;AA8CD;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GACvD,mBAAmB,EAAE,CAmDvB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,GACnC,MAAM,EAAE,CAgBV;AA+GD;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;CAiG1B,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;CAkHvC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;CAuMlC,CAAC;AAMH,qBAAa,UAAW,SAAQ,KAAK;aAGjB,SAAS,EAAE,MAAM;aACjB,OAAO,CAAC,EAAE,OAAO;gBAFjC,OAAO,EAAE,MAAM,EACC,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,OAAO,YAAA;CAKpC;AAED,qBAAa,kBAAmB,SAAQ,UAAU;aAG9B,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ;gBADrC,OAAO,EAAE,MAAM,EACC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,YAAA;CAIxC;AAkCD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;CA0RjC,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK1B,CAAC"}
+{"version":3,"file":"swarm-decompose.d.ts","sourceRoot":"","sources":["../src/swarm-decompose.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAyJxB;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,mBAAmB,GAAG,eAAe,CAAC;IACrD,WAAW,EAAE,MAAM,CAAC;CACrB;AA8CD;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GACvD,mBAAmB,EAAE,CAmDvB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,GACnC,MAAM,EAAE,CAgBV;AA+GD;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;CAiG1B,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;CAqKvC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;CAuMlC,CAAC;AAMH,qBAAa,UAAW,SAAQ,KAAK;aAGjB,SAAS,EAAE,MAAM;aACjB,OAAO,CAAC,EAAE,OAAO;gBAFjC,OAAO,EAAE,MAAM,EACC,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,OAAO,YAAA;CAKpC;AAED,qBAAa,kBAAmB,SAAQ,UAAU;aAG9B,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ;gBADrC,OAAO,EAAE,MAAM,EACC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,YAAA;CAIxC;AAkCD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;CA0RjC,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK1B,CAAC"}