opencode-swarm 6.18.0 → 6.18.1

package/dist/cli/index.js

@@ -14272,6 +14272,60 @@ function sanitizeTaskId(taskId) {
   }
   return taskId;
 }
+async function saveEvidence(directory, taskId, evidence) {
+  const sanitizedTaskId = sanitizeTaskId(taskId);
+  const relativePath = path3.join("evidence", sanitizedTaskId, "evidence.json");
+  const evidencePath = validateSwarmPath(directory, relativePath);
+  const evidenceDir = path3.dirname(evidencePath);
+  let bundle;
+  const existingContent = await readSwarmFileAsync(directory, relativePath);
+  if (existingContent !== null) {
+    try {
+      const parsed = JSON.parse(existingContent);
+      bundle = EvidenceBundleSchema.parse(parsed);
+    } catch (error49) {
+      warn(`Existing evidence bundle invalid for task ${sanitizedTaskId}, creating new: ${error49 instanceof Error ? error49.message : String(error49)}`);
+      const now = new Date().toISOString();
+      bundle = {
+        schema_version: "1.0.0",
+        task_id: sanitizedTaskId,
+        entries: [],
+        created_at: now,
+        updated_at: now
+      };
+    }
+  } else {
+    const now = new Date().toISOString();
+    bundle = {
+      schema_version: "1.0.0",
+      task_id: sanitizedTaskId,
+      entries: [],
+      created_at: now,
+      updated_at: now
+    };
+  }
+  const updatedBundle = {
+    ...bundle,
+    entries: [...bundle.entries, evidence],
+    updated_at: new Date().toISOString()
+  };
+  const bundleJson = JSON.stringify(updatedBundle);
+  if (bundleJson.length > EVIDENCE_MAX_JSON_BYTES) {
+    throw new Error(`Evidence bundle size (${bundleJson.length} bytes) exceeds maximum (${EVIDENCE_MAX_JSON_BYTES} bytes)`);
+  }
+  mkdirSync(evidenceDir, { recursive: true });
+  const tempPath = path3.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+  try {
+    await Bun.write(tempPath, bundleJson);
+    renameSync(tempPath, evidencePath);
+  } catch (error49) {
+    try {
+      rmSync(tempPath, { force: true });
+    } catch {}
+    throw error49;
+  }
+  return updatedBundle;
+}
 async function loadEvidence(directory, taskId) {
   const sanitizedTaskId = sanitizeTaskId(taskId);
   const relativePath = path3.join("evidence", sanitizedTaskId, "evidence.json");
@@ -37958,6 +38012,128 @@ No active swarm plan found. Nothing to sync.`;
 `);
 }
 
+// src/tools/write-retro.ts
+init_manager();
+async function executeWriteRetro(args, directory) {
+  const phase = args.phase;
+  if (!Number.isInteger(phase) || phase < 1) {
+    return JSON.stringify({
+      success: false,
+      phase,
+      message: "Invalid phase: must be a positive integer"
+    }, null, 2);
+  }
+  const validComplexities = [
+    "trivial",
+    "simple",
+    "moderate",
+    "complex"
+  ];
+  if (!validComplexities.includes(args.task_complexity)) {
+    return JSON.stringify({
+      success: false,
+      phase,
+      message: `Invalid task_complexity: must be one of 'trivial'|'simple'|'moderate'|'complex'`
+    }, null, 2);
+  }
+  if (!Number.isInteger(args.task_count) || args.task_count < 1) {
+    return JSON.stringify({
+      success: false,
+      phase,
+      message: "Invalid task_count: must be a positive integer >= 1"
+    }, null, 2);
+  }
+  const summary = args.summary;
+  if (typeof summary !== "string" || summary.trim().length === 0) {
+    return JSON.stringify({
+      success: false,
+      phase,
+      message: "Invalid summary: must be a non-empty string"
+    }, null, 2);
+  }
+  const taskId = args.task_id ?? `retro-${phase}`;
+  const retroEntry = {
+    task_id: taskId,
+    type: "retrospective",
+    timestamp: new Date().toISOString(),
+    agent: "architect",
+    verdict: "pass",
+    summary,
+    metadata: args.metadata,
+    phase_number: phase,
+    total_tool_calls: args.total_tool_calls,
+    coder_revisions: args.coder_revisions,
+    reviewer_rejections: args.reviewer_rejections,
+    test_failures: args.test_failures,
+    security_findings: args.security_findings,
+    integration_issues: args.integration_issues,
+    task_count: args.task_count,
+    task_complexity: args.task_complexity,
+    top_rejection_reasons: args.top_rejection_reasons ?? [],
+    lessons_learned: (args.lessons_learned ?? []).slice(0, 5),
+    user_directives: [],
+    approaches_tried: []
+  };
+  try {
+    await saveEvidence(directory, taskId, retroEntry);
+    return JSON.stringify({
+      success: true,
+      task_id: taskId,
+      phase,
+      message: `Retrospective evidence written to .swarm/evidence/${taskId}/evidence.json`
+    }, null, 2);
+  } catch (error93) {
+    return JSON.stringify({
+      success: false,
+      phase,
+      message: error93 instanceof Error ? error93.message : String(error93)
+    }, null, 2);
+  }
+}
+var write_retro = createSwarmTool({
+  description: "Write a retrospective evidence bundle for a completed phase. " + "Accepts flat retro fields and writes a correctly-wrapped EvidenceBundle to " + ".swarm/evidence/retro-{phase}/evidence.json. " + "Use this instead of manually writing retro JSON to avoid schema validation failures in phase_complete.",
+  args: {
+    phase: tool.schema.number().int().positive().describe("The phase number being completed (e.g., 1, 2, 3)"),
+    summary: tool.schema.string().describe("Human-readable summary of the phase"),
+    task_count: tool.schema.number().int().min(1).describe("Count of tasks completed in this phase"),
+    task_complexity: tool.schema.enum(["trivial", "simple", "moderate", "complex"]).describe("Complexity level of the completed tasks"),
+    total_tool_calls: tool.schema.number().int().min(0).describe("Total number of tool calls in this phase"),
+    coder_revisions: tool.schema.number().int().min(0).describe("Number of coder revisions made"),
+    reviewer_rejections: tool.schema.number().int().min(0).describe("Number of reviewer rejections received"),
+    test_failures: tool.schema.number().int().min(0).describe("Number of test failures encountered"),
+    security_findings: tool.schema.number().int().min(0).describe("Number of security findings"),
+    integration_issues: tool.schema.number().int().min(0).describe("Number of integration issues"),
+    lessons_learned: tool.schema.array(tool.schema.string()).max(5).optional().describe("Key lessons learned from this phase (max 5)"),
+    top_rejection_reasons: tool.schema.array(tool.schema.string()).optional().describe("Top reasons for reviewer rejections"),
+    task_id: tool.schema.string().optional().describe("Optional custom task ID (defaults to retro-{phase})"),
+    metadata: tool.schema.record(tool.schema.string(), tool.schema.unknown()).optional().describe("Optional additional metadata")
+  },
+  execute: async (args, directory) => {
+    const rawPhase = args.phase !== undefined ? Number(args.phase) : 0;
+    try {
+      const writeRetroArgs = {
+        phase: Number(args.phase),
+        summary: String(args.summary ?? ""),
+        task_count: Number(args.task_count),
+        task_complexity: args.task_complexity,
+        total_tool_calls: Number(args.total_tool_calls),
+        coder_revisions: Number(args.coder_revisions),
+        reviewer_rejections: Number(args.reviewer_rejections),
+        test_failures: Number(args.test_failures),
+        security_findings: Number(args.security_findings),
+        integration_issues: Number(args.integration_issues),
+        lessons_learned: Array.isArray(args.lessons_learned) ? args.lessons_learned.map(String) : undefined,
+        top_rejection_reasons: Array.isArray(args.top_rejection_reasons) ? args.top_rejection_reasons.map(String) : undefined,
+        task_id: args.task_id !== undefined ? String(args.task_id) : undefined,
+        metadata: args.metadata
+      };
+      return await executeWriteRetro(writeRetroArgs, directory);
+    } catch {
+      return JSON.stringify({ success: false, phase: rawPhase, message: "Invalid arguments" }, null, 2);
+    }
+  }
+});
+
 // src/commands/index.ts
 var HELP_TEXT = [
   "## Swarm Commands",
@@ -37986,7 +38162,8 @@ var HELP_TEXT = [
   "- `/swarm simulate [--target <glob>]` \u2014 Dry-run impact analysis of proposed changes",
   "- `/swarm knowledge quarantine <id> [reason]` \u2014 Move a knowledge entry to quarantine",
   "- `/swarm knowledge restore <id>` \u2014 Restore a quarantined knowledge entry",
-  "- `/swarm knowledge migrate` \u2014 Migrate knowledge entries to the current format"
+  "- `/swarm knowledge migrate` \u2014 Migrate knowledge entries to the current format",
+  "- `/swarm write-retro <json>` \u2014 Write a retrospective evidence bundle for a completed phase"
 ].join(`
 `);
 

package/dist/commands/index.d.ts

@@ -21,6 +21,7 @@ export { handleSimulateCommand } from './simulate';
 export { handleSpecifyCommand } from './specify';
 export { handleStatusCommand } from './status';
 export { handleSyncPlanCommand } from './sync-plan';
+export { handleWriteRetroCommand } from './write_retro';
 /**
  * Creates a command.execute.before handler for /swarm commands.
  * Uses factory pattern to close over directory and agents.

package/dist/commands/write_retro.d.ts

@@ -0,0 +1 @@
+export declare function handleWriteRetroCommand(directory: string, args: string[]): Promise<string>;

package/dist/index.js

@@ -45019,6 +45019,188 @@ No active swarm plan found. Nothing to sync.`;
 `);
 }
 
+// src/tools/write-retro.ts
+init_tool();
+init_manager();
+init_create_tool();
+async function executeWriteRetro(args2, directory) {
+  const phase = args2.phase;
+  if (!Number.isInteger(phase) || phase < 1) {
+    return JSON.stringify({
+      success: false,
+      phase,
+      message: "Invalid phase: must be a positive integer"
+    }, null, 2);
+  }
+  const validComplexities = [
+    "trivial",
+    "simple",
+    "moderate",
+    "complex"
+  ];
+  if (!validComplexities.includes(args2.task_complexity)) {
+    return JSON.stringify({
+      success: false,
+      phase,
+      message: `Invalid task_complexity: must be one of 'trivial'|'simple'|'moderate'|'complex'`
+    }, null, 2);
+  }
+  if (!Number.isInteger(args2.task_count) || args2.task_count < 1) {
+    return JSON.stringify({
+      success: false,
+      phase,
+      message: "Invalid task_count: must be a positive integer >= 1"
+    }, null, 2);
+  }
+  const summary = args2.summary;
+  if (typeof summary !== "string" || summary.trim().length === 0) {
+    return JSON.stringify({
+      success: false,
+      phase,
+      message: "Invalid summary: must be a non-empty string"
+    }, null, 2);
+  }
+  const taskId = args2.task_id ?? `retro-${phase}`;
+  const retroEntry = {
+    task_id: taskId,
+    type: "retrospective",
+    timestamp: new Date().toISOString(),
+    agent: "architect",
+    verdict: "pass",
+    summary,
+    metadata: args2.metadata,
+    phase_number: phase,
+    total_tool_calls: args2.total_tool_calls,
+    coder_revisions: args2.coder_revisions,
+    reviewer_rejections: args2.reviewer_rejections,
+    test_failures: args2.test_failures,
+    security_findings: args2.security_findings,
+    integration_issues: args2.integration_issues,
+    task_count: args2.task_count,
+    task_complexity: args2.task_complexity,
+    top_rejection_reasons: args2.top_rejection_reasons ?? [],
+    lessons_learned: (args2.lessons_learned ?? []).slice(0, 5),
+    user_directives: [],
+    approaches_tried: []
+  };
+  try {
+    await saveEvidence(directory, taskId, retroEntry);
+    return JSON.stringify({
+      success: true,
+      task_id: taskId,
+      phase,
+      message: `Retrospective evidence written to .swarm/evidence/${taskId}/evidence.json`
+    }, null, 2);
+  } catch (error93) {
+    return JSON.stringify({
+      success: false,
+      phase,
+      message: error93 instanceof Error ? error93.message : String(error93)
+    }, null, 2);
+  }
+}
+var write_retro = createSwarmTool({
+  description: "Write a retrospective evidence bundle for a completed phase. " + "Accepts flat retro fields and writes a correctly-wrapped EvidenceBundle to " + ".swarm/evidence/retro-{phase}/evidence.json. " + "Use this instead of manually writing retro JSON to avoid schema validation failures in phase_complete.",
+  args: {
+    phase: tool.schema.number().int().positive().describe("The phase number being completed (e.g., 1, 2, 3)"),
+    summary: tool.schema.string().describe("Human-readable summary of the phase"),
+    task_count: tool.schema.number().int().min(1).describe("Count of tasks completed in this phase"),
+    task_complexity: tool.schema.enum(["trivial", "simple", "moderate", "complex"]).describe("Complexity level of the completed tasks"),
+    total_tool_calls: tool.schema.number().int().min(0).describe("Total number of tool calls in this phase"),
+    coder_revisions: tool.schema.number().int().min(0).describe("Number of coder revisions made"),
+    reviewer_rejections: tool.schema.number().int().min(0).describe("Number of reviewer rejections received"),
+    test_failures: tool.schema.number().int().min(0).describe("Number of test failures encountered"),
+    security_findings: tool.schema.number().int().min(0).describe("Number of security findings"),
+    integration_issues: tool.schema.number().int().min(0).describe("Number of integration issues"),
+    lessons_learned: tool.schema.array(tool.schema.string()).max(5).optional().describe("Key lessons learned from this phase (max 5)"),
+    top_rejection_reasons: tool.schema.array(tool.schema.string()).optional().describe("Top reasons for reviewer rejections"),
+    task_id: tool.schema.string().optional().describe("Optional custom task ID (defaults to retro-{phase})"),
+    metadata: tool.schema.record(tool.schema.string(), tool.schema.unknown()).optional().describe("Optional additional metadata")
+  },
+  execute: async (args2, directory) => {
+    const rawPhase = args2.phase !== undefined ? Number(args2.phase) : 0;
+    try {
+      const writeRetroArgs = {
+        phase: Number(args2.phase),
+        summary: String(args2.summary ?? ""),
+        task_count: Number(args2.task_count),
+        task_complexity: args2.task_complexity,
+        total_tool_calls: Number(args2.total_tool_calls),
+        coder_revisions: Number(args2.coder_revisions),
+        reviewer_rejections: Number(args2.reviewer_rejections),
+        test_failures: Number(args2.test_failures),
+        security_findings: Number(args2.security_findings),
+        integration_issues: Number(args2.integration_issues),
+        lessons_learned: Array.isArray(args2.lessons_learned) ? args2.lessons_learned.map(String) : undefined,
+        top_rejection_reasons: Array.isArray(args2.top_rejection_reasons) ? args2.top_rejection_reasons.map(String) : undefined,
+        task_id: args2.task_id !== undefined ? String(args2.task_id) : undefined,
+        metadata: args2.metadata
+      };
+      return await executeWriteRetro(writeRetroArgs, directory);
+    } catch {
+      return JSON.stringify({ success: false, phase: rawPhase, message: "Invalid arguments" }, null, 2);
+    }
+  }
+});
+
+// src/commands/write_retro.ts
+async function handleWriteRetroCommand(directory, args2) {
+  if (args2.length === 0 || !args2[0] || args2[0].trim() === "") {
+    return `## Usage: /swarm write-retro <json>
+
+Writes a retrospective evidence bundle for a completed phase.
+
+### Required JSON fields:
+\`\`\`json
+{
+  "phase": 1,
+  "summary": "Phase summary here",
+  "task_count": 3,
+  "task_complexity": "simple",
+  "total_tool_calls": 20,
+  "coder_revisions": 1,
+  "reviewer_rejections": 0,
+  "test_failures": 0,
+  "security_findings": 0,
+  "integration_issues": 0
+}
+\`\`\`
+
+### Optional fields:
+- \`lessons_learned\`: string[] (max 5)
+- \`top_rejection_reasons\`: string[]
+- \`task_id\`: string (defaults to \`retro-{phase}\`)
+- \`metadata\`: Record<string, unknown>
+
+### task_complexity values: trivial | simple | moderate | complex`;
+  }
+  let parsedArgs;
+  try {
+    const jsonObj = JSON.parse(args2[0]);
+    if (typeof jsonObj !== "object" || jsonObj === null || Array.isArray(jsonObj)) {
+      return "Error: Invalid JSON \u2014 expected a JSON object with retro fields. Run `/swarm write-retro` with no arguments to see usage.";
+    }
+    parsedArgs = jsonObj;
+  } catch {
+    return "Error: Invalid JSON \u2014 expected a JSON object with retro fields. Run `/swarm write-retro` with no arguments to see usage.";
+  }
+  const resultJson = await executeWriteRetro(parsedArgs, directory);
+  let result;
+  try {
+    result = JSON.parse(resultJson);
+  } catch {
+    return "Error: Failed to parse result from write-retro tool.";
+  }
+  if (result.success === true) {
+    return `## Retrospective Written
+
+Phase **${result.phase ?? "unknown"}** retrospective saved to \`.swarm/evidence/${result.task_id ?? "unknown"}/evidence.json\`.
+
+Run \`/swarm evidence ${result.task_id ?? "unknown"}\` to view it, or \`/swarm status\` to check phase_complete readiness.`;
+  }
+  return `Error: ${result.message}`;
+}
+
 // src/commands/index.ts
 var HELP_TEXT = [
   "## Swarm Commands",
@@ -45047,7 +45229,8 @@ var HELP_TEXT = [
   "- `/swarm simulate [--target <glob>]` \u2014 Dry-run impact analysis of proposed changes",
   "- `/swarm knowledge quarantine <id> [reason]` \u2014 Move a knowledge entry to quarantine",
   "- `/swarm knowledge restore <id>` \u2014 Restore a quarantined knowledge entry",
-  "- `/swarm knowledge migrate` \u2014 Migrate knowledge entries to the current format"
+  "- `/swarm knowledge migrate` \u2014 Migrate knowledge entries to the current format",
+  "- `/swarm write-retro <json>` \u2014 Write a retrospective evidence bundle for a completed phase"
 ].join(`
 `);
 function createSwarmCommandHandler(directory, agents) {
@@ -45133,6 +45316,9 @@ function createSwarmCommandHandler(directory, agents) {
       case "dark-matter":
         text = await handleDarkMatterCommand(directory, args2);
         break;
+      case "write-retro":
+        text = await handleWriteRetroCommand(directory, args2);
+        break;
       case "knowledge": {
         const [knowledgeSubcmd, ...knowledgeArgs] = args2;
         if (knowledgeSubcmd === "quarantine") {

package/dist/tools/index.d.ts

@@ -24,3 +24,4 @@ export { symbols } from './symbols';
 export { type SyntaxCheckFileResult, type SyntaxCheckInput, type SyntaxCheckResult, syntaxCheck, } from './syntax-check';
 export { test_runner } from './test-runner';
 export { todo_extract } from './todo-extract';
+export { executeWriteRetro, write_retro } from './write-retro';

package/dist/tools/write-retro.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Write retro tool for persisting retrospective evidence bundles.
+ * Accepts flat retro fields from the Architect and wraps them correctly
+ * in a RetrospectiveEvidence entry before calling saveEvidence().
+ * This fixes the bug where Architect was writing flat JSON that failed EvidenceBundleSchema.parse().
+ */
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+/**
+ * Arguments for the write_retro tool
+ * User-supplied fields (the Architect provides these)
+ */
+export interface WriteRetroArgs {
+    /** The phase number being completed (maps to phase_number in schema) */
+    phase: number;
+    /** Human-readable phase summary (maps to summary in BaseEvidenceSchema) */
+    summary: string;
+    /** Count of tasks completed */
+    task_count: number;
+    /** Task complexity level */
+    task_complexity: 'trivial' | 'simple' | 'moderate' | 'complex';
+    /** Total number of tool calls in the phase */
+    total_tool_calls: number;
+    /** Number of coder revisions made */
+    coder_revisions: number;
+    /** Number of reviewer rejections received */
+    reviewer_rejections: number;
+    /** Number of test failures encountered */
+    test_failures: number;
+    /** Number of security findings */
+    security_findings: number;
+    /** Number of integration issues */
+    integration_issues: number;
+    /** Optional lessons learned (max 5) */
+    lessons_learned?: string[];
+    /** Optional top rejection reasons */
+    top_rejection_reasons?: string[];
+    /** Optional task ID (defaults to retro-{phase}) */
+    task_id?: string;
+    /** Optional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Execute the write_retro tool.
+ * Validates input, builds a RetrospectiveEvidence entry, and saves to disk.
+ * @param args - The write retro arguments
+ * @param directory - Working directory
+ * @returns JSON string with success status and details
+ */
+export declare function executeWriteRetro(args: WriteRetroArgs, directory: string): Promise<string>;
+/**
+ * Tool definition for write_retro
+ */
+export declare const write_retro: ToolDefinition;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "6.18.0",
+	"version": "6.18.1",
 	"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",