opencode-swarm 7.83.0 → 7.84.0

package/dist/cli/evidence-summary-service-g2znnd33.js

@@ -0,0 +1,320 @@
+// @bun
+import {
+  getDurableGateEvidenceStatus,
+  listEvidenceTaskIds,
+  loadEvidence,
+  loadPlanJsonOnly,
+  mergeDurableGateEntriesFromEvidence,
+  readDurableGateEvidence
+} from "./index-red8fm8p.js";
+import"./index-e7h9bb6v.js";
+import"./index-fjwwrwr5.js";
+import"./index-ckntc5gf.js";
+import"./index-jtqkh8jf.js";
+import"./index-zfsbaaqh.js";
+import"./index-p0arc26j.js";
+import {
+  log
+} from "./index-yx44zd0p.js";
+import"./index-bcp79s17.js";
+import"./index-293f68mj.js";
+import"./index-b9v501fr.js";
+import"./index-p0ye10nd.js";
+import"./index-a76rekgs.js";
+
+// src/services/evidence-summary-service.ts
+var VALID_EVIDENCE_TYPES = new Set([
+  "review",
+  "test",
+  "diff",
+  "approval",
+  "note",
+  "retrospective"
+]);
+function normalizeBundleEntries(bundle) {
+  if (!bundle) {
+    return [];
+  }
+  const entries = bundle.entries;
+  if (!Array.isArray(entries)) {
+    return [];
+  }
+  const validEntries = [];
+  for (const entry of entries) {
+    if (entry === null || entry === undefined) {
+      continue;
+    }
+    if (typeof entry !== "object") {
+      continue;
+    }
+    const typedEntry = entry;
+    if (!typedEntry.type || !VALID_EVIDENCE_TYPES.has(typedEntry.type)) {
+      continue;
+    }
+    if (!typedEntry.task_id || !typedEntry.timestamp || !typedEntry.agent) {
+      continue;
+    }
+    if (!typedEntry.verdict || !typedEntry.summary) {
+      continue;
+    }
+    validEntries.push(typedEntry);
+  }
+  return validEntries;
+}
+var REQUIRED_EVIDENCE_TYPES = ["review", "test"];
+var EVIDENCE_SUMMARY_VERSION = "1.0.0";
+function getTaskStatus(task, bundle) {
+  if (task?.status) {
+    return task.status;
+  }
+  const entries = _internals.normalizeBundleEntries(bundle);
+  if (entries.length > 0) {
+    return "completed";
+  }
+  return "pending";
+}
+function evidenceCompleteFromEntries(entries) {
+  if (entries.length === 0) {
+    return {
+      isComplete: false,
+      missingEvidence: [...REQUIRED_EVIDENCE_TYPES]
+    };
+  }
+  const typesPresent = new Set(entries.map((e) => e.type));
+  const missing = [];
+  for (const required of REQUIRED_EVIDENCE_TYPES) {
+    if (!typesPresent.has(required)) {
+      missing.push(required);
+    }
+  }
+  return {
+    isComplete: missing.length === 0,
+    missingEvidence: missing
+  };
+}
+function isEvidenceComplete(bundle) {
+  return evidenceCompleteFromEntries(_internals.normalizeBundleEntries(bundle));
+}
+function getTaskBlockers(task, summary, status) {
+  const blockers = [];
+  if (task?.blocked_reason) {
+    blockers.push(task.blocked_reason);
+  }
+  if (status === "blocked") {
+    blockers.push("Task is marked as blocked");
+  }
+  if (summary.missingEvidence.length > 0 && status !== "pending") {
+    blockers.push(`Missing evidence: ${summary.missingEvidence.join(", ")}`);
+  }
+  return blockers;
+}
+async function buildTaskSummary(directory, task, taskId) {
+  const result = await loadEvidence(directory, taskId);
+  const bundle = result.status === "found" ? result.bundle : null;
+  const gateEvidence = await readDurableGateEvidence(directory, taskId);
+  const phase = task?.phase ?? 0;
+  const status = _internals.getTaskStatus(task, bundle);
+  const entries = mergeDurableGateEntriesFromEvidence(taskId, _internals.normalizeBundleEntries(bundle), gateEvidence);
+  let evidenceCheck = _internals.evidenceCompleteFromEntries(entries);
+  if (gateEvidence) {
+    const gateStatus = getDurableGateEvidenceStatus(gateEvidence);
+    evidenceCheck = gateStatus.isComplete ? { isComplete: true, missingEvidence: [] } : {
+      isComplete: false,
+      missingEvidence: gateStatus.missingGates.map((gate) => `gate:${gate}`)
+    };
+  }
+  const blockers = _internals.getTaskBlockers(task, evidenceCheck, status);
+  const hasReview = entries.some((e) => e.type === "review");
+  const hasTest = entries.some((e) => e.type === "test");
+  const hasApproval = entries.some((e) => e.type === "approval");
+  let lastTimestamp = null;
+  if (entries.length > 0) {
+    const timestamps = entries.map((e) => e.timestamp).sort().reverse();
+    lastTimestamp = timestamps[0] ?? null;
+  }
+  return {
+    taskId,
+    phase,
+    taskStatus: status,
+    evidenceCount: entries.length,
+    hasReview,
+    hasTest,
+    hasApproval,
+    missingEvidence: evidenceCheck.missingEvidence,
+    isComplete: evidenceCheck.isComplete && status === "completed",
+    blockers,
+    lastEvidenceTimestamp: lastTimestamp
+  };
+}
+async function buildPhaseSummary(directory, phase) {
+  const taskIds = await listEvidenceTaskIds(directory);
+  const phaseTaskIds = new Set(phase.tasks.map((t) => t.id));
+  const taskSummaries = [];
+  const _taskMap = new Map(phase.tasks.map((t) => [t.id, t]));
+  for (const task of phase.tasks) {
+    const summary = await _internals.buildTaskSummary(directory, task, task.id);
+    taskSummaries.push(summary);
+  }
+  const extraTaskIds = taskIds.filter((id) => !phaseTaskIds.has(id));
+  for (const taskId of extraTaskIds) {
+    const summary = await _internals.buildTaskSummary(directory, undefined, taskId);
+    if (summary.phase === phase.id) {
+      taskSummaries.push(summary);
+    }
+  }
+  const completedTasks = taskSummaries.filter((s) => s.taskStatus === "completed").length;
+  const tasksWithEvidence = taskSummaries.filter((s) => s.evidenceCount > 0).length;
+  const tasksWithCompleteEvidence = taskSummaries.filter((s) => s.isComplete).length;
+  const missingByType = {};
+  for (const summary of taskSummaries) {
+    for (const missing of summary.missingEvidence) {
+      if (!missingByType[missing]) {
+        missingByType[missing] = [];
+      }
+      if (!missingByType[missing].includes(summary.taskId)) {
+        missingByType[missing].push(summary.taskId);
+      }
+    }
+  }
+  const phaseBlockers = [];
+  for (const [type, taskIds2] of Object.entries(missingByType)) {
+    phaseBlockers.push({
+      type: "missing_evidence",
+      taskId: taskIds2.join(", "),
+      reason: `${type} evidence missing for ${taskIds2.length} task(s)`,
+      severity: "high"
+    });
+  }
+  const incomplete = taskSummaries.filter((s) => s.taskStatus === "completed" && !s.isComplete);
+  for (const task of incomplete) {
+    phaseBlockers.push({
+      type: "incomplete_task",
+      taskId: task.taskId,
+      reason: "Task marked complete but missing required evidence",
+      severity: "medium"
+    });
+  }
+  const blocked = taskSummaries.filter((s) => s.taskStatus === "blocked" || s.blockers.length > 0);
+  for (const task of blocked) {
+    phaseBlockers.push({
+      type: "blocked_task",
+      taskId: task.taskId,
+      reason: task.blockers.join("; ") || "Task is blocked",
+      severity: "high"
+    });
+  }
+  return {
+    phaseId: phase.id,
+    phaseName: phase.name,
+    phaseStatus: phase.status,
+    totalTasks: phase.tasks.length,
+    completedTasks,
+    tasksWithEvidence,
+    tasksWithCompleteEvidence,
+    completionRatio: phase.tasks.length > 0 ? completedTasks / phase.tasks.length : 0,
+    missingEvidenceByType: missingByType,
+    blockers: phaseBlockers,
+    tasks: taskSummaries
+  };
+}
+function generateSummaryText(artifact) {
+  const lines = [];
+  lines.push(`Evidence Summary for "${artifact.planTitle}"`);
+  lines.push(`Generated: ${new Date(artifact.generated_at).toISOString()}`);
+  lines.push("");
+  lines.push(`Overall Completion: ${(artifact.overallCompletionRatio * 100).toFixed(1)}%`);
+  lines.push(`Current Phase: ${artifact.currentPhase}`);
+  lines.push("");
+  for (const phase of artifact.phaseSummaries) {
+    lines.push(`## Phase ${phase.phaseId}: ${phase.phaseName}`);
+    lines.push(`  Tasks: ${phase.completedTasks}/${phase.totalTasks} completed (${(phase.completionRatio * 100).toFixed(1)}%)`);
+    lines.push(`  Evidence: ${phase.tasksWithCompleteEvidence}/${phase.totalTasks} complete`);
+    if (phase.blockers.length > 0) {
+      lines.push("  Blockers:");
+      for (const blocker of phase.blockers) {
+        lines.push(`    - [${blocker.severity}] ${blocker.reason}`);
+      }
+    }
+    lines.push("");
+  }
+  if (artifact.overallBlockers.length > 0) {
+    lines.push("## Overall Blockers");
+    for (const blocker of artifact.overallBlockers) {
+      lines.push(`- [${blocker.severity}] ${blocker.reason}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+async function buildEvidenceSummary(directory, currentPhase) {
+  log("[EvidenceSummary] Building summary for directory", { directory });
+  const plan = await loadPlanJsonOnly(directory);
+  if (!plan) {
+    log("[EvidenceSummary] No plan found, skipping summary generation");
+    return null;
+  }
+  const phasesToProcess = currentPhase !== undefined ? plan.phases.filter((p) => p.id <= currentPhase) : plan.phases;
+  const phaseSummaries = [];
+  let totalTasks = 0;
+  let completedTasks = 0;
+  for (const phase of phasesToProcess) {
+    const summary = await _internals.buildPhaseSummary(directory, phase);
+    phaseSummaries.push(summary);
+    totalTasks += summary.totalTasks;
+    completedTasks += summary.completedTasks;
+  }
+  const overallCompletionRatio = totalTasks > 0 ? completedTasks / totalTasks : 0;
+  const overallBlockers = [];
+  for (const phase of phaseSummaries) {
+    if (phase.phaseStatus !== "complete") {
+      overallBlockers.push(...phase.blockers);
+    }
+  }
+  const artifact = {
+    schema_version: EVIDENCE_SUMMARY_VERSION,
+    generated_at: new Date().toISOString(),
+    planTitle: plan.title,
+    currentPhase: currentPhase ?? plan.current_phase ?? 1,
+    phaseSummaries,
+    overallCompletionRatio,
+    overallBlockers,
+    summaryText: ""
+  };
+  artifact.summaryText = _internals.generateSummaryText(artifact);
+  log("[EvidenceSummary] Summary built", {
+    phases: phaseSummaries.length,
+    totalTasks,
+    completedTasks,
+    completionRatio: overallCompletionRatio,
+    blockers: overallBlockers.length
+  });
+  return artifact;
+}
+function isAutoSummaryEnabled(automationConfig) {
+  if (!automationConfig) {
+    return false;
+  }
+  if (automationConfig.mode === "manual") {
+    return false;
+  }
+  return automationConfig.capabilities?.evidence_auto_summaries === true;
+}
+var _internals = {
+  buildEvidenceSummary,
+  isAutoSummaryEnabled,
+  normalizeBundleEntries,
+  getTaskStatus,
+  evidenceCompleteFromEntries,
+  isEvidenceComplete,
+  getTaskBlockers,
+  buildTaskSummary,
+  buildPhaseSummary,
+  generateSummaryText
+};
+export {
+  isAutoSummaryEnabled,
+  buildEvidenceSummary,
+  _internals,
+  REQUIRED_EVIDENCE_TYPES,
+  EVIDENCE_SUMMARY_VERSION
+};

package/dist/cli/explorer-gz70sm9b.js

@@ -0,0 +1,16 @@
+// @bun
+import {
+  CURATOR_INIT_PROMPT,
+  CURATOR_PHASE_PROMPT,
+  CURATOR_POSTMORTEM_PROMPT,
+  EXPLORER_PROMPT,
+  createExplorerAgent
+} from "./index-yhsmmv2z.js";
+import"./index-a76rekgs.js";
+export {
+  createExplorerAgent,
+  EXPLORER_PROMPT,
+  CURATOR_POSTMORTEM_PROMPT,
+  CURATOR_PHASE_PROMPT,
+  CURATOR_INIT_PROMPT
+};

package/dist/cli/gate-evidence-y8zn7fe2.js

@@ -0,0 +1,29 @@
+// @bun
+import {
+  DEFAULT_REQUIRED_GATES,
+  deriveRequiredGates,
+  expandRequiredGates,
+  hasPassedAllGates,
+  isValidTaskId,
+  readTaskEvidence,
+  readTaskEvidenceRaw,
+  recordAgentDispatch,
+  recordGateEvidence
+} from "./index-e7h9bb6v.js";
+import"./index-fjwwrwr5.js";
+import"./index-bcp79s17.js";
+import"./index-293f68mj.js";
+import"./index-b9v501fr.js";
+import"./index-p0ye10nd.js";
+import"./index-a76rekgs.js";
+export {
+  recordGateEvidence,
+  recordAgentDispatch,
+  readTaskEvidenceRaw,
+  readTaskEvidence,
+  isValidTaskId,
+  hasPassedAllGates,
+  expandRequiredGates,
+  deriveRequiredGates,
+  DEFAULT_REQUIRED_GATES
+};

package/dist/cli/guardrail-explain-tcamcdfy.js

@@ -0,0 +1,30 @@
+// @bun
+import {
+  handleGuardrailExplain
+} from "./index-xw0bcy0v.js";
+import"./index-8ra2qpk8.js";
+import"./index-pv2xmc9k.js";
+import"./index-yhsmmv2z.js";
+import"./index-d9fbxaqd.js";
+import"./index-e8pk68cc.js";
+import"./index-a82d6d87.js";
+import"./index-wg3r6acj.js";
+import"./index-red8fm8p.js";
+import"./index-f8r50m3h.js";
+import"./index-hz59hg4h.js";
+import"./index-e7h9bb6v.js";
+import"./index-fjwwrwr5.js";
+import"./index-eb85wtx9.js";
+import"./index-ckntc5gf.js";
+import"./index-jtqkh8jf.js";
+import"./index-zfsbaaqh.js";
+import"./index-p0arc26j.js";
+import"./index-yx44zd0p.js";
+import"./index-bcp79s17.js";
+import"./index-293f68mj.js";
+import"./index-b9v501fr.js";
+import"./index-p0ye10nd.js";
+import"./index-a76rekgs.js";
+export {
+  handleGuardrailExplain
+};

package/dist/cli/guardrail-log-fd14n96q.js

@@ -0,0 +1,15 @@
+// @bun
+import {
+  handleGuardrailLog
+} from "./index-jfgr5gye.js";
+import"./index-pv2xmc9k.js";
+import"./index-wg3r6acj.js";
+import"./index-zfsbaaqh.js";
+import"./index-p0arc26j.js";
+import"./index-yx44zd0p.js";
+import"./index-293f68mj.js";
+import"./index-b9v501fr.js";
+import"./index-a76rekgs.js";
+export {
+  handleGuardrailLog
+};