feat: implement new agent flow (#43)

Author: kasin-it

docs/superpowers/plans/2026-04-06-three-phase-agent-workflow.md

@@ -9,12 +9,8 @@ vi.mock("workflow/api", () => ({
   getRun: (...args: any[]) => mockGetRun(...args),
 }));
 
-vi.mock("../workflows/implementation.js", () => ({
-  implementationWorkflow: "implementationWorkflow_sentinel",
-}));
-
-vi.mock("../workflows/review-fix.js", () => ({
-  reviewFixWorkflow: "reviewFixWorkflow_sentinel",
+vi.mock("../workflows/agent.js", () => ({
+  agentWorkflow: "agentWorkflow_sentinel",
 }));
 
 const mockSandboxList = vi.fn();
@@ -102,7 +98,7 @@ describe("dispatchTicket", () => {
     mockStart.mockResolvedValue({ runId: "run_123" });
   });
 
-  it("dispatches implementation workflow when no PR exists", async () => {
+  it("dispatches agentWorkflow for any ticket", async () => {
     const adapters = makeAdapters();
     const { dispatchTicket } = await import("./dispatch.js");
 
@@ -114,32 +110,8 @@ describe("dispatchTicket", () => {
       expect.stringMatching(/^claiming:\d+$/),
     );
     expect(adapters.issueTracker.fetchTicket).toHaveBeenCalledWith("PROJ-42");
-    expect(adapters.vcs.findPR).toHaveBeenCalledWith("blazebot/proj-42");
-    expect(mockStart).toHaveBeenCalledWith("implementationWorkflow_sentinel", [
-      "ticket-001",
-    ]);
-    expect(adapters.runRegistry.register).toHaveBeenCalledWith(
-      "PROJ-42",
-      "run_123",
-    );
-  });
-
-  it("dispatches review-fix workflow when PR exists", async () => {
-    const adapters = makeAdapters({
-      findPR: vi.fn().mockResolvedValue({
-        id: 7,
-        url: "https://github.com/pr/7",
-        branch: "blazebot/proj-42",
-      }),
-    });
-    const { dispatchTicket } = await import("./dispatch.js");
-
-    const result = await dispatchTicket("PROJ-42", adapters, 5);
-
-    expect(result).toEqual({ started: true, runId: "run_123" });
-    expect(mockStart).toHaveBeenCalledWith("reviewFixWorkflow_sentinel", [
+    expect(mockStart).toHaveBeenCalledWith("agentWorkflow_sentinel", [
       "ticket-001",
-      "blazebot/proj-42",
     ]);
     expect(adapters.runRegistry.register).toHaveBeenCalledWith(
       "PROJ-42",

docs/superpowers/specs/2026-04-06-three-phase-workflow-design.md

@@ -1,6 +1,5 @@
 import { start, getRun } from "workflow/api";
-import { implementationWorkflow } from "../workflows/implementation.js";
-import { reviewFixWorkflow } from "../workflows/review-fix.js";
+import { agentWorkflow } from "../workflows/agent.js";
 import { logger } from "./logger.js";
 import type { Adapters } from "./adapters.js";
 
@@ -25,7 +24,7 @@ export async function dispatchTicket(
   adapters: Adapters,
   maxConcurrentAgents: number,
 ): Promise<DispatchResult> {
-  const { issueTracker, vcs, runRegistry } = adapters;
+  const { issueTracker, runRegistry } = adapters;
 
   if (await runRegistry.isTicketFailed(ticketKey)) {
     logger.info({ ticketKey }, "dispatch_skipped_previously_failed");
@@ -45,9 +44,12 @@ export async function dispatchTicket(
 
   try {
     const ticket = await issueTracker.fetchTicket(ticketKey);
-    const branchName = `blazebot/${ticket.identifier.toLowerCase()}`;
 
-    const handle = await startWorkflow(ticket, branchName, vcs);
+    const handle = await start(agentWorkflow, [ticket.id]);
+    logger.info(
+      { ticketId: ticket.id, identifier: ticket.identifier, runId: handle.runId },
+      "workflow_started",
+    );
 
     const claimStillHeld = await verifyClaimNotCancelled(
       ticketKey,
@@ -90,26 +92,6 @@ async function getActiveSandboxCount(): Promise<number> {
   }
 }
 
-async function startWorkflow(
-  ticket: { id: string; identifier: string },
-  branchName: string,
-  vcs: Adapters["vcs"],
-) {
-  const existingPR = await vcs.findPR(branchName);
-
-  const handle = existingPR
-    ? await start(reviewFixWorkflow, [ticket.id, branchName])
-    : await start(implementationWorkflow, [ticket.id]);
-
-  const workflowType = existingPR ? "review_fix" : "implementation";
-  logger.info(
-    { ticketId: ticket.id, identifier: ticket.identifier, runId: handle.runId },
-    `workflow_started_${workflowType}`,
-  );
-
-  return handle;
-}
-
 async function verifyClaimNotCancelled(
   ticketKey: string,
   expectedClaimValue: string,

src/lib/dispatch.test.ts

@@ -3,6 +3,9 @@ import {
   parseAgentOutput,
   AGENT_SCHEMA,
   type AgentOutput,
+  parseResearchStatus,
+  parseReviewOutput,
+  REVIEW_SCHEMA,
 } from "./agent-runner.js";
 
 describe("parseAgentOutput", () => {
@@ -123,3 +126,97 @@ describe("AGENT_SCHEMA", () => {
     expect(() => JSON.parse(AGENT_SCHEMA)).not.toThrow();
   });
 });
+
+describe("parseResearchStatus", () => {
+  it("extracts completed status", () => {
+    const raw = "STATUS: completed\n\n# Implementation Plan\n1. Create foo.ts";
+    const { status, body } = parseResearchStatus(raw);
+    expect(status).toBe("completed");
+    expect(body).toContain("# Implementation Plan");
+  });
+
+  it("extracts clarification_needed status", () => {
+    const raw = "STATUS: clarification_needed\n\n1. What database?\n2. Which auth?";
+    const { status, body } = parseResearchStatus(raw);
+    expect(status).toBe("clarification_needed");
+    expect(body).toContain("What database?");
+  });
+
+  it("extracts failed status", () => {
+    const raw = "STATUS: failed\n\nCould not access repository";
+    const { status, body } = parseResearchStatus(raw);
+    expect(status).toBe("failed");
+  });
+
+  it("defaults to failed when no STATUS line", () => {
+    const raw = "Here is my analysis of the codebase...";
+    const { status, body } = parseResearchStatus(raw);
+    expect(status).toBe("failed");
+    expect(body).toContain("analysis");
+  });
+
+  it("handles STATUS line with extra whitespace", () => {
+    const raw = "  STATUS:   completed  \n\nPlan here";
+    const { status } = parseResearchStatus(raw);
+    expect(status).toBe("completed");
+  });
+});
+
+describe("parseReviewOutput", () => {
+  it("parses approved result", () => {
+    const raw = JSON.stringify({
+      result: "approved",
+      feedback: "Looks good",
+      issues: [],
+    });
+    const output = parseReviewOutput(raw);
+    expect(output.result).toBe("approved");
+    expect(output.feedback).toBe("Looks good");
+  });
+
+  it("parses changes_requested result with issues", () => {
+    const raw = JSON.stringify({
+      result: "changes_requested",
+      feedback: "Several issues found",
+      issues: [
+        { file: "src/foo.ts", description: "Missing null check", severity: "critical" },
+      ],
+    });
+    const output = parseReviewOutput(raw);
+    expect(output.result).toBe("changes_requested");
+    expect(output.issues).toHaveLength(1);
+    expect(output.issues[0].severity).toBe("critical");
+  });
+
+  it("returns failed on unparseable output", () => {
+    const output = parseReviewOutput("not json");
+    expect(output.result).toBe("failed");
+    expect(output.error).toBeDefined();
+  });
+
+  it("returns failed on empty output", () => {
+    const output = parseReviewOutput("");
+    expect(output.result).toBe("failed");
+  });
+
+  it("extracts from result envelope", () => {
+    const envelope = JSON.stringify({
+      type: "result",
+      subtype: "success",
+      is_error: false,
+      structured_output: {
+        result: "approved",
+        feedback: "All good",
+        issues: [],
+      },
+    });
+    const output = parseReviewOutput(envelope);
+    expect(output.result).toBe("approved");
+  });
+});
+
+describe("REVIEW_SCHEMA", () => {
+  it("is valid JSON", () => {
+    expect(() => JSON.parse(REVIEW_SCHEMA)).not.toThrow();
+  });
+});

src/lib/dispatch.ts

@@ -103,3 +103,111 @@ export function parseAgentOutput(raw: string): AgentOutput {
     error: `Agent output was not structured JSON. Output starts with: ${raw.slice(0, 500)}`,
   };
 }
+
+// --- Research Status Parser ---
+
+export type ResearchStatus = "completed" | "clarification_needed" | "failed";
+
+export interface ResearchResult {
+  status: ResearchStatus;
+  body: string;
+}
+
+const VALID_RESEARCH_STATUSES: ResearchStatus[] = ["completed", "clarification_needed", "failed"];
+
+export function parseResearchStatus(raw: string): ResearchResult {
+  const lines = raw.split("\n");
+  const firstLine = lines[0]?.trim() ?? "";
+  const match = firstLine.match(/^STATUS:\s*(\S+)/i);
+
+  if (match && VALID_RESEARCH_STATUSES.includes(match[1] as ResearchStatus)) {
+    const body = lines.slice(1).join("\n").trim();
+    return { status: match[1] as ResearchStatus, body };
+  }
+
+  return { status: "failed", body: raw };
+}
+
+// --- Review Output Schema ---
+
+const reviewOutputSchema = z.object({
+  result: z.enum(["approved", "changes_requested", "failed"]),
+  feedback: z.string(),
+  issues: z.array(z.object({
+    file: z.string(),
+    description: z.string(),
+    severity: z.enum(["critical", "suggestion"]),
+  })),
+  error: z.string().optional(),
+});
+
+export type ReviewOutput = z.infer<typeof reviewOutputSchema>;
+
+export const REVIEW_SCHEMA = JSON.stringify({
+  type: "object",
+  properties: {
+    result: {
+      type: "string",
+      enum: ["approved", "changes_requested", "failed"],
+    },
+    feedback: { type: "string" },
+    issues: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          file: { type: "string" },
+          description: { type: "string" },
+          severity: { type: "string", enum: ["critical", "suggestion"] },
+        },
+        required: ["file", "description", "severity"],
+      },
+    },
+    error: { type: "string" },
+  },
+  required: ["result", "feedback", "issues"],
+});
+
+export function parseReviewOutput(raw: string): ReviewOutput {
+  if (!raw.trim()) {
+    return { result: "failed", feedback: "", issues: [], error: "Review agent produced no output" };
+  }
+
+  // Direct parse
+  try {
+    const direct = reviewOutputSchema.safeParse(JSON.parse(raw));
+    if (direct.success) return direct.data;
+  } catch {}
+
+  // Stream-json / result-envelope format
+  const lines = raw.split("\n").filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    try {
+      const event = JSON.parse(lines[i]);
+
+      if (event.type === "result" && event.structured_output != null) {
+        const parsed = reviewOutputSchema.safeParse(event.structured_output);
+        if (parsed.success) return parsed.data;
+      }
+
+      const direct = reviewOutputSchema.safeParse(event);
+      if (direct.success) return direct.data;
+    } catch {}
+  }
+
+  // Fallback: extract JSON objects
+  const objects = raw.matchAll(/\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}/g);
+  for (const [candidate] of objects) {
+    try {
+      const result = reviewOutputSchema.safeParse(JSON.parse(candidate));
+      if (result.success) return result.data;
+    } catch {}
+  }
+
+  return {
+    result: "failed",
+    feedback: "",
+    issues: [],
+    error: `Review output was not structured JSON. Output starts with: ${raw.slice(0, 500)}`,
+  };
+}