opencode-swarm 6.17.1 → 6.17.3

package/dist/commands/index.d.ts

@@ -8,7 +8,7 @@ export { handleConfigCommand } from './config';
 export { handleDarkMatterCommand } from './dark-matter';
 export { handleDiagnoseCommand } from './diagnose';
 export { handleDoctorCommand } from './doctor';
-export { handleEvidenceCommand } from './evidence';
+export { handleEvidenceCommand, handleEvidenceSummaryCommand, } from './evidence';
 export { handleExportCommand } from './export';
 export { handleHistoryCommand } from './history';
 export { handleKnowledgeMigrateCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, } from './knowledge';

package/dist/evidence/index.d.ts

@@ -1 +1,2 @@
+export type { LoadEvidenceResult } from './manager';
 export { archiveEvidence, deleteEvidence, listEvidenceTaskIds, loadEvidence, sanitizeTaskId, saveEvidence, } from './manager';

package/dist/evidence/manager.d.ts

@@ -1,4 +1,19 @@
 import { type BuildEvidence, type Evidence, type EvidenceBundle, type PlaceholderEvidence, type QualityBudgetEvidence, type SastEvidence, type SbomEvidence, type SyntaxEvidence } from '../config/evidence-schema';
+/**
+ * Discriminated union returned by loadEvidence.
+ * - 'found': file exists and passed Zod schema validation
+ * - 'not_found': file does not exist on disk
+ * - 'invalid_schema': file exists but failed Zod validation; errors contains field names
+ */
+export type LoadEvidenceResult = {
+    status: 'found';
+    bundle: EvidenceBundle;
+} | {
+    status: 'not_found';
+} | {
+    status: 'invalid_schema';
+    errors: string[];
+};
 /**
  * All valid evidence types (12 total)
  */
@@ -33,9 +48,9 @@ export declare function sanitizeTaskId(taskId: string): string;
 export declare function saveEvidence(directory: string, taskId: string, evidence: Evidence): Promise<EvidenceBundle>;
 /**
  * Load evidence bundle for a task.
- * Returns null if file doesn't exist or validation fails.
+ * Returns a LoadEvidenceResult discriminated union.
  */
-export declare function loadEvidence(directory: string, taskId: string): Promise<EvidenceBundle | null>;
+export declare function loadEvidence(directory: string, taskId: string): Promise<LoadEvidenceResult>;
 /**
  * List all task IDs that have evidence bundles.
  * Returns sorted array of valid task IDs.

package/dist/index.js

@@ -14496,15 +14496,16 @@ async function loadEvidence(directory, taskId) {
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
-    return null;
+    return { status: "not_found" };
   }
   try {
     const parsed = JSON.parse(content);
     const validated = EvidenceBundleSchema.parse(parsed);
-    return validated;
+    return { status: "found", bundle: validated };
   } catch (error49) {
     warn(`Evidence bundle validation failed for task ${sanitizedTaskId}: ${error49 instanceof Error ? error49.message : String(error49)}`);
-    return null;
+    const errors3 = error49 instanceof ZodError ? error49.issues.map((e) => e.path.join(".") + ": " + e.message) : [String(error49)];
+    return { status: "invalid_schema", errors: errors3 };
   }
 }
 async function listEvidenceTaskIds(directory) {
@@ -14563,11 +14564,11 @@ async function archiveEvidence(directory, maxAgeDays, maxBundles) {
   const archived = [];
   const remainingBundles = [];
   for (const taskId of taskIds) {
-    const bundle = await loadEvidence(directory, taskId);
-    if (!bundle) {
+    const result = await loadEvidence(directory, taskId);
+    if (result.status !== "found") {
       continue;
     }
-    if (bundle.updated_at < cutoffIso) {
+    if (result.bundle.updated_at < cutoffIso) {
       const deleted = await deleteEvidence(directory, taskId);
       if (deleted) {
         archived.push(taskId);
@@ -14575,7 +14576,7 @@ async function archiveEvidence(directory, maxAgeDays, maxBundles) {
     } else {
       remainingBundles.push({
         taskId,
-        updatedAt: bundle.updated_at
+        updatedAt: result.bundle.updated_at
       });
     }
   }
@@ -14593,6 +14594,7 @@ async function archiveEvidence(directory, maxAgeDays, maxBundles) {
 }
 var VALID_EVIDENCE_TYPES, TASK_ID_REGEX;
 var init_manager = __esm(() => {
+  init_zod();
   init_evidence_schema();
   init_utils2();
   init_utils();
@@ -15108,7 +15110,8 @@ function getTaskBlockers(task, summary, status) {
   return blockers;
 }
 async function buildTaskSummary(task, taskId) {
-  const bundle = await loadEvidence(".", taskId);
+  const result = await loadEvidence(".", taskId);
+  const bundle = result.status === "found" ? result.bundle : null;
   const phase = task?.phase ?? 0;
   const status = getTaskStatus(task, bundle);
   const evidenceCheck = isEvidenceComplete(bundle);
@@ -38923,6 +38926,7 @@ Available commands via /swarm: status, plan, agents, history, config, config doc
 evidence, evidence summary, archive, diagnose, preflight, sync-plan, benchmark, export,
 reset, retrieve, clarify, analyze, specify, dark-matter, knowledge quarantine, knowledge restore, knowledge migrate.
 Type /swarm (no arguments) for full help.
+Outside OpenCode, invoke any plugin command via: \`bunx opencode-swarm run <command> [args]\` (e.g. \`bunx opencode-swarm run knowledge migrate\`). Do not use \`bun -e\` or look for \`src/commands/\` \u2014 those paths are internal to the plugin source and do not exist in user project directories.
 
 SMEs advise only. Reviewer and critic review only. None of them write code.
 
@@ -41295,11 +41299,14 @@ async function handleArchiveCommand(directory, args2) {
     const wouldArchiveAge = [];
     const remainingBundles = [];
     for (const taskId of beforeTaskIds) {
-      const bundle = await loadEvidence(directory, taskId);
-      if (bundle && bundle.updated_at < cutoffIso) {
+      const result = await loadEvidence(directory, taskId);
+      if (result.status !== "found") {
+        continue;
+      }
+      if (result.bundle.updated_at < cutoffIso) {
         wouldArchiveAge.push(taskId);
-      } else if (bundle) {
-        remainingBundles.push({ taskId, updatedAt: bundle.updated_at });
+      } else {
+        remainingBundles.push({ taskId, updatedAt: result.bundle.updated_at });
       }
     }
     const wouldArchiveMaxBundles = [];
@@ -41597,10 +41604,10 @@ async function handleBenchmarkCommand(directory, args2) {
     let totalTestToCodeRatio = 0;
     let qualityEvidenceCount = 0;
     for (const tid of await listEvidenceTaskIds(directory)) {
-      const b = await loadEvidence(directory, tid);
-      if (!b)
+      const result = await loadEvidence(directory, tid);
+      if (result.status !== "found")
         continue;
-      for (const e of b.entries) {
+      for (const e of result.bundle.entries) {
         if (!isValidEvidenceType(e.type)) {
           warn(`Unknown evidence type '${e.type}' in task ${tid}, skipping`);
           continue;
@@ -42905,8 +42912,8 @@ function getVerdictEmoji(verdict) {
   return getVerdictIcon(verdict);
 }
 async function getTaskEvidenceData(directory, taskId) {
-  const bundle = await loadEvidence(directory, taskId);
-  if (!bundle) {
+  const result = await loadEvidence(directory, taskId);
+  if (result.status !== "found") {
     return {
       hasEvidence: false,
       taskId,
@@ -42916,14 +42923,14 @@ async function getTaskEvidenceData(directory, taskId) {
     };
   }
   const entries = [];
-  for (let i2 = 0;i2 < bundle.entries.length; i2++) {
-    entries.push(formatEvidenceEntry(i2 + 1, bundle.entries[i2]));
+  for (let i2 = 0;i2 < result.bundle.entries.length; i2++) {
+    entries.push(formatEvidenceEntry(i2 + 1, result.bundle.entries[i2]));
   }
   return {
     hasEvidence: true,
     taskId,
-    createdAt: bundle.created_at,
-    updatedAt: bundle.updated_at,
+    createdAt: result.bundle.created_at,
+    updatedAt: result.bundle.updated_at,
     entries
   };
 }
@@ -42934,12 +42941,12 @@ async function getEvidenceListData(directory) {
   }
   const tasks = [];
   for (const taskId of taskIds) {
-    const bundle = await loadEvidence(directory, taskId);
-    if (bundle) {
+    const result = await loadEvidence(directory, taskId);
+    if (result.status === "found") {
       tasks.push({
         taskId,
-        entryCount: bundle.entries.length,
-        lastUpdated: bundle.updated_at
+        entryCount: result.bundle.entries.length,
+        lastUpdated: result.bundle.updated_at
       });
     } else {
       tasks.push({
@@ -44616,7 +44623,8 @@ var HELP_TEXT = [
   "- `/swarm specify [description]` \u2014 Generate or import a feature specification",
   "- `/swarm dark-matter` \u2014 Detect hidden file couplings via co-change NPMI analysis",
   "- `/swarm knowledge quarantine <id> [reason]` \u2014 Move a knowledge entry to quarantine",
-  "- `/swarm knowledge restore <id>` \u2014 Restore a quarantined knowledge entry"
+  "- `/swarm knowledge restore <id>` \u2014 Restore a quarantined knowledge entry",
+  "- `/swarm knowledge migrate` \u2014 Migrate knowledge entries to the current format"
 ].join(`
 `);
 function createSwarmCommandHandler(directory, agents) {
@@ -45106,7 +45114,7 @@ function logFirstCall(modelID, providerID, source, limit) {
   const key = `${modelID || "unknown"}::${providerID || "unknown"}`;
   if (!loggedFirstCalls.has(key)) {
     loggedFirstCalls.add(key);
-    warn(`[model-limits] Resolved limit for ${modelID || "(no model)"}@${providerID || "(no provider)"}: ${limit} (source: ${source})`);
+    log(`[model-limits] Resolved limit for ${modelID || "(no model)"}@${providerID || "(no provider)"}: ${limit} (source: ${source})`);
   }
 }
 
@@ -45131,7 +45139,7 @@ function createContextBudgetHandler(config3) {
     const cacheKey = `${modelID || "unknown"}::${providerID || "unknown"}`;
     if (!loggedLimits.has(cacheKey)) {
       loggedLimits.add(cacheKey);
-      warn(`[swarm] Context budget: model=${modelID || "unknown"} provider=${providerID || "unknown"} limit=${modelLimit}`);
+      log(`[swarm] Context budget: model=${modelID || "unknown"} provider=${providerID || "unknown"} limit=${modelLimit}`);
     }
     let totalTokens = 0;
     for (const message of messages) {
@@ -46608,9 +46616,9 @@ async function buildRetroInjection(directory, currentPhaseNumber, currentPlanTit
   try {
     const prevPhase = currentPhaseNumber - 1;
     if (prevPhase >= 1) {
-      const bundle = await loadEvidence(directory, `retro-${prevPhase}`);
-      if (bundle && bundle.entries.length > 0) {
-        const retroEntry = bundle.entries.find((entry) => entry.type === "retrospective");
+      const result1 = await loadEvidence(directory, `retro-${prevPhase}`);
+      if (result1.status === "found" && result1.bundle.entries.length > 0) {
+        const retroEntry = result1.bundle.entries.find((entry) => entry.type === "retrospective");
         if (retroEntry && retroEntry.verdict !== "fail") {
           const lessons = retroEntry.lessons_learned ?? [];
           const rejections = retroEntry.top_rejection_reasons ?? [];
@@ -46638,9 +46646,9 @@ ${top5.map((d) => `- [${d.category}] ${d.directive}`).join(`
       const retroIds = taskIds.filter((id) => id.startsWith("retro-"));
       let latestRetro = null;
       for (const taskId of retroIds) {
-        const b = await loadEvidence(directory, taskId);
-        if (b && b.entries.length > 0) {
-          for (const entry of b.entries) {
+        const r = await loadEvidence(directory, taskId);
+        if (r.status === "found" && r.bundle.entries.length > 0) {
+          for (const entry of r.bundle.entries) {
             if (entry.type === "retrospective") {
               const retro = entry;
               if (retro.verdict !== "fail") {
@@ -46687,16 +46695,16 @@ ${top5.map((d) => `- [${d.category}] ${d.directive}`).join(`
     const now = Date.now();
     for (const taskId of allRetroIds) {
       const b = await loadEvidence(directory, taskId);
-      if (!b)
+      if (b.status !== "found")
         continue;
-      for (const e of b.entries) {
+      for (const e of b.bundle.entries) {
         if (e.type === "retrospective") {
           const retro = e;
           if (retro.verdict === "fail")
             continue;
           if (currentPlanTitle && typeof retro.metadata === "object" && retro.metadata !== null && "plan_id" in retro.metadata && retro.metadata.plan_id === currentPlanTitle)
             continue;
-          const ts = retro.timestamp ?? b.created_at;
+          const ts = retro.timestamp ?? b.bundle.created_at;
           const ageMs = now - new Date(ts).getTime();
           if (isNaN(ageMs) || ageMs > cutoffMs)
             continue;
@@ -46752,10 +46760,10 @@ async function buildCoderRetroInjection(directory, currentPhaseNumber) {
     const prevPhase = currentPhaseNumber - 1;
     if (prevPhase < 1)
       return null;
-    const bundle = await loadEvidence(directory, `retro-${prevPhase}`);
-    if (!bundle || bundle.entries.length === 0)
+    const result = await loadEvidence(directory, `retro-${prevPhase}`);
+    if (result.status !== "found" || result.bundle.entries.length === 0)
       return null;
-    const retroEntry = bundle.entries.find((entry) => entry.type === "retrospective");
+    const retroEntry = result.bundle.entries.find((entry) => entry.type === "retrospective");
     if (!retroEntry || retroEntry.verdict === "fail")
       return null;
     const lessons = retroEntry.lessons_learned ?? [];
@@ -50176,34 +50184,69 @@ async function executePhaseComplete(args2, workingDirectory) {
       warnings: []
     }, null, 2);
   }
-  const retroBundle = await loadEvidence(dir, `retro-${phase}`);
+  const retroResult = await loadEvidence(dir, `retro-${phase}`);
   let retroFound = false;
-  if (retroBundle !== null) {
-    retroFound = retroBundle.entries?.some((entry) => isValidRetroEntry(entry, phase)) ?? false;
+  let invalidSchemaErrors = [];
+  if (retroResult.status === "found") {
+    retroFound = retroResult.bundle.entries?.some((entry) => isValidRetroEntry(entry, phase)) ?? false;
+  } else if (retroResult.status === "invalid_schema") {
+    invalidSchemaErrors = retroResult.errors;
   }
   if (!retroFound) {
     const allTaskIds = await listEvidenceTaskIds(dir);
     const retroTaskIds = allTaskIds.filter((id) => id.startsWith("retro-"));
     for (const taskId of retroTaskIds) {
-      const bundle = await loadEvidence(dir, taskId);
-      if (bundle === null)
+      const bundleResult = await loadEvidence(dir, taskId);
+      if (bundleResult.status !== "found") {
+        if (bundleResult.status === "invalid_schema") {
+          invalidSchemaErrors.push(...bundleResult.errors);
+        }
         continue;
-      retroFound = bundle.entries?.some((entry) => isValidRetroEntry(entry, phase)) ?? false;
+      }
+      retroFound = bundleResult.bundle.entries?.some((entry) => isValidRetroEntry(entry, phase)) ?? false;
       if (retroFound)
         break;
     }
   }
   if (!retroFound) {
+    const schemaErrorDetail = invalidSchemaErrors.length > 0 ? ` Schema validation failed: ${invalidSchemaErrors.join("; ")}.` : "";
     return JSON.stringify({
       success: false,
       phase,
       status: "blocked",
       reason: "RETROSPECTIVE_MISSING",
-      message: `Phase ${phase} cannot be completed: no valid retrospective evidence found. Write a retrospective bundle at .swarm/evidence/retro-${phase}/evidence.json with type='retrospective', phase_number=${phase}, verdict='pass' before calling phase_complete.`,
+      message: `Phase ${phase} cannot be completed: no valid retrospective evidence found.${schemaErrorDetail} Write a retrospective bundle at .swarm/evidence/retro-${phase}/evidence.json before calling phase_complete.`,
       agentsDispatched: [],
       agentsMissing: [],
       warnings: [
-        `Retrospective missing for phase ${phase}. Write a retro bundle with verdict='pass' at .swarm/evidence/retro-${phase}/evidence.json`
+        `Retrospective missing for phase ${phase}.${schemaErrorDetail} Use this template:`,
+        JSON.stringify({
+          schema_version: "1.0.0",
+          task_id: `retro-${phase}`,
+          created_at: new Date().toISOString(),
+          updated_at: new Date().toISOString(),
+          entries: [
+            {
+              task_id: `retro-${phase}`,
+              type: "retrospective",
+              timestamp: new Date().toISOString(),
+              agent: "architect",
+              verdict: "pass",
+              summary: `Phase ${phase} completed.`,
+              phase_number: phase,
+              total_tool_calls: 0,
+              coder_revisions: 0,
+              reviewer_rejections: 0,
+              test_failures: 0,
+              security_findings: 0,
+              integration_issues: 0,
+              task_count: 1,
+              task_complexity: "simple",
+              top_rejection_reasons: [],
+              lessons_learned: []
+            }
+          ]
+        }, null, 2)
       ]
     }, null, 2);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "6.17.1",
+	"version": "6.17.3",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",