opencode-swarm-plugin 0.33.0 → 0.35.0

package/src/swarm-prompts.ts

@@ -743,10 +743,32 @@ swarm_review_feedback(
 )
 \`\`\`
 
-### Step 5: ONLY THEN Continue
-- If approved: Close the cell, spawn next worker
-- If needs_changes: Worker gets feedback, retries (max 3 attempts)
-- If 3 failures: Mark blocked, escalate to human
+### Step 5: Take Action Based on Review
+
+**If APPROVED:**
+- Close the cell with hive_close
+- Spawn next worker (if any) using swarm_spawn_subtask
+
+**If NEEDS_CHANGES:**
+- Generate retry prompt:
+  \`\`\`
+  swarm_spawn_retry(
+    bead_id="{task_id}",
+    epic_id="{epic_id}",
+    original_prompt="<original prompt>",
+    attempt=<current_attempt>,
+    issues="<JSON from swarm_review_feedback>",
+    diff="<git diff of previous changes>",
+    files=[{files_touched}],
+    project_path="{project_key}"
+  )
+  \`\`\`
+- Spawn new worker with Task() using the retry prompt
+- Increment attempt counter (max 3 attempts)
+
+**If 3 FAILURES:**
+- Mark task as blocked: \`hive_update(id="{task_id}", status="blocked")\`
+- Escalate to human - likely an architectural problem, not execution issue
 
 **⚠️ DO NOT spawn the next worker until review is complete.**
 `;
@@ -1164,6 +1186,157 @@ export const swarm_spawn_researcher = tool({
   },
 });
 
+/**
+ * Generate retry prompt for a worker that needs to fix issues from review feedback
+ * 
+ * Coordinators use this when swarm_review_feedback returns "needs_changes".
+ * Creates a new worker spawn with context about what went wrong and what to fix.
+ */
+export const swarm_spawn_retry = tool({
+  description:
+    "Generate retry prompt for a worker that failed review. Includes issues from previous attempt, diff if provided, and standard worker contract.",
+  args: {
+    bead_id: tool.schema.string().describe("Original subtask bead ID"),
+    epic_id: tool.schema.string().describe("Parent epic bead ID"),
+    original_prompt: tool.schema.string().describe("The prompt given to failed worker"),
+    attempt: tool.schema.number().int().min(1).max(3).describe("Current attempt number (1, 2, or 3)"),
+    issues: tool.schema.string().describe("JSON array of ReviewIssue objects from swarm_review_feedback"),
+    diff: tool.schema
+      .string()
+      .optional()
+      .describe("Git diff of previous changes"),
+    files: tool.schema
+      .array(tool.schema.string())
+      .describe("Files to modify (from original subtask)"),
+    project_path: tool.schema
+      .string()
+      .optional()
+      .describe("Absolute project path for swarmmail_init"),
+  },
+  async execute(args) {
+    // Validate attempt number
+    if (args.attempt > 3) {
+      throw new Error(
+        `Retry attempt ${args.attempt} exceeds maximum of 3. After 3 failures, task should be marked blocked.`,
+      );
+    }
+
+    // Parse issues
+    let issuesArray: Array<{
+      file: string;
+      line: number;
+      issue: string;
+      suggestion: string;
+    }> = [];
+    try {
+      issuesArray = JSON.parse(args.issues);
+    } catch (e) {
+      // If issues is not valid JSON, treat as empty array
+      issuesArray = [];
+    }
+
+    // Format issues section
+    const issuesSection = issuesArray.length > 0
+      ? `## ISSUES FROM PREVIOUS ATTEMPT
+
+The previous attempt had the following issues that need to be fixed:
+
+${issuesArray
+  .map(
+    (issue, idx) =>
+      `**${idx + 1}. ${issue.file}:${issue.line}**
+   - **Issue**: ${issue.issue}
+   - **Suggestion**: ${issue.suggestion}`,
+  )
+  .join("\n\n")}
+
+**Critical**: Fix these issues while preserving any working changes from the previous attempt.`
+      : "";
+
+    // Format diff section
+    const diffSection = args.diff
+      ? `## PREVIOUS ATTEMPT
+
+Here's what was tried in the previous attempt:
+
+\`\`\`diff
+${args.diff}
+\`\`\`
+
+Review this carefully - some changes may be correct and should be preserved.`
+      : "";
+
+    // Build the retry prompt
+    const retryPrompt = `⚠️ **RETRY ATTEMPT ${args.attempt}/3**
+
+This is a retry of a previously attempted subtask. The coordinator reviewed the previous attempt and found issues that need to be fixed.
+
+${issuesSection}
+
+${diffSection}
+
+## ORIGINAL TASK
+
+${args.original_prompt}
+
+## YOUR MISSION
+
+1. **Understand what went wrong** - Read the issues carefully
+2. **Fix the specific problems** - Address each issue listed above
+3. **Preserve working code** - Don't throw away correct changes from previous attempt
+4. **Follow the standard worker contract** - See below
+
+## MANDATORY WORKER CONTRACT
+
+### Step 1: Initialize (REQUIRED FIRST)
+\`\`\`
+swarmmail_init(project_path="${args.project_path || "$PWD"}", task_description="${args.bead_id}: Retry ${args.attempt}/3")
+\`\`\`
+
+### Step 2: Reserve Files
+\`\`\`
+swarmmail_reserve(
+  paths=${JSON.stringify(args.files)},
+  reason="${args.bead_id}: Retry attempt ${args.attempt}",
+  exclusive=true
+)
+\`\`\`
+
+### Step 3: Fix the Issues
+- Address each issue listed above
+- Run tests to verify fixes
+- Don't introduce new bugs
+
+### Step 4: Complete
+\`\`\`
+swarm_complete(
+  project_key="${args.project_path || "$PWD"}",
+  agent_name="<your-agent-name>",
+  bead_id="${args.bead_id}",
+  summary="Fixed issues from review: <brief summary>",
+  files_touched=[<files you modified>]
+)
+\`\`\`
+
+**Remember**: This is attempt ${args.attempt} of 3. If this fails review again, there may be an architectural problem that needs human intervention.
+
+Begin work now.`;
+
+    return JSON.stringify(
+      {
+        prompt: retryPrompt,
+        bead_id: args.bead_id,
+        attempt: args.attempt,
+        max_attempts: 3,
+        files: args.files,
+        issues_count: issuesArray.length,
+      },
+      null,
+      2,
+    );
+  },
+});
+
 /**
  * Generate self-evaluation prompt
  */
@@ -1220,12 +1393,6 @@ export const swarm_plan_prompt = tool({
       .enum(["file-based", "feature-based", "risk-based", "auto"])
       .optional()
       .describe("Decomposition strategy (default: auto-detect)"),
-    max_subtasks: tool.schema
-      .number()
-      .int()
-      .min(1)
-      .optional()
-      .describe("Suggested max subtasks (optional - LLM decides if not specified)"),
     context: tool.schema
       .string()
       .optional()
@@ -1309,8 +1476,7 @@ export const swarm_plan_prompt = tool({
       .replace("{strategy_guidelines}", strategyGuidelines)
       .replace("{context_section}", contextSection)
       .replace("{cass_history}", "") // Empty for now
-      .replace("{skills_context}", skillsContext || "")
-      .replace("{max_subtasks}", (args.max_subtasks ?? 5).toString());
+      .replace("{skills_context}", skillsContext || "");
 
     return JSON.stringify(
       {
@@ -1353,6 +1519,7 @@ export const promptTools = {
   swarm_subtask_prompt,
   swarm_spawn_subtask,
   swarm_spawn_researcher,
+  swarm_spawn_retry,
   swarm_evaluation_prompt,
   swarm_plan_prompt,
 };

package/src/swarm-review.test.ts

@@ -700,3 +700,180 @@ describe("edge cases", () => {
     expect(prompt).toContain(longDiff);
   });
 });
+
+// ============================================================================
+// Coordinator-Driven Retry: swarm_review_feedback returns retry_context
+// ============================================================================
+
+describe("swarm_review_feedback retry_context", () => {
+  beforeEach(() => {
+    clearReviewStatus("bd-retry-test");
+    vi.clearAllMocks();
+  });
+
+  it("returns retry_context when status is needs_changes", async () => {
+    const issues = JSON.stringify([
+      { file: "src/auth.ts", line: 42, issue: "Missing null check", suggestion: "Add null check" }
+    ]);
+
+    const result = await swarm_review_feedback.execute(
+      {
+        project_key: "/tmp/test-project",
+        task_id: "bd-retry-test",
+        worker_id: "worker-test",
+        status: "needs_changes",
+        issues,
+      },
+      mockContext
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.success).toBe(true);
+    expect(parsed.status).toBe("needs_changes");
+    // NEW: Should include retry_context for coordinator
+    expect(parsed).toHaveProperty("retry_context");
+    expect(parsed.retry_context).toHaveProperty("task_id", "bd-retry-test");
+    expect(parsed.retry_context).toHaveProperty("attempt", 1);
+    expect(parsed.retry_context).toHaveProperty("issues");
+    expect(parsed.retry_context.issues).toHaveLength(1);
+  });
+
+  it("retry_context includes issues in structured format", async () => {
+    const issues = [
+      { file: "src/a.ts", line: 10, issue: "Bug A", suggestion: "Fix A" },
+      { file: "src/b.ts", line: 20, issue: "Bug B", suggestion: "Fix B" },
+    ];
+
+    const result = await swarm_review_feedback.execute(
+      {
+        project_key: "/tmp/test-project",
+        task_id: "bd-retry-test",
+        worker_id: "worker-test",
+        status: "needs_changes",
+        issues: JSON.stringify(issues),
+      },
+      mockContext
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.retry_context.issues).toEqual(issues);
+  });
+
+  it("retry_context includes next_action hint for coordinator", async () => {
+    const issues = JSON.stringify([{ file: "x.ts", issue: "bug" }]);
+
+    const result = await swarm_review_feedback.execute(
+      {
+        project_key: "/tmp/test-project",
+        task_id: "bd-retry-test",
+        worker_id: "worker-test",
+        status: "needs_changes",
+        issues,
+      },
+      mockContext
+    );
+
+    const parsed = JSON.parse(result);
+    // Should tell coordinator what to do next
+    expect(parsed.retry_context).toHaveProperty("next_action");
+    expect(parsed.retry_context.next_action).toContain("swarm_spawn_retry");
+  });
+
+  it("does NOT include retry_context when approved", async () => {
+    const result = await swarm_review_feedback.execute(
+      {
+        project_key: "/tmp/test-project",
+        task_id: "bd-retry-test",
+        worker_id: "worker-test",
+        status: "approved",
+        summary: "Looks good!",
+      },
+      mockContext
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.success).toBe(true);
+    expect(parsed.status).toBe("approved");
+    expect(parsed).not.toHaveProperty("retry_context");
+  });
+
+  it("does NOT include retry_context when task fails (3 attempts)", async () => {
+    const issues = JSON.stringify([{ file: "x.ts", issue: "still broken" }]);
+
+    // Exhaust all attempts
+    let result: string = "";
+    for (let i = 0; i < 3; i++) {
+      result = await swarm_review_feedback.execute(
+        {
+          project_key: "/tmp/test-project",
+          task_id: "bd-retry-test",
+          worker_id: "worker-test",
+          status: "needs_changes",
+          issues,
+        },
+        mockContext
+      );
+    }
+
+    const parsed = JSON.parse(result);
+    expect(parsed.task_failed).toBe(true);
+    // No retry_context when task is failed - nothing more to retry
+    expect(parsed).not.toHaveProperty("retry_context");
+  });
+
+  it("retry_context includes max_attempts for coordinator awareness", async () => {
+    const issues = JSON.stringify([{ file: "x.ts", issue: "bug" }]);
+
+    const result = await swarm_review_feedback.execute(
+      {
+        project_key: "/tmp/test-project",
+        task_id: "bd-retry-test",
+        worker_id: "worker-test",
+        status: "needs_changes",
+        issues,
+      },
+      mockContext
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.retry_context).toHaveProperty("max_attempts", 3);
+  });
+
+  it("does NOT send message to dead worker for needs_changes", async () => {
+    const { sendSwarmMessage } = await import("swarm-mail");
+    const issues = JSON.stringify([{ file: "x.ts", issue: "bug" }]);
+
+    await swarm_review_feedback.execute(
+      {
+        project_key: "/tmp/test-project",
+        task_id: "bd-retry-test",
+        worker_id: "worker-test",
+        status: "needs_changes",
+        issues,
+      },
+      mockContext
+    );
+
+    // Should NOT call sendSwarmMessage for needs_changes
+    // Workers are dead - they can't read messages
+    expect(sendSwarmMessage).not.toHaveBeenCalled();
+  });
+
+  it("DOES send message for approved status (audit trail)", async () => {
+    const { sendSwarmMessage } = await import("swarm-mail");
+
+    await swarm_review_feedback.execute(
+      {
+        project_key: "/tmp/test-project",
+        task_id: "bd-retry-test",
+        worker_id: "worker-test",
+        status: "approved",
+        summary: "Good work!",
+      },
+      mockContext
+    );
+
+    // Approved messages are still sent for audit trail
+    expect(sendSwarmMessage).toHaveBeenCalled();
+  });
+});

package/src/swarm-review.ts

@@ -551,23 +551,8 @@ You may now complete the task with \`swarm_complete\`.`,
         }
       }
 
-      // Send failure message
-      await sendSwarmMessage({
-        projectPath: args.project_key,
-        fromAgent: "coordinator",
-        toAgents: [args.worker_id],
-        subject: `FAILED: ${args.task_id} - max review attempts reached`,
-        body: `## Task Failed ✗
-
-Maximum review attempts (${MAX_REVIEW_ATTEMPTS}) reached.
-
-**Last Issues:**
-${parsedIssues.map((i: ReviewIssue) => `- ${i.file}${i.line ? `:${i.line}` : ""}: ${i.issue}`).join("\n")}
-
-The task has been marked as blocked. A human or different approach is needed.`,
-        threadId: epicId,
-        importance: "urgent",
-      });
+      // NO sendSwarmMessage - worker is dead, can't read it
+      // Coordinator handles retry or escalation
 
       return JSON.stringify(
         {
@@ -584,35 +569,8 @@ The task has been marked as blocked. A human or different approach is needed.`,
       );
     }
 
-    // Send feedback message
-    const issuesList = parsedIssues
-      .map((i: ReviewIssue) => {
-        let line = `- **${i.file}**`;
-        if (i.line) line += `:${i.line}`;
-        line += `: ${i.issue}`;
-        if (i.suggestion) line += `\n  → ${i.suggestion}`;
-        return line;
-      })
-      .join("\n");
-
-    await sendSwarmMessage({
-      projectPath: args.project_key,
-      fromAgent: "coordinator",
-      toAgents: [args.worker_id],
-      subject: `NEEDS CHANGES: ${args.task_id} (attempt ${attemptNumber}/${MAX_REVIEW_ATTEMPTS})`,
-      body: `## Review: Changes Needed
-
-${args.summary || "Please address the following issues:"}
-
-**Issues:**
-${issuesList}
-
-**Remaining attempts:** ${remaining}
-
-Please fix these issues and request another review.`,
-      threadId: epicId,
-      importance: "high",
-    });
+    // NO sendSwarmMessage for needs_changes - worker is dead
+    // Instead, return retry_context for coordinator to use with swarm_spawn_retry
 
     return JSON.stringify(
       {
@@ -622,7 +580,14 @@ Please fix these issues and request another review.`,
         attempt: attemptNumber,
         remaining_attempts: remaining,
         issues: parsedIssues,
-        message: `Feedback sent. ${remaining} attempt(s) remaining.`,
+        message: `Review feedback ready. ${remaining} attempt(s) remaining.`,
+        retry_context: {
+          task_id: args.task_id,
+          attempt: attemptNumber,
+          max_attempts: MAX_REVIEW_ATTEMPTS,
+          issues: parsedIssues,
+          next_action: "Use swarm_spawn_retry to spawn new worker with these issues",
+        },
       },
       null,
       2