opencode-swarm-plugin 0.58.4 → 0.59.0

package/claude-plugin/dist/index.js

@@ -12815,6 +12815,7 @@ __export(exports_dist, {
   formatCSV: () => formatCSV,
   findSimilarDecisions: () => findSimilarDecisions,
   findRelatedMemories: () => findRelatedMemories,
+  findDecisionTraceByBead: () => findDecisionTraceByBead,
   findCellsByPartialId: () => findCellsByPartialId,
   failedDecompositions: () => failedDecompositions,
   extractEntitiesAndRelationships: () => extractEntitiesAndRelationships,
@@ -29347,6 +29348,10 @@ async function getDecisionTracesByEpic(db2, epicId) {
   const result = await db2.query(`SELECT * FROM decision_traces WHERE epic_id = ? ORDER BY timestamp ASC`, [epicId]);
   return result.rows;
 }
+async function findDecisionTraceByBead(db2, beadId) {
+  const result = await db2.query(`SELECT * FROM decision_traces WHERE bead_id = ? ORDER BY timestamp DESC LIMIT 1`, [beadId]);
+  return result.rows[0] ?? null;
+}
 async function getDecisionTracesByAgent(db2, agentName) {
   const result = await db2.query(`SELECT * FROM decision_traces WHERE agent_name = ? ORDER BY timestamp ASC`, [agentName]);
   return result.rows;
@@ -120790,6 +120795,7 @@ ${stack.split(`
     getAgent: () => getAgent2,
     getActiveReservations: () => getActiveReservations2,
     findSimilarDecisions: () => findSimilarDecisions,
+    findDecisionTraceByBead: () => findDecisionTraceByBead,
     emitThreadActivity: () => emitThreadActivity,
     createEvent: () => createEvent,
     createEntityLink: () => createEntityLink,
@@ -139479,6 +139485,235 @@ Codebase context considered: ${args2.codebase_context.slice(0, 200)}...`;
   };
 });
 
+// src/decision-trace-integration.ts
+var exports_decision_trace_integration = {};
+__export(exports_decision_trace_integration, {
+  traceWorkerSpawn: () => traceWorkerSpawn,
+  traceStrategySelection: () => traceStrategySelection,
+  traceScopeChange: () => traceScopeChange,
+  traceReviewDecision: () => traceReviewDecision,
+  traceFileSelection: () => traceFileSelection,
+  linkOutcomeToDecisionTrace: () => linkOutcomeToDecisionTrace,
+  getEpicDecisionTraces: () => getEpicDecisionTraces,
+  getDecisionTracesByType: () => getDecisionTracesByType2,
+  extractMemoryIds: () => extractMemoryIds
+});
+async function getTraceDb(projectPath) {
+  const dbPath = getDatabasePath2(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 trace3 = 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: trace3.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 trace3.id;
+  } catch (error47) {
+    console.warn("[decision-trace] Failed to trace strategy_selection:", error47);
+    return "";
+  }
+}
+async function traceWorkerSpawn(input) {
+  try {
+    const db = await getTraceDb(input.projectKey);
+    const trace3 = 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 file3 of input.files) {
+      await createEntityLink(db, {
+        source_decision_id: trace3.id,
+        target_entity_type: "file",
+        target_entity_id: file3,
+        link_type: "assigns_file",
+        strength: 1,
+        context: `File assigned to worker ${input.workerName || "worker"}`
+      });
+    }
+    await db.close?.();
+    return trace3.id;
+  } catch (error47) {
+    console.warn("[decision-trace] Failed to trace worker_spawn:", error47);
+    return "";
+  }
+}
+async function traceReviewDecision(input) {
+  try {
+    const db = await getTraceDb(input.projectKey);
+    const trace3 = 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: trace3.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 trace3.id;
+  } catch (error47) {
+    console.warn("[decision-trace] Failed to trace review_decision:", error47);
+    return "";
+  }
+}
+async function traceFileSelection(input) {
+  try {
+    const db = await getTraceDb(input.projectKey);
+    const trace3 = await createDecisionTrace(db, {
+      decision_type: "file_selection",
+      epic_id: input.epicId,
+      bead_id: input.beadId,
+      agent_name: input.agentName,
+      project_key: input.projectKey,
+      decision: {
+        files_selected: input.filesSelected,
+        files_owned: input.filesOwned,
+        scope_expanded: input.scopeExpanded
+      },
+      rationale: input.rationale || `Selected ${input.filesSelected.length} files`
+    });
+    await db.close?.();
+    return trace3.id;
+  } catch (error47) {
+    console.warn("[decision-trace] Failed to trace file_selection:", error47);
+    return "";
+  }
+}
+async function traceScopeChange(input) {
+  try {
+    const db = await getTraceDb(input.projectKey);
+    const trace3 = await createDecisionTrace(db, {
+      decision_type: "scope_change",
+      epic_id: input.epicId,
+      bead_id: input.beadId,
+      agent_name: input.agentName,
+      project_key: input.projectKey,
+      decision: {
+        files_added: input.filesAdded || [],
+        files_removed: input.filesRemoved || [],
+        coordinator_approved: input.coordinatorApproved
+      },
+      rationale: input.reason
+    });
+    await db.close?.();
+    return trace3.id;
+  } catch (error47) {
+    console.warn("[decision-trace] Failed to trace scope_change:", error47);
+    return "";
+  }
+}
+async function getEpicDecisionTraces(projectKey, epicId) {
+  try {
+    const { getDecisionTracesByEpic: getDecisionTracesByEpic2 } = await Promise.resolve().then(() => (init_dist2(), exports_dist));
+    const db = await getTraceDb(projectKey);
+    const traces = await getDecisionTracesByEpic2(db, epicId);
+    await db.close?.();
+    return traces;
+  } catch (error47) {
+    console.warn("[decision-trace] Failed to query epic traces:", error47);
+    return [];
+  }
+}
+async function getDecisionTracesByType2(projectKey, decisionType) {
+  try {
+    const { getDecisionTracesByType: queryByType } = await Promise.resolve().then(() => (init_dist2(), exports_dist));
+    const db = await getTraceDb(projectKey);
+    const traces = await queryByType(db, decisionType);
+    await db.close?.();
+    return traces;
+  } catch (error47) {
+    console.warn("[decision-trace] Failed to query traces by type:", error47);
+    return [];
+  }
+}
+async function linkOutcomeToDecisionTrace(input) {
+  try {
+    const { findDecisionTraceByBead: findDecisionTraceByBead2, linkOutcomeToTrace: linkOutcomeToTrace2 } = await Promise.resolve().then(() => (init_dist2(), exports_dist));
+    const db = await getTraceDb(input.projectKey);
+    const trace3 = await findDecisionTraceByBead2(db, input.beadId);
+    if (!trace3) {
+      await db.close?.();
+      return false;
+    }
+    await linkOutcomeToTrace2(db, trace3.id, input.outcomeEventId);
+    await db.close?.();
+    return true;
+  } catch (error47) {
+    console.warn("[decision-trace] Failed to link outcome to trace:", error47);
+    return false;
+  }
+}
+var init_decision_trace_integration = __esm(() => {
+  init_dist2();
+  init_dist2();
+  init_dist2();
+});
+
 // src/learning.ts
 var exports_learning = {};
 __export(exports_learning, {
@@ -179082,136 +179317,7 @@ init_dist();
 init_zod();
 init_swarm_strategies();
 init_eval_capture();
-
-// src/decision-trace-integration.ts
-init_dist2();
-init_dist2();
-init_dist2();
-async function getTraceDb(projectPath) {
-  const dbPath = getDatabasePath2(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 trace3 = 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: trace3.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 trace3.id;
-  } catch (error47) {
-    console.warn("[decision-trace] Failed to trace strategy_selection:", error47);
-    return "";
-  }
-}
-async function traceWorkerSpawn(input) {
-  try {
-    const db = await getTraceDb(input.projectKey);
-    const trace3 = 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 file3 of input.files) {
-      await createEntityLink(db, {
-        source_decision_id: trace3.id,
-        target_entity_type: "file",
-        target_entity_id: file3,
-        link_type: "assigns_file",
-        strength: 1,
-        context: `File assigned to worker ${input.workerName || "worker"}`
-      });
-    }
-    await db.close?.();
-    return trace3.id;
-  } catch (error47) {
-    console.warn("[decision-trace] Failed to trace worker_spawn:", error47);
-    return "";
-  }
-}
-async function traceReviewDecision(input) {
-  try {
-    const db = await getTraceDb(input.projectKey);
-    const trace3 = 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: trace3.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 trace3.id;
-  } catch (error47) {
-    console.warn("[decision-trace] Failed to trace review_decision:", error47);
-    return "";
-  }
-}
-
-// src/swarm-decompose.ts
+init_decision_trace_integration();
 var DECOMPOSITION_PROMPT = `You are decomposing a task into parallelizable subtasks for a swarm of agents.
 
 ## Task
@@ -181813,6 +181919,7 @@ init_dist();
 init_zod();
 init_dist2();
 init_eval_capture();
+init_decision_trace_integration();
 var ReviewIssueSchema = exports_external.object({
   file: exports_external.string(),
   line: exports_external.number().optional(),
@@ -183073,6 +183180,7 @@ This will be recorded as a negative learning signal.`;
       }
       const completionDurationMs = Date.now() - args2.start_time;
       const eventEpicId = cell.parent_id || (args2.bead_id.includes(".") ? args2.bead_id.split(".")[0] : args2.bead_id);
+      let outcomeEventId;
       try {
         const event = createEvent("subtask_outcome", {
           project_key: args2.project_key,
@@ -183087,10 +183195,23 @@ This will be recorded as a negative learning signal.`;
           scope_violation: contractValidation ? !contractValidation.valid : undefined,
           violation_files: contractValidation?.violations
         });
-        await appendEvent(event, args2.project_key);
+        const savedEvent = await appendEvent(event, args2.project_key);
+        outcomeEventId = savedEvent.id;
       } catch (error47) {
         console.warn("[swarm_complete] Failed to emit SubtaskOutcomeEvent:", error47);
       }
+      if (outcomeEventId) {
+        try {
+          const { linkOutcomeToDecisionTrace: linkOutcomeToDecisionTrace2 } = await Promise.resolve().then(() => (init_decision_trace_integration(), exports_decision_trace_integration));
+          await linkOutcomeToDecisionTrace2({
+            projectKey: args2.project_key,
+            beadId: args2.bead_id,
+            outcomeEventId
+          });
+        } catch (error47) {
+          console.warn("[swarm_complete] Failed to link outcome to decision trace:", error47);
+        }
+      }
       try {
         const workerCompletedEvent = createEvent("worker_completed", {
           project_key: args2.project_key,
@@ -184068,6 +184189,7 @@ var orchestrateTools = {
 // src/swarm-prompts.ts
 init_eval_capture();
 init_memory_tools();
+init_decision_trace_integration();
 var STRATEGY_DECOMPOSITION_PROMPT2 = `You are decomposing a task into parallelizable subtasks for a swarm of agents.
 
 ## Task