@callumvass/forgeflow-dev 0.1.0

package/src/index.ts

@@ -0,0 +1,380 @@
+import { type AnyCtx, getFinalOutput, type PipelineDetails, type StageResult } from "@callumvass/forgeflow-shared";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Container, Markdown, Spacer, Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { runArchitecture } from "./pipelines/architecture.js";
+import { runDiscoverSkills } from "./pipelines/discover-skills.js";
+import { runImplement } from "./pipelines/implement.js";
+import { runImplementAll } from "./pipelines/implement-all.js";
+import { runReview } from "./pipelines/review.js";
+
+// ─── Display helpers ──────────────────────────────────────────────────
+
+type DisplayItem = { type: "text"; text: string } | { type: "toolCall"; name: string; args: Record<string, unknown> };
+
+interface ForgeflowDevInput {
+  pipeline: string;
+  issue?: string;
+  target?: string;
+  skipPlan?: boolean;
+  skipReview?: boolean;
+  customPrompt?: string;
+}
+
+function parseImplFlags(args: string) {
+  const skipPlan = args.includes("--skip-plan");
+  const skipReview = args.includes("--skip-review");
+  const rest = args
+    .replace(/--skip-plan/g, "")
+    .replace(/--skip-review/g, "")
+    .trim();
+
+  const firstSpace = rest.indexOf(" ");
+  const issue = firstSpace === -1 ? rest : rest.slice(0, firstSpace);
+  const customPrompt =
+    firstSpace === -1
+      ? ""
+      : rest
+          .slice(firstSpace + 1)
+          .trim()
+          .replace(/^"(.*)"$/, "$1");
+
+  const flags = [skipPlan ? ", skipPlan: true" : "", skipReview ? ", skipReview: true" : ""].join("");
+  return { issue, customPrompt, flags };
+}
+
+function parseReviewArgs(args: string) {
+  const trimmed = args.trim();
+  if (!trimmed) return { target: "", customPrompt: "" };
+
+  if (trimmed.startsWith("--branch")) {
+    const afterFlag = trimmed.replace(/^--branch\s*/, "").trim();
+    const firstSpace = afterFlag.indexOf(" ");
+    if (firstSpace === -1) return { target: `--branch ${afterFlag}`, customPrompt: "" };
+    return {
+      target: `--branch ${afterFlag.slice(0, firstSpace)}`,
+      customPrompt: afterFlag
+        .slice(firstSpace + 1)
+        .trim()
+        .replace(/^"(.*)"$/, "$1"),
+    };
+  }
+
+  const firstSpace = trimmed.indexOf(" ");
+  if (firstSpace === -1) return { target: trimmed, customPrompt: "" };
+  return {
+    target: trimmed.slice(0, firstSpace),
+    customPrompt: trimmed
+      .slice(firstSpace + 1)
+      .trim()
+      .replace(/^"(.*)"$/, "$1"),
+  };
+}
+
+function getDisplayItems(messages: AnyCtx[]): DisplayItem[] {
+  const items: DisplayItem[] = [];
+  for (const msg of messages) {
+    if (msg.role === "assistant") {
+      for (const part of msg.content) {
+        if (part.type === "text") items.push({ type: "text", text: part.text });
+        else if (part.type === "toolCall") items.push({ type: "toolCall", name: part.name, args: part.arguments });
+      }
+    }
+  }
+  return items;
+}
+
+function formatToolCallShort(
+  name: string,
+  args: Record<string, unknown>,
+  fg: (c: string, t: string) => string,
+): string {
+  switch (name) {
+    case "bash": {
+      const cmd = (args.command as string) || "...";
+      return fg("muted", "$ ") + fg("toolOutput", cmd.length > 60 ? `${cmd.slice(0, 60)}...` : cmd);
+    }
+    case "read":
+      return fg("muted", "read ") + fg("accent", (args.file_path || args.path || "...") as string);
+    case "write":
+      return fg("muted", "write ") + fg("accent", (args.file_path || args.path || "...") as string);
+    case "edit":
+      return fg("muted", "edit ") + fg("accent", (args.file_path || args.path || "...") as string);
+    case "grep":
+      return fg("muted", "grep ") + fg("accent", `/${args.pattern || ""}/`);
+    case "find":
+      return fg("muted", "find ") + fg("accent", (args.pattern || "*") as string);
+    default:
+      return fg("accent", name);
+  }
+}
+
+function formatUsage(usage: { input: number; output: number; cost: number; turns: number }, model?: string): string {
+  const parts: string[] = [];
+  if (usage.turns) parts.push(`${usage.turns}t`);
+  if (usage.input) parts.push(`↑${usage.input < 1000 ? usage.input : `${Math.round(usage.input / 1000)}k`}`);
+  if (usage.output) parts.push(`↓${usage.output < 1000 ? usage.output : `${Math.round(usage.output / 1000)}k`}`);
+  if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
+  if (model) parts.push(model);
+  return parts.join(" ");
+}
+
+// ─── Tool registration ────────────────────────────────────────────────
+
+const ForgeflowDevParams = Type.Object({
+  pipeline: Type.String({
+    description: 'Which pipeline to run: "implement", "implement-all", "review", "architecture", or "discover-skills"',
+  }),
+  issue: Type.Optional(
+    Type.String({
+      description: "Issue number or description for implement pipeline",
+    }),
+  ),
+  target: Type.Optional(Type.String({ description: "PR number or --branch for review pipeline" })),
+  skipPlan: Type.Optional(Type.Boolean({ description: "Skip planner, implement directly (default false)" })),
+  skipReview: Type.Optional(Type.Boolean({ description: "Skip code review after implementation (default false)" })),
+  customPrompt: Type.Optional(
+    Type.String({ description: "Additional user instructions passed to agents (e.g. 'check the openapi spec')" }),
+  ),
+});
+
+function registerForgeflowDevTool(pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "forgeflow-dev",
+    label: "Forgeflow Dev",
+    description: [
+      "Run forgeflow dev pipelines: implement (plan→TDD→refactor a single issue),",
+      "implement-all (loop through all open issues autonomously), review (deterministic checks→code review→judge),",
+      "architecture (analyze codebase for structural friction→create RFC issues),",
+      "discover-skills (find and install domain-specific plugins).",
+      "Each pipeline spawns specialized sub-agents with isolated context.",
+    ].join(" "),
+    parameters: ForgeflowDevParams as AnyCtx,
+
+    async execute(
+      _toolCallId: string,
+      _params: unknown,
+      signal: AbortSignal | undefined,
+      onUpdate: AnyCtx,
+      ctx: AnyCtx,
+    ) {
+      const params = _params as ForgeflowDevInput;
+      const cwd = ctx.cwd as string;
+      const sig = signal ?? new AbortController().signal;
+
+      try {
+        switch (params.pipeline) {
+          case "implement":
+            return await runImplement(cwd, params.issue ?? "", sig, onUpdate, ctx, {
+              skipPlan: params.skipPlan ?? false,
+              skipReview: params.skipReview ?? false,
+              customPrompt: params.customPrompt,
+            });
+          case "implement-all":
+            return await runImplementAll(cwd, sig, onUpdate, ctx, {
+              skipPlan: params.skipPlan ?? false,
+              skipReview: params.skipReview ?? false,
+            });
+          case "review":
+            return await runReview(cwd, params.target ?? "", sig, onUpdate, ctx, params.customPrompt);
+          case "architecture":
+            return await runArchitecture(cwd, sig, onUpdate, ctx);
+          case "discover-skills":
+            return await runDiscoverSkills(cwd, params.issue ?? "", sig, onUpdate, ctx);
+          default:
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Unknown pipeline: ${params.pipeline}. Use: implement, implement-all, review, architecture, discover-skills`,
+                },
+              ],
+              details: { pipeline: params.pipeline, stages: [] } as PipelineDetails,
+            };
+        }
+      } finally {
+        if (ctx.hasUI) {
+          ctx.ui.setStatus("forgeflow-dev", undefined);
+          ctx.ui.setWidget("forgeflow-dev", undefined);
+        }
+      }
+    },
+
+    renderCall(_args: unknown, theme: AnyCtx) {
+      const args = _args as ForgeflowDevInput;
+      const pipeline = args.pipeline || "?";
+      let text = theme.fg("toolTitle", theme.bold("forgeflow-dev ")) + theme.fg("accent", pipeline);
+      if (args.issue) {
+        const prefix = /^[A-Z]+-\d+$/.test(args.issue) ? " " : " #";
+        text += theme.fg("dim", `${prefix}${args.issue}`);
+      }
+      if (args.target) text += theme.fg("dim", ` ${args.target}`);
+      return new Text(text, 0, 0);
+    },
+
+    renderResult(result: AnyCtx, { expanded }: { expanded: boolean }, theme: AnyCtx) {
+      const details = result.details as PipelineDetails | undefined;
+      if (!details || details.stages.length === 0) {
+        const text = result.content[0];
+        return new Text(text?.type === "text" ? text.text : "(no output)", 0, 0);
+      }
+
+      if (expanded) {
+        return renderExpanded(details, theme);
+      }
+      return renderCollapsed(details, theme);
+    },
+  });
+}
+
+// ─── Rendering ────────────────────────────────────────────────────────
+
+function renderExpanded(details: PipelineDetails, theme: AnyCtx) {
+  const container = new Container();
+  container.addChild(
+    new Text(theme.fg("toolTitle", theme.bold("forgeflow-dev ")) + theme.fg("accent", details.pipeline), 0, 0),
+  );
+  container.addChild(new Spacer(1));
+
+  for (const stage of details.stages) {
+    const icon = stageIcon(stage, theme);
+    container.addChild(new Text(`${icon} ${theme.fg("toolTitle", theme.bold(stage.name))}`, 0, 0));
+
+    const items = getDisplayItems(stage.messages);
+    for (const item of items) {
+      if (item.type === "toolCall") {
+        container.addChild(
+          new Text(
+            `  ${theme.fg("muted", "→ ")}${formatToolCallShort(item.name, item.args, theme.fg.bind(theme))}`,
+            0,
+            0,
+          ),
+        );
+      }
+    }
+
+    const output = getFinalOutput(stage.messages);
+    if (output) {
+      container.addChild(new Spacer(1));
+      try {
+        const { getMarkdownTheme } = require("@mariozechner/pi-coding-agent");
+        container.addChild(new Markdown(output.trim(), 0, 0, getMarkdownTheme()));
+      } catch {
+        container.addChild(new Text(theme.fg("toolOutput", output.slice(0, 500)), 0, 0));
+      }
+    }
+
+    const usageStr = formatUsage(stage.usage, stage.model);
+    if (usageStr) container.addChild(new Text(theme.fg("dim", usageStr), 0, 0));
+    container.addChild(new Spacer(1));
+  }
+
+  return container;
+}
+
+function renderCollapsed(details: PipelineDetails, theme: AnyCtx) {
+  let text = theme.fg("toolTitle", theme.bold("forgeflow-dev ")) + theme.fg("accent", details.pipeline);
+  for (const stage of details.stages) {
+    const icon = stageIcon(stage, theme);
+    text += `\n  ${icon} ${theme.fg("toolTitle", stage.name)}`;
+
+    if (stage.status === "running") {
+      const items = getDisplayItems(stage.messages);
+      const last = items.filter((i) => i.type === "toolCall").slice(-3);
+      for (const item of last) {
+        if (item.type === "toolCall") {
+          text += `\n    ${theme.fg("muted", "→ ")}${formatToolCallShort(item.name, item.args, theme.fg.bind(theme))}`;
+        }
+      }
+    } else if (stage.status === "done" || stage.status === "failed") {
+      const preview = stage.output.split("\n")[0]?.slice(0, 80) || "(no output)";
+      text += theme.fg("dim", ` ${preview}`);
+      const usageStr = formatUsage(stage.usage, stage.model);
+      if (usageStr) text += ` ${theme.fg("dim", usageStr)}`;
+    }
+  }
+  return new Text(text, 0, 0);
+}
+
+function stageIcon(stage: StageResult, theme: AnyCtx): string {
+  return stage.status === "done"
+    ? theme.fg("success", "✓")
+    : stage.status === "running"
+      ? theme.fg("warning", "⟳")
+      : stage.status === "failed"
+        ? theme.fg("error", "✗")
+        : theme.fg("muted", "○");
+}
+
+// ─── Extension entry point ────────────────────────────────────────────
+
+const extension: (pi: ExtensionAPI) => void = (pi) => {
+  registerForgeflowDevTool(pi);
+
+  pi.registerCommand("implement", {
+    description:
+      "Implement a single issue using TDD. Usage: /implement <issue#|JIRA-KEY> [custom prompt] [--skip-plan] [--skip-review]",
+    handler: async (args) => {
+      const { issue, customPrompt, flags } = parseImplFlags(args);
+      const promptPart = customPrompt ? `, customPrompt: "${customPrompt}"` : "";
+
+      if (issue) {
+        pi.sendUserMessage(
+          `Call the forgeflow-dev tool now with these exact parameters: pipeline="implement", issue="${issue}"${promptPart}${flags}. Do not interpret the issue number — pass it as-is.`,
+        );
+      } else {
+        pi.sendUserMessage(
+          `Call the forgeflow-dev tool now with these exact parameters: pipeline="implement"${promptPart}${flags}. No issue number provided — the tool will detect it from the current branch. Do NOT ask for an issue number.`,
+        );
+      }
+    },
+  });
+
+  pi.registerCommand("implement-all", {
+    description:
+      "Loop through all open auto-generated issues: implement, review, merge. Flags: --skip-plan, --skip-review",
+    handler: async (args) => {
+      const { flags } = parseImplFlags(args);
+
+      pi.sendUserMessage(
+        `Call the forgeflow-dev tool now with these exact parameters: pipeline="implement-all"${flags}. Do NOT ask for confirmation — run autonomously.`,
+      );
+    },
+  });
+
+  pi.registerCommand("review", {
+    description: "Run code review: deterministic checks → reviewer → judge. Usage: /review [target] [custom prompt]",
+    handler: async (args) => {
+      const { target, customPrompt } = parseReviewArgs(args);
+      const promptPart = customPrompt ? `, customPrompt: "${customPrompt}"` : "";
+      pi.sendUserMessage(
+        `Call the forgeflow-dev tool now with these exact parameters: pipeline="review"${target ? `, target="${target}"` : ""}${promptPart}. Do not interpret the target — pass it as-is.`,
+      );
+    },
+  });
+
+  pi.registerCommand("architecture", {
+    description: "Analyze codebase for architectural friction and create RFC issues",
+    handler: async () => {
+      pi.sendUserMessage(`Call the forgeflow-dev tool now with these exact parameters: pipeline="architecture".`);
+    },
+  });
+
+  pi.registerCommand("discover-skills", {
+    description: "Find and install domain-specific plugins from skills.sh for this project's tech stack",
+    handler: async (args) => {
+      const query = args.trim();
+      if (query) {
+        pi.sendUserMessage(
+          `Call the forgeflow-dev tool now with these exact parameters: pipeline="discover-skills", issue="${query}". Present the tool's output verbatim — do not summarize or reformat it.`,
+        );
+      } else {
+        pi.sendUserMessage(
+          `Call the forgeflow-dev tool now with these exact parameters: pipeline="discover-skills". Present the tool's output verbatim — do not summarize or reformat it.`,
+        );
+      }
+    },
+  });
+};
+
+export default extension;

package/src/pipelines/architecture.ts

@@ -0,0 +1,67 @@
+import { type AnyCtx, emptyStage, runAgent, TOOLS_READONLY } from "@callumvass/forgeflow-shared";
+import { AGENTS_DIR } from "../resolve.js";
+
+export async function runArchitecture(cwd: string, signal: AbortSignal, onUpdate: AnyCtx, ctx: AnyCtx) {
+  const stages = [emptyStage("architecture-reviewer")];
+  const opts = { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline: "architecture", onUpdate };
+
+  // Phase 1: Explore codebase for friction
+  const exploreResult = await runAgent(
+    "architecture-reviewer",
+    "Explore this codebase and identify architectural friction. Present numbered candidates ranked by severity.",
+    { ...opts, tools: TOOLS_READONLY },
+  );
+
+  if (exploreResult.status === "failed") {
+    return {
+      content: [{ type: "text" as const, text: `Exploration failed: ${exploreResult.output}` }],
+      details: { pipeline: "architecture", stages },
+      isError: true,
+    };
+  }
+
+  // Non-interactive: return candidates
+  if (!ctx.hasUI) {
+    return {
+      content: [{ type: "text" as const, text: exploreResult.output }],
+      details: { pipeline: "architecture", stages },
+    };
+  }
+
+  // Interactive gate: user reviews candidates, can edit/annotate
+  const edited = await ctx.ui.editor(
+    "Review architecture candidates (edit to highlight your pick)",
+    exploreResult.output,
+  );
+  const action = await ctx.ui.select("Create RFC issue for a candidate?", ["Yes — generate RFC", "Skip"]);
+
+  if (action === "Skip" || action == null) {
+    return {
+      content: [{ type: "text" as const, text: "Architecture review complete. No RFC created." }],
+      details: { pipeline: "architecture", stages },
+    };
+  }
+
+  // Phase 2: Generate RFC and create GitHub issue
+  stages.push(emptyStage("architecture-rfc"));
+  const candidateContext = edited ?? exploreResult.output;
+
+  const rfcResult = await runAgent(
+    "architecture-reviewer",
+    `Based on the following architectural analysis, generate a detailed RFC and create a GitHub issue (with label "architecture") for the highest-priority candidate — or the one the user highlighted/edited.\n\nANALYSIS:\n${candidateContext}`,
+    { ...opts, tools: TOOLS_READONLY },
+  );
+
+  // Extract issue URL/number from agent output
+  const issueMatch = rfcResult.output?.match(/https:\/\/github\.com\/[^\s]+\/issues\/(\d+)/);
+  const issueNum = issueMatch?.[1];
+  const issueUrl = issueMatch?.[0];
+  const summary = issueUrl
+    ? `Architecture RFC issue created: ${issueUrl}\n\nRun \`/implement ${issueNum}\` to implement it.`
+    : "Architecture RFC issue created.";
+
+  return {
+    content: [{ type: "text" as const, text: summary }],
+    details: { pipeline: "architecture", stages },
+  };
+}

package/src/pipelines/discover-skills.ts

@@ -0,0 +1,33 @@
+import { type AnyCtx, emptyStage, runAgent, TOOLS_ALL, TOOLS_NO_EDIT } from "@callumvass/forgeflow-shared";
+import { AGENTS_DIR } from "../resolve.js";
+
+export async function runDiscoverSkills(
+  cwd: string,
+  query: string,
+  signal: AbortSignal,
+  onUpdate: AnyCtx,
+  _ctx: AnyCtx,
+) {
+  // If query looks like specific skill names (contains commas or known skill identifiers),
+  // treat as install mode. Otherwise, discover mode.
+  const isInstall = query.includes(",") || query.includes("/");
+
+  const stages = [emptyStage("skill-discoverer")];
+  const opts = { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline: "discover-skills", onUpdate };
+
+  const task = isInstall
+    ? `Install these skills as forgeflow plugins: ${query}`
+    : query
+      ? `Discover skills related to "${query}" — recommend only, do NOT install.`
+      : "Analyze the project tech stack and discover relevant skills — recommend only, do NOT install.";
+
+  // Install mode needs write access, discover mode is read-only
+  const tools = isInstall ? TOOLS_ALL : TOOLS_NO_EDIT;
+
+  const result = await runAgent("skill-discoverer", task, { ...opts, tools });
+
+  return {
+    content: [{ type: "text" as const, text: result.output || "No skills found." }],
+    details: { pipeline: "discover-skills", stages },
+  };
+}

package/src/pipelines/implement-all.ts

@@ -0,0 +1,181 @@
+import { type AnyCtx, emptyStage, type StageResult, sumUsage } from "@callumvass/forgeflow-shared";
+import { exec } from "../utils/exec.js";
+import { setForgeflowStatus, updateProgressWidget } from "../utils/ui.js";
+import { runImplement } from "./implement.js";
+
+interface IssueInfo {
+  number: number;
+  title: string;
+  body: string;
+}
+
+/**
+ * Get issue numbers whose dependencies (referenced as #N in ## Dependencies section) are satisfied.
+ */
+function getReadyIssues(issues: IssueInfo[], completed: Set<number>): number[] {
+  return issues
+    .filter((issue) => {
+      if (completed.has(issue.number)) return false;
+      const parts = issue.body.split("## Dependencies");
+      if (parts.length < 2) return true;
+      const depSection = parts[1]?.split("\n## ")[0] ?? "";
+      const deps = [...depSection.matchAll(/#(\d+)/g)].map((m) => parseInt(m[1] ?? "0", 10));
+      return deps.every((d) => completed.has(d));
+    })
+    .map((i) => i.number);
+}
+
+export async function runImplementAll(
+  cwd: string,
+  signal: AbortSignal,
+  onUpdate: AnyCtx,
+  ctx: AnyCtx,
+  flags: { skipPlan: boolean; skipReview: boolean },
+) {
+  const allStages: StageResult[] = [];
+  const issueProgress = new Map<number, { title: string; status: "pending" | "running" | "done" | "failed" }>();
+
+  // Seed completed set with already-closed issues
+  const closedJson = await exec(
+    `gh issue list --state closed --label "auto-generated" --json number --jq '.[].number'`,
+    cwd,
+  );
+  const completed = new Set<number>(closedJson ? closedJson.split("\n").filter(Boolean).map(Number) : []);
+
+  let iteration = 0;
+  const maxIterations = 50;
+
+  while (iteration++ < maxIterations) {
+    if (signal.aborted) break;
+
+    // Return to main and pull
+    await exec("git checkout main && git pull --rebase", cwd);
+
+    // Fetch open issues
+    const issuesJson = await exec(
+      `gh issue list --state open --label "auto-generated" --json number,title,body --jq 'sort_by(.number)'`,
+      cwd,
+    );
+    let issues: IssueInfo[];
+    try {
+      issues = JSON.parse(issuesJson || "[]");
+    } catch {
+      issues = [];
+    }
+
+    if (issues.length === 0) {
+      return {
+        content: [{ type: "text" as const, text: "All issues implemented." }],
+        details: { pipeline: "implement-all", stages: allStages },
+      };
+    }
+
+    // Track all known issues in progress widget
+    for (const issue of issues) {
+      if (!issueProgress.has(issue.number)) {
+        issueProgress.set(issue.number, { title: issue.title, status: "pending" });
+      }
+    }
+
+    // Find ready issues (deps satisfied)
+    const ready = getReadyIssues(issues, completed);
+    if (ready.length === 0) {
+      return {
+        content: [
+          { type: "text" as const, text: `${issues.length} issues remain but all have unresolved dependencies.` },
+        ],
+        details: { pipeline: "implement-all", stages: allStages },
+        isError: true,
+      };
+    }
+
+    // biome-ignore lint/style/noNonNullAssertion: ready is non-empty (checked above)
+    const issueNum = ready[0]!;
+    const issueTitle = issues.find((i) => i.number === issueNum)?.title ?? `#${issueNum}`;
+
+    // Update status + widget
+    issueProgress.set(issueNum, { title: issueTitle, status: "running" });
+    setForgeflowStatus(
+      ctx,
+      `implement-all · ${completed.size}/${completed.size + issues.length} · #${issueNum} ${issueTitle}`,
+    );
+    updateProgressWidget(ctx, issueProgress, sumUsage(allStages).cost);
+
+    // Run implement for this issue
+    allStages.push(emptyStage(`implement-${issueNum}`));
+    const implResult = await runImplement(cwd, String(issueNum), signal, onUpdate, ctx, {
+      ...flags,
+      autonomous: true,
+    });
+
+    // Accumulate usage from detailed stages into the container stage
+    const implStage = allStages.find((s) => s.name === `implement-${issueNum}`);
+    if (implStage) {
+      implStage.status = implResult.isError ? "failed" : "done";
+      implStage.output = implResult.content[0]?.type === "text" ? implResult.content[0].text : "";
+      const detailedStages = (implResult as AnyCtx).details?.stages as StageResult[] | undefined;
+      if (detailedStages) implStage.usage = sumUsage(detailedStages);
+    }
+
+    if (implResult.isError) {
+      issueProgress.set(issueNum, { title: issueTitle, status: "failed" });
+      updateProgressWidget(ctx, issueProgress, sumUsage(allStages).cost);
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Failed on issue #${issueNum}: ${implResult.content[0]?.type === "text" ? implResult.content[0].text : "unknown error"}`,
+          },
+        ],
+        details: { pipeline: "implement-all", stages: allStages },
+        isError: true,
+      };
+    }
+
+    // Check for PR and merge
+    const branch = `feat/issue-${issueNum}`;
+    await exec("git checkout main && git pull --rebase", cwd);
+    const prNum = await exec(`gh pr list --head "${branch}" --json number --jq '.[0].number'`, cwd);
+
+    if (prNum && prNum !== "null") {
+      const mergeResult = await exec(`gh pr merge ${prNum} --squash --delete-branch`, cwd);
+      if (mergeResult.includes("Merged") || mergeResult === "") {
+        completed.add(issueNum);
+      } else {
+        const prState = await exec(`gh pr view ${prNum} --json state --jq '.state'`, cwd);
+        if (prState === "MERGED") {
+          completed.add(issueNum);
+        } else {
+          issueProgress.set(issueNum, { title: issueTitle, status: "failed" });
+          updateProgressWidget(ctx, issueProgress, sumUsage(allStages).cost);
+          return {
+            content: [{ type: "text" as const, text: `Failed to merge PR #${prNum} for issue #${issueNum}.` }],
+            details: { pipeline: "implement-all", stages: allStages },
+            isError: true,
+          };
+        }
+      }
+    } else {
+      issueProgress.set(issueNum, { title: issueTitle, status: "failed" });
+      updateProgressWidget(ctx, issueProgress, sumUsage(allStages).cost);
+      return {
+        content: [{ type: "text" as const, text: `No PR found for issue #${issueNum} after implementation.` }],
+        details: { pipeline: "implement-all", stages: allStages },
+        isError: true,
+      };
+    }
+
+    // Mark done and update widget
+    issueProgress.set(issueNum, { title: issueTitle, status: "done" });
+    setForgeflowStatus(
+      ctx,
+      `implement-all · ${completed.size}/${completed.size + issues.length - 1} · $${sumUsage(allStages).cost.toFixed(2)}`,
+    );
+    updateProgressWidget(ctx, issueProgress, sumUsage(allStages).cost);
+  }
+
+  return {
+    content: [{ type: "text" as const, text: `Reached max iterations (${maxIterations}).` }],
+    details: { pipeline: "implement-all", stages: allStages },
+  };
+}