@callumvass/forgeflow-dev 0.4.4 → 0.6.0

package/agents/implementor.md

@@ -103,6 +103,10 @@ PRBODY
 gh pr create --title "My title" --body-file /tmp/pr-body.md
 ```
 
+## Commit Style
+
+Use [Conventional Commits](https://www.conventionalcommits.org/). Read `git log --oneline -10` before your first commit to match the repo's existing style. Common prefixes: `feat:`, `fix:`, `test:`, `refactor:`, `chore:`, `docs:`. Keep messages concise (under 72 chars).
+
 ## Before Committing
 
 - **Reachability check**: Every new module, class, or function you created must be imported and called from production code — not just from tests. Trace from the entry point to your new code.

package/agents/refactorer.md

@@ -37,3 +37,4 @@ You are a refactorer agent. You run after a feature has been implemented to find
 - **Keep it small**: Each refactoring should be a single, focused change.
 - **If nothing to do, say so**: "No refactoring needed" is a perfectly valid outcome.
 - **Preserve public interfaces**: Don't rename or restructure exports without updating all callers.
+- **Commit style**: Use [Conventional Commits](https://www.conventionalcommits.org/). Read `git log --oneline -10` before committing to match the repo's style. Use `refactor:` prefix.

package/extensions/index.js

@@ -5,8 +5,40 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// ../shared/dist/confluence.js
+// ../shared/dist/exec.js
 import { spawn } from "child_process";
+function exec(cmd, cwd) {
+  return new Promise((resolve2, reject) => {
+    const proc = spawn("bash", ["-c", cmd], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (d) => {
+      stdout += d.toString();
+    });
+    proc.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`Command failed (exit ${code}): ${cmd}
+${stderr.trim()}`));
+      } else {
+        resolve2(stdout.trim());
+      }
+    });
+    proc.on("error", (err) => reject(err));
+  });
+}
+async function execSafe(cmd, cwd) {
+  try {
+    return await exec(cmd, cwd);
+  } catch {
+    return "";
+  }
+}
 
 // ../shared/dist/constants.js
 var TOOLS_ALL = ["read", "write", "edit", "bash", "grep", "find"];
@@ -18,12 +50,8 @@ var SIGNALS = {
   blocked: "BLOCKED.md"
 };
 
-// ../shared/dist/run-agent.js
-import { spawn as spawn2 } from "child_process";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { withFileMutationQueue } from "@mariozechner/pi-coding-agent";
+// ../shared/dist/rendering.js
+import { Container, Markdown, Spacer, Text } from "@mariozechner/pi-tui";
 
 // ../shared/dist/types.js
 function emptyUsage() {
@@ -66,7 +94,131 @@ function sumUsage(stages) {
   return total;
 }
 
+// ../shared/dist/rendering.js
+function getDisplayItems(messages) {
+  const items = [];
+  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, args, fg) {
+  switch (name) {
+    case "bash": {
+      const cmd = args.command || "...";
+      return fg("muted", "$ ") + fg("toolOutput", cmd.length > 60 ? `${cmd.slice(0, 60)}...` : cmd);
+    }
+    case "read":
+    case "write":
+    case "edit":
+      return fg("muted", `${name} `) + fg("accent", args.file_path || args.path || "...");
+    case "grep":
+      return fg("muted", "grep ") + fg("accent", `/${args.pattern || ""}/`);
+    case "find":
+      return fg("muted", "find ") + fg("accent", args.pattern || "*");
+    default:
+      return fg("accent", name);
+  }
+}
+function formatUsage(usage, model) {
+  const parts = [];
+  if (usage.turns)
+    parts.push(`${usage.turns}t`);
+  if (usage.input)
+    parts.push(`\u2191${usage.input < 1e3 ? usage.input : `${Math.round(usage.input / 1e3)}k`}`);
+  if (usage.output)
+    parts.push(`\u2193${usage.output < 1e3 ? usage.output : `${Math.round(usage.output / 1e3)}k`}`);
+  if (usage.cost)
+    parts.push(`$${usage.cost.toFixed(4)}`);
+  if (model)
+    parts.push(model);
+  return parts.join(" ");
+}
+function stageIcon(stage, theme) {
+  return stage.status === "done" ? theme.fg("success", "\u2713") : stage.status === "running" ? theme.fg("warning", "\u27F3") : stage.status === "failed" ? theme.fg("error", "\u2717") : theme.fg("muted", "\u25CB");
+}
+function renderExpanded(details, theme, toolLabel) {
+  const container = new Container();
+  container.addChild(new Text(theme.fg("toolTitle", theme.bold(`${toolLabel} `)) + 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", "\u2192 ")}${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 renderResult(result2, expanded, theme, toolLabel) {
+  const details = result2.details;
+  if (!details || details.stages.length === 0) {
+    const text = result2.content[0];
+    return new Text(text?.type === "text" ? text.text : "(no output)", 0, 0);
+  }
+  return expanded ? renderExpanded(details, theme, toolLabel) : renderCollapsed(details, theme, toolLabel);
+}
+function renderCollapsed(details, theme, toolLabel) {
+  let text = theme.fg("toolTitle", theme.bold(`${toolLabel} `)) + theme.fg("accent", details.pipeline);
+  for (const stage of details.stages) {
+    const icon = stageIcon(stage, theme);
+    text += `
+  ${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 += `
+    ${theme.fg("muted", "\u2192 ")}${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);
+}
+
 // ../shared/dist/run-agent.js
+import { spawn as spawn2 } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { withFileMutationQueue } from "@mariozechner/pi-coding-agent";
+async function resolveRunAgent(injected) {
+  if (injected)
+    return injected;
+  return runAgent;
+}
 function getPiInvocation(args) {
   const currentScript = process.argv[1];
   if (currentScript && fs.existsSync(currentScript)) {
@@ -213,9 +365,8 @@ function getLastToolCall(messages) {
   for (let i = messages.length - 1; i >= 0; i--) {
     const msg = messages[i];
     if (msg.role === "assistant") {
-      const parts = msg.content;
-      for (let j = parts.length - 1; j >= 0; j--) {
-        const part = parts[j];
+      for (let j = msg.content.length - 1; j >= 0; j--) {
+        const part = msg.content[j];
         if (part?.type === "toolCall") {
           const name = part.name;
           const args = part.arguments ?? {};
@@ -283,7 +434,7 @@ function cleanSignal(cwd, signal) {
 }
 
 // src/index.ts
-import { Container, Markdown, Spacer, Text } from "@mariozechner/pi-tui";
+import { Text as Text2 } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
 
 // src/resolve.ts
@@ -293,6 +444,22 @@ var __dirname = path3.dirname(fileURLToPath(import.meta.url));
 var AGENTS_DIR = path3.resolve(__dirname, "..", "agents");
 
 // src/pipelines/architecture.ts
+function parseCandidates(text) {
+  const pattern = /^(?:#{1,4}\s+)?(\d+)\.\s+(.+)$/gm;
+  const matches = [...text.matchAll(pattern)];
+  if (matches.length === 0) return [];
+  const results = [];
+  for (let i = 0; i < matches.length; i++) {
+    const match = matches[i];
+    const num = match[1];
+    const name = match[2].replace(/[*#]+/g, "").trim();
+    const start = match.index;
+    const end = i + 1 < matches.length ? matches[i + 1].index : text.length;
+    const body = text.slice(start, end).trim();
+    results.push({ label: `${num}. ${name}`, body });
+  }
+  return results;
+}
 async function runArchitecture(cwd, signal, onUpdate, ctx) {
   const stages = [emptyStage("architecture-reviewer")];
   const opts = { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline: "architecture", onUpdate };
@@ -318,29 +485,52 @@ async function runArchitecture(cwd, signal, onUpdate, ctx) {
     "Review architecture candidates (edit to highlight your pick)",
     exploreResult.output
   );
-  const action = await ctx.ui.select("Create RFC issue for a candidate?", ["Yes \u2014 generate RFC", "Skip"]);
+  const candidateContext = edited ?? exploreResult.output;
+  const candidates = parseCandidates(candidateContext);
+  const selectOptions = candidates.length > 1 ? [...candidates.map((c) => c.label), "All candidates", "Skip"] : candidates.length === 1 ? [candidates[0].label, "Skip"] : ["Yes \u2014 generate RFC", "Skip"];
+  const action = await ctx.ui.select("Create RFC issues for which candidates?", selectOptions);
   if (action === "Skip" || action == null) {
     return {
       content: [{ type: "text", text: "Architecture review complete. No RFC created." }],
       details: { pipeline: "architecture", stages }
     };
   }
-  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 \u2014 or the one the user highlighted/edited.
+  let selectedCandidates;
+  if (action === "All candidates") {
+    selectedCandidates = candidates;
+  } else if (action === "Yes \u2014 generate RFC") {
+    selectedCandidates = [{ label: "RFC", body: candidateContext }];
+  } else {
+    const match = candidates.find((c) => c.label === action);
+    selectedCandidates = match ? [match] : [{ label: "RFC", body: candidateContext }];
+  }
+  const createdIssues = [];
+  for (const candidate of selectedCandidates) {
+    const stageName = `architecture-rfc-${selectedCandidates.indexOf(candidate) + 1}`;
+    stages.push(emptyStage(stageName));
+    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 this specific candidate.
 
-ANALYSIS:
-${candidateContext}`,
-    { ...opts, tools: TOOLS_READONLY }
-  );
-  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}
+CANDIDATE:
+${candidate.body}
 
-Run \`/implement ${issueNum}\` to implement it.` : "Architecture RFC issue created.";
+FULL ANALYSIS (for context):
+${candidateContext}`,
+      { ...opts, stageName, tools: TOOLS_READONLY }
+    );
+    const issueMatch = rfcResult.output?.match(/https:\/\/github\.com\/[^\s]+\/issues\/(\d+)/);
+    const issueUrl = issueMatch?.[0];
+    const issueNum = issueMatch?.[1];
+    if (issueUrl) {
+      createdIssues.push(`- ${issueUrl} \u2014 run \`/implement ${issueNum}\` to implement`);
+    } else {
+      createdIssues.push(`- ${candidate.label}: RFC created (no issue URL found in output)`);
+    }
+  }
+  const summary = createdIssues.length === 1 ? `Architecture RFC issue created:
+${createdIssues[0]}` : `Architecture RFC issues created (${createdIssues.length}):
+${createdIssues.join("\n")}`;
   return {
     content: [{ type: "text", text: summary }],
     details: { pipeline: "architecture", stages }
@@ -354,31 +544,91 @@ async function runDiscoverSkills(cwd, query, signal, onUpdate, _ctx) {
   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}" \u2014 recommend only, do NOT install.` : "Analyze the project tech stack and discover relevant skills \u2014 recommend only, do NOT install.";
   const tools = isInstall ? TOOLS_ALL : TOOLS_NO_EDIT;
-  const result = await runAgent("skill-discoverer", task, { ...opts, tools });
+  const result2 = await runAgent("skill-discoverer", task, { ...opts, tools });
   return {
-    content: [{ type: "text", text: result.output || "No skills found." }],
+    content: [{ type: "text", text: result2.output || "No skills found." }],
     details: { pipeline: "discover-skills", stages }
   };
 }
 
-// src/utils/exec.ts
-import { spawn as spawn3 } from "child_process";
-function exec(cmd, cwd) {
-  return new Promise((resolve2) => {
-    const proc = spawn3("bash", ["-c", cmd], { cwd, stdio: ["ignore", "pipe", "pipe"] });
-    let out = "";
-    proc.stdout.on("data", (d) => {
-      out += d.toString();
-    });
-    proc.on("close", () => resolve2(out.trim()));
-    proc.on("error", () => resolve2(""));
-  });
-}
-
 // src/utils/git.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+
+// src/utils/git-workflow.ts
 import * as fs3 from "fs";
 import * as os2 from "os";
 import * as path4 from "path";
+async function setupBranch(cwd, branch, execFn = exec) {
+  const aheadStr = await execFn(`git rev-list main..${branch} --count 2>/dev/null || echo 0`, cwd);
+  const ahead = parseInt(aheadStr, 10) || 0;
+  if (ahead > 0) {
+    await execFn(`git checkout ${branch}`, cwd);
+    const current2 = await execFn("git branch --show-current", cwd);
+    if (current2 !== branch) {
+      return { status: "failed", error: `Failed to switch to ${branch} (on ${current2})` };
+    }
+    return { status: "resumed", ahead };
+  }
+  await execFn(`git branch -D ${branch} 2>/dev/null; git branch -dr origin/${branch} 2>/dev/null; echo done`, cwd);
+  await execFn(`git checkout -b ${branch}`, cwd);
+  let current = await execFn("git branch --show-current", cwd);
+  if (current !== branch) {
+    await execFn(`git checkout ${branch} 2>/dev/null || git checkout -b ${branch}`, cwd);
+    current = await execFn("git branch --show-current", cwd);
+  }
+  if (current !== branch) {
+    return { status: "failed", error: `Failed to switch to ${branch} (on ${current})` };
+  }
+  return { status: "fresh" };
+}
+async function ensurePr(cwd, title, body, branch, execFn = exec) {
+  await execFn(`git push -u origin ${branch}`, cwd);
+  const existingNum = await findPrNumber(cwd, branch, execFn);
+  if (existingNum != null) {
+    return { number: existingNum, created: false };
+  }
+  const tmp = path4.join(os2.tmpdir(), `forgeflow-pr-${Date.now()}.md`);
+  try {
+    fs3.writeFileSync(tmp, body, "utf-8");
+    const createOutput = await execFn(`gh pr create --title "${title}" --body-file "${tmp}" --head ${branch}`, cwd);
+    const urlMatch = createOutput.match(/\/pull\/(\d+)/);
+    if (urlMatch?.[1]) {
+      return { number: parseInt(urlMatch[1], 10), created: true };
+    }
+    const createdNum = await findPrNumber(cwd, branch, execFn);
+    return { number: createdNum ?? 0, created: true };
+  } finally {
+    try {
+      fs3.unlinkSync(tmp);
+    } catch {
+    }
+  }
+}
+async function findPrNumber(cwd, branch, execFn = exec) {
+  const result2 = await execFn(`gh pr list --head "${branch}" --json number --jq '.[0].number'`, cwd);
+  if (result2 && result2 !== "null") {
+    return parseInt(result2, 10);
+  }
+  return null;
+}
+async function mergePr(cwd, prNumber, execFn = exec) {
+  const mergeResult = await execFn(`gh pr merge ${prNumber} --squash --delete-branch`, cwd);
+  if (mergeResult.includes("Merged") || mergeResult.includes("merged")) {
+    return;
+  }
+  const prState = await execFn(`gh pr view ${prNumber} --json state --jq '.state'`, cwd);
+  if (prState === "MERGED") {
+    return;
+  }
+  throw new Error(`Failed to merge PR #${prNumber}. State: ${prState || "unknown"}`);
+}
+async function returnToMain(cwd, execFn = exec) {
+  await execFn("git checkout main", cwd);
+  await execFn("git pull --rebase", cwd);
+}
+
+// src/utils/git.ts
 var PR_TEMPLATE_PATHS = [
   ".github/pull_request_template.md",
   ".github/PULL_REQUEST_TEMPLATE.md",
@@ -390,9 +640,9 @@ function buildPrBody(cwd, issue) {
   const isGitHub = issue.source === "github" && issue.number > 0;
   const defaultBody = isGitHub ? `Closes #${issue.number}` : `Jira: ${issue.key}`;
   for (const rel of PR_TEMPLATE_PATHS) {
-    const abs = path4.join(cwd, rel);
+    const abs = path5.join(cwd, rel);
     try {
-      const template = fs3.readFileSync(abs, "utf-8");
+      const template = fs4.readFileSync(abs, "utf-8");
       const closeRef = isGitHub ? `Closes #${issue.number}` : `Jira: ${issue.key}`;
       return `${closeRef}
 
@@ -402,18 +652,6 @@ ${template}`;
   }
   return defaultBody;
 }
-async function createPr(cwd, title, body, branch) {
-  const tmp = path4.join(os2.tmpdir(), `forgeflow-pr-${Date.now()}.md`);
-  try {
-    fs3.writeFileSync(tmp, body, "utf-8");
-    await exec(`gh pr create --title "${title}" --body-file "${tmp}" --head ${branch}`, cwd);
-  } finally {
-    try {
-      fs3.unlinkSync(tmp);
-    } catch {
-    }
-  }
-}
 function slugify(text, maxLen = 40) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, maxLen).replace(/-$/, "");
 }
@@ -441,7 +679,7 @@ async function resolveIssue(cwd, issueArg) {
   return `On branch "${branch}" \u2014 can't detect issue. Use /implement <issue#> or /implement <JIRA-KEY>.`;
 }
 async function resolveGitHubIssue(cwd, issueNum) {
-  const issueJson = await exec(`gh issue view ${issueNum} --json number,title,body`, cwd);
+  const issueJson = await execSafe(`gh issue view ${issueNum} --json number,title,body`, cwd);
   if (!issueJson) return `Could not fetch issue #${issueNum}.`;
   let issue;
   try {
@@ -450,12 +688,11 @@ async function resolveGitHubIssue(cwd, issueNum) {
     return `Could not parse issue #${issueNum}.`;
   }
   const branch = `feat/issue-${issueNum}`;
-  const prJson = await exec(`gh pr list --head "${branch}" --json number --jq '.[0].number'`, cwd);
-  const existingPR = prJson && prJson !== "null" ? parseInt(prJson, 10) : void 0;
+  const existingPR = await findPrNumber(cwd, branch) ?? void 0;
   return { source: "github", key: String(issueNum), ...issue, branch, existingPR };
 }
 async function resolveJiraIssue(cwd, jiraKey, existingBranch) {
-  const raw = await exec(`jira issue view ${jiraKey} --raw`, cwd);
+  const raw = await execSafe(`jira issue view ${jiraKey} --raw`, cwd);
   if (!raw) return `Could not fetch Jira issue ${jiraKey}.`;
   let data;
   try {
@@ -475,8 +712,7 @@ ${fields.acceptance_criteria}`);
   if (fields.sprint?.name) bodyParts.push(`**Sprint:** ${fields.sprint.name}`);
   const body = bodyParts.join("\n\n");
   const branch = existingBranch ?? `feat/${jiraKey}-${slugify(title)}`;
-  const prJson = await exec(`gh pr list --head "${branch}" --json number --jq '.[0].number'`, cwd);
-  const existingPR = prJson && prJson !== "null" ? parseInt(prJson, 10) : void 0;
+  const existingPR = await findPrNumber(cwd, branch) ?? void 0;
   return { source: "jira", key: jiraKey, number: 0, title, body, branch, existingPR };
 }
 
@@ -503,152 +739,60 @@ function updateProgressWidget(ctx, progress, totalCost) {
   setForgeflowWidget(ctx, lines);
 }
 
-// src/pipelines/review.ts
-async function runReviewInline(cwd, signal, onUpdate, ctx, stages, diffCmd = "git diff main...HEAD", pipeline = "review", options = {}) {
-  const diff = await exec(diffCmd, cwd);
-  if (!diff) {
-    return { content: [{ type: "text", text: "No changes to review." }] };
-  }
-  const opts = { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline, onUpdate };
-  const extraInstructions = options.customPrompt ? `
+// src/pipelines/review-orchestrator.ts
+async function runReviewPipeline(diff, opts) {
+  const { cwd, signal, stages, pipeline = "review", onUpdate, customPrompt } = opts;
+  const runAgentFn = await resolveRunAgent(opts.runAgentFn);
+  const agentOpts = { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline, onUpdate };
+  const extraInstructions = customPrompt ? `
 
 ADDITIONAL INSTRUCTIONS FROM USER:
-${options.customPrompt}` : "";
+${customPrompt}` : "";
   cleanSignal(cwd, "findings");
   stages.push(emptyStage("code-reviewer"));
-  await runAgent("code-reviewer", `Review the following diff:
+  await runAgentFn("code-reviewer", `Review the following diff:
 
 ${diff}${extraInstructions}`, {
-    ...opts,
+    ...agentOpts,
     tools: TOOLS_NO_EDIT
   });
   if (!signalExists(cwd, "findings")) {
-    return { content: [{ type: "text", text: "Review passed \u2014 no actionable findings." }] };
+    return { passed: true };
   }
   stages.push(emptyStage("review-judge"));
   const findings = readSignal(cwd, "findings") ?? "";
-  await runAgent(
+  await runAgentFn(
     "review-judge",
     `Validate the following code review findings against the actual code:
 
 ${findings}`,
-    { ...opts, tools: TOOLS_NO_EDIT }
+    { ...agentOpts, tools: TOOLS_NO_EDIT }
   );
   if (!signalExists(cwd, "findings")) {
-    return { content: [{ type: "text", text: "Review passed \u2014 judge filtered all findings." }] };
+    return { passed: true };
   }
   const validatedFindings = readSignal(cwd, "findings") ?? "";
-  if (options.interactive && options.prNumber) {
-    const repo = await exec("gh repo view --json nameWithOwner --jq .nameWithOwner", cwd);
-    const prNum = options.prNumber;
-    const proposalPrompt = `You have validated code review findings for PR #${prNum} in ${repo}.
-
-FINDINGS:
-${validatedFindings}
-
-Generate ready-to-run \`gh api\` commands to post each finding as a PR review comment. One command per finding.
-
-Format each as:
-
-**Finding N** \u2014 path/to/file.ts:LINE
-
-\`\`\`bash
-gh api repos/${repo}/pulls/${prNum}/comments \\
-  --method POST \\
-  --field body="<comment>" \\
-  --field commit_id="$(gh pr view ${prNum} --repo ${repo} --json headRefOid -q .headRefOid)" \\
-  --field path="path/to/file.ts" \\
-  --field line=LINE \\
-  --field side="RIGHT"
-\`\`\`
-
-Comment tone rules:
-- Write like a teammate, not an auditor. Casual, brief, direct.
-- 1-2 short sentences max. Lead with the suggestion, not the problem.
-- Use "might be worth..." / "could we..." / "what about..." / "small thing:"
-- No em dashes, no "Consider...", no "Note that...", no hedging filler.
-- Use GitHub \`\`\`suggestion\`\`\` blocks when proposing code changes.
-- Only generate commands for findings with a specific file + line.
-
-After the comments, add the review decision command:
-
-\`\`\`bash
-gh pr review ${prNum} --request-changes --body "Left a few comments" --repo ${repo}
-\`\`\`
-
-Output ONLY the commands, no other text.`;
-    stages.push(emptyStage("propose-comments"));
-    await runAgent("review-judge", proposalPrompt, {
-      agentsDir: AGENTS_DIR,
-      cwd,
-      signal,
-      stages,
-      pipeline,
-      onUpdate,
-      tools: TOOLS_READONLY
-    });
-    const commentStage = stages.find((s) => s.name === "propose-comments");
-    const proposedCommands = commentStage?.output || "";
-    if (proposedCommands && ctx.hasUI) {
-      const reviewed = await ctx.ui.editor(
-        `Review PR comments for PR #${prNum} (edit or close to skip)`,
-        `${validatedFindings}
-
----
-
-Proposed commands (run these to post):
-
-${proposedCommands}`
-      );
-      if (reviewed != null) {
-        const action = await ctx.ui.select("Post these review comments?", ["Post comments", "Skip"]);
-        if (action === "Post comments") {
-          const commands = reviewed.match(/```bash\n([\s\S]*?)```/g) || [];
-          for (const block of commands) {
-            const cmd = block.replace(/```bash\n/, "").replace(/```$/, "").trim();
-            if (cmd.startsWith("gh ")) {
-              await exec(cmd, cwd);
-            }
-          }
-        }
-      }
-    }
-  }
-  return { content: [{ type: "text", text: validatedFindings }], isError: true };
+  return { passed: false, findings: validatedFindings };
 }
-async function runReview(cwd, target, signal, onUpdate, ctx, customPrompt) {
-  const stages = [];
-  let diffCmd = "git diff main...HEAD";
-  let prNumber;
-  if (target.match(/^\d+$/)) {
-    diffCmd = `gh pr diff ${target}`;
-    prNumber = target;
-  } else if (target.startsWith("--branch")) {
-    const branch = target.replace("--branch", "").trim() || "HEAD";
-    diffCmd = `git diff main...${branch}`;
-  } else {
-    const pr = await exec("gh pr view --json number --jq .number 2>/dev/null", cwd);
-    if (pr && pr !== "") prNumber = pr;
-  }
-  if (ctx.hasUI && !customPrompt) {
-    const extra = await ctx.ui.input("Additional instructions?", "Skip");
-    if (extra != null && extra.trim() !== "") {
-      customPrompt = extra.trim();
-    }
-  }
-  const result = await runReviewInline(cwd, signal, onUpdate, ctx, stages, diffCmd, "review", {
-    prNumber,
-    interactive: ctx.hasUI,
-    customPrompt
+
+// src/pipelines/agents.ts
+async function runImplementor(cwd, prompt, signal, stages, onUpdate) {
+  await runAgent("implementor", prompt, {
+    agentsDir: AGENTS_DIR,
+    cwd,
+    signal,
+    stages,
+    pipeline: "implement",
+    onUpdate,
+    tools: TOOLS_ALL
   });
-  return { ...result, details: { pipeline: "review", stages } };
 }
-
-// src/pipelines/implement.ts
-async function reviewAndFix(cwd, signal, onUpdate, ctx, stages, pipeline = "implement") {
-  const reviewResult = await runReviewInline(cwd, signal, onUpdate, ctx, stages);
-  if (reviewResult.isError) {
-    const findings = reviewResult.content[0]?.type === "text" ? reviewResult.content[0].text : "";
+async function reviewAndFix(cwd, signal, onUpdate, _ctx, stages, pipeline = "implement") {
+  const diff = await exec("git diff main...HEAD", cwd);
+  if (!diff) return;
+  const reviewResult2 = await runReviewPipeline(diff, { cwd, signal, stages, pipeline, onUpdate });
+  if (!reviewResult2.passed) {
+    const findings = reviewResult2.findings ?? "";
     stages.push(emptyStage("fix-findings"));
     await runAgent(
       "implementor",
@@ -676,21 +820,56 @@ async function refactorAndReview(cwd, signal, onUpdate, ctx, stages, skipReview,
     await reviewAndFix(cwd, signal, onUpdate, ctx, stages, pipeline);
   }
 }
-async function resolveQuestions(plan, ctx) {
-  const sectionMatch = plan.match(/### Unresolved Questions\n([\s\S]*?)(?=\n###|$)/);
-  if (!sectionMatch) return plan;
-  const section = sectionMatch[1] ?? "";
-  const itemRe = /^(?:[-*]|\d+[.)]+|[a-z][.)]+)\s+(.+(?:\n(?!(?:[-*]|\d+[.)]+|[a-z][.)]+)\s).*)*)/gm;
-  const items = [];
-  for (const m of section.matchAll(itemRe)) {
-    if (m[0] && m[1]) items.push({ full: m[0], text: m[1] });
-  }
-  if (items.length === 0) return plan;
-  let updatedSection = section;
-  for (const item of items) {
-    const answer = await ctx.ui.input(`${item.text}`, "Skip to use defaults");
-    if (answer != null && answer.trim() !== "") {
-      updatedSection = updatedSection.replace(item.full, `${item.full}
+function buildImplementorPrompt(issueContext, plan, customPrompt, resolved, autonomous) {
+  const isGitHub = resolved.source === "github" && resolved.number > 0;
+  const planSection = plan ? `
+
+IMPLEMENTATION PLAN:
+${plan}` : "";
+  const customPromptSection = customPrompt ? `
+
+ADDITIONAL INSTRUCTIONS FROM USER:
+${customPrompt}` : "";
+  const branchNote = resolved.branch ? `
+- You should be on branch: ${resolved.branch} \u2014 do NOT create or switch branches.` : "\n- Do NOT create or switch branches.";
+  const prNote = resolved.existingPR ? `
+- PR #${resolved.existingPR} already exists for this branch.` : "";
+  const closeNote = isGitHub ? `
+- The PR body MUST end with a blank line then 'Closes #${resolved.number}' on its own line (not inline with other text), so the issue auto-closes on merge.` : `
+- The PR body should reference Jira issue ${resolved.key}.`;
+  const unresolvedNote = autonomous ? `
+- If the plan has unresolved questions, resolve them yourself using sensible defaults. Do NOT stop and wait.` : "";
+  return `Implement the following issue using strict TDD (red-green-refactor).
+
+${issueContext}${planSection}${customPromptSection}
+
+WORKFLOW:
+1. Read the codebase.
+2. TDD${plan ? " following the plan" : ""}.
+3. Refactor after all tests pass.
+4. Run check command, fix failures.
+5. Commit, push, and create a PR.
+
+CONSTRAINTS:${branchNote}${prNote}${closeNote}${unresolvedNote}
+- If blocked, write BLOCKED.md with the reason and stop.`;
+}
+
+// src/pipelines/planning.ts
+async function resolveQuestions(plan, ctx) {
+  const sectionMatch = plan.match(/### Unresolved Questions\n([\s\S]*?)(?=\n###|$)/);
+  if (!sectionMatch) return plan;
+  const section = sectionMatch[1] ?? "";
+  const itemRe = /^(?:[-*]|\d+[.)]+|[a-z][.)]+)\s+(.+(?:\n(?!(?:[-*]|\d+[.)]+|[a-z][.)]+)\s).*)*)/gm;
+  const items = [];
+  for (const m of section.matchAll(itemRe)) {
+    if (m[0] && m[1]) items.push({ full: m[0], text: m[1] });
+  }
+  if (items.length === 0) return plan;
+  let updatedSection = section;
+  for (const item of items) {
+    const answer = await ctx.ui.input(`${item.text}`, "Skip to use defaults");
+    if (answer != null && answer.trim() !== "") {
+      updatedSection = updatedSection.replace(item.full, `${item.full}
   **Answer:** ${answer.trim()}`);
     }
   }
@@ -698,186 +877,120 @@ async function resolveQuestions(plan, ctx) {
 ${section}`, `### Unresolved Questions
 ${updatedSection}`);
 }
+async function runPlanning(cwd, issueContext, customPrompt, opts) {
+  const { signal, onUpdate, ctx, interactive, stages } = opts;
+  const runAgentFn = await resolveRunAgent(opts.runAgentFn);
+  const customPromptSection = customPrompt ? `
+
+ADDITIONAL INSTRUCTIONS FROM USER:
+${customPrompt}` : "";
+  const planResult = await runAgentFn(
+    "planner",
+    `Plan the implementation for this issue by producing a sequenced list of test cases.
+
+${issueContext}${customPromptSection}`,
+    { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline: "implement", onUpdate, tools: TOOLS_READONLY }
+  );
+  if (planResult.status === "failed") {
+    return { plan: planResult.output, cancelled: false, failed: true, stages };
+  }
+  let plan = planResult.output;
+  if (interactive && plan) {
+    const edited = await ctx.ui.editor("Review implementation plan", plan);
+    if (edited != null && edited !== plan) {
+      plan = edited;
+    }
+    plan = await resolveQuestions(plan, ctx);
+    const action = await ctx.ui.select("Plan ready. What next?", ["Approve and implement", "Cancel"]);
+    if (action === "Cancel" || action == null) {
+      return { plan, cancelled: true, stages };
+    }
+  }
+  return { plan, cancelled: false, stages };
+}
+
+// src/pipelines/implement.ts
+function result(text, stages, isError) {
+  return {
+    content: [{ type: "text", text }],
+    details: { pipeline: "implement", stages },
+    ...isError ? { isError } : {}
+  };
+}
 async function runImplement(cwd, issueArg, signal, onUpdate, ctx, flags = {
   skipPlan: false,
   skipReview: false
 }) {
   const interactive = ctx.hasUI && !flags.autonomous;
   const resolved = await resolveIssue(cwd, issueArg || void 0);
-  if (typeof resolved === "string") {
-    return { content: [{ type: "text", text: resolved }], details: { pipeline: "implement", stages: [] } };
-  }
-  const isGitHub = resolved.source === "github" && resolved.number > 0;
-  const issueLabel = isGitHub ? `#${resolved.number}: ${resolved.title}` : `${resolved.key}: ${resolved.title}`;
-  if (!flags.autonomous && (resolved.number || resolved.key)) {
-    const tag = isGitHub ? `#${resolved.number}` : resolved.key;
-    setForgeflowStatus(ctx, `${tag} ${resolved.title} \xB7 ${resolved.branch}`);
-  }
-  const issueContext = isGitHub ? `Issue #${resolved.number}: ${resolved.title}
+  if (typeof resolved === "string") return result(resolved, []);
+  const isGH = resolved.source === "github" && resolved.number > 0;
+  const issueLabel = isGH ? `#${resolved.number}: ${resolved.title}` : `${resolved.key}: ${resolved.title}`;
+  const issueContext = isGH ? `Issue #${resolved.number}: ${resolved.title}
 
 ${resolved.body}` : `Jira ${resolved.key}: ${resolved.title}
 
 ${resolved.body}`;
+  if (!flags.autonomous && (resolved.number || resolved.key))
+    setForgeflowStatus(ctx, `${isGH ? `#${resolved.number}` : resolved.key} ${resolved.title} \xB7 ${resolved.branch}`);
   if (interactive && !flags.customPrompt) {
     const extra = await ctx.ui.input("Additional instructions?", "Skip");
-    if (extra != null && extra.trim() !== "") {
-      flags.customPrompt = extra.trim();
-    }
+    if (extra?.trim()) flags.customPrompt = extra.trim();
   }
-  const customPromptSection = flags.customPrompt ? `
-
-ADDITIONAL INSTRUCTIONS FROM USER:
-${flags.customPrompt}` : "";
   if (resolved.existingPR) {
     const stages2 = [];
-    if (!flags.skipReview) {
-      await reviewAndFix(cwd, signal, onUpdate, ctx, stages2);
-    }
-    return {
-      content: [{ type: "text", text: `Resumed ${issueLabel} \u2014 PR #${resolved.existingPR} already exists.` }],
-      details: { pipeline: "implement", stages: stages2 }
-    };
+    if (!flags.skipReview) await reviewAndFix(cwd, signal, onUpdate, ctx, stages2);
+    return result(`Resumed ${issueLabel} \u2014 PR #${resolved.existingPR} already exists.`, stages2);
   }
   if (resolved.branch) {
-    const branch = resolved.branch;
-    const branchSetup = await exec(
-      `ahead=$(git rev-list main..${branch} --count 2>/dev/null || echo 0); if [ "$ahead" -gt 0 ] 2>/dev/null; then git checkout ${branch} && echo "RESUME:$ahead"; else git branch -D ${branch} 2>/dev/null; git branch -dr origin/${branch} 2>/dev/null; git checkout -b ${branch} && echo "FRESH"; fi`,
-      cwd
-    );
-    if (branchSetup.startsWith("RESUME:")) {
-      await exec(`git push -u origin ${branch}`, cwd);
-      const prBody = buildPrBody(cwd, resolved);
-      await createPr(cwd, resolved.title, prBody, branch);
+    const branchResult = await setupBranch(cwd, resolved.branch);
+    if (branchResult.status === "resumed") {
+      await ensurePr(cwd, resolved.title, buildPrBody(cwd, resolved), resolved.branch);
       const stages2 = [];
       await refactorAndReview(cwd, signal, onUpdate, ctx, stages2, flags.skipReview);
-      return {
-        content: [{ type: "text", text: `Resumed ${issueLabel} \u2014 pushed existing commits and created PR.` }],
-        details: { pipeline: "implement", stages: stages2 }
-      };
-    }
-    let afterBranch = await exec("git branch --show-current", cwd);
-    if (afterBranch !== branch) {
-      await exec(`git checkout ${branch} 2>/dev/null || git checkout -b ${branch}`, cwd);
-      afterBranch = await exec("git branch --show-current", cwd);
-    }
-    if (afterBranch !== branch) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Failed to switch to ${branch} (on ${afterBranch}). Setup output: ${branchSetup || "(empty)"}`
-          }
-        ],
-        details: { pipeline: "implement", stages: [] },
-        isError: true
-      };
+      return result(`Resumed ${issueLabel} \u2014 pushed existing commits and created PR.`, stages2);
     }
+    if (branchResult.status === "failed")
+      return result(branchResult.error || `Failed to switch to ${resolved.branch}.`, [], true);
   }
-  const stageList = [];
-  if (!flags.skipPlan) stageList.push(emptyStage("planner"));
-  stageList.push(emptyStage("implementor"));
-  stageList.push(emptyStage("refactorer"));
-  const stages = stageList;
-  const opts = { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline: "implement", onUpdate };
+  const stages = [];
+  if (!flags.skipPlan) stages.push(emptyStage("planner"));
+  stages.push(emptyStage("implementor"), emptyStage("refactorer"));
   let plan = "";
   if (!flags.skipPlan) {
-    const planResult = await runAgent(
-      "planner",
-      `Plan the implementation for this issue by producing a sequenced list of test cases.
-
-${issueContext}${customPromptSection}`,
-      { ...opts, tools: TOOLS_READONLY }
-    );
-    if (planResult.status === "failed") {
-      return {
-        content: [{ type: "text", text: `Planner failed: ${planResult.output}` }],
-        details: { pipeline: "implement", stages },
-        isError: true
-      };
-    }
-    plan = planResult.output;
-    if (interactive && plan) {
-      const edited = await ctx.ui.editor(`Review implementation plan for ${issueLabel}`, plan);
-      if (edited != null && edited !== plan) {
-        plan = edited;
-      }
-      plan = await resolveQuestions(plan, ctx);
-      const action = await ctx.ui.select("Plan ready. What next?", ["Approve and implement", "Cancel"]);
-      if (action === "Cancel" || action == null) {
-        return {
-          content: [{ type: "text", text: "Implementation cancelled." }],
-          details: { pipeline: "implement", stages }
-        };
-      }
-    }
+    const planResult = await runPlanning(cwd, issueContext, flags.customPrompt, {
+      signal,
+      onUpdate,
+      ctx,
+      interactive,
+      stages
+    });
+    if (planResult.failed) return result(`Planner failed: ${planResult.plan}`, stages, true);
+    if (planResult.cancelled) return result("Implementation cancelled.", stages);
+    plan = planResult.plan;
   }
   cleanSignal(cwd, "blocked");
-  const planSection = plan ? `
-
-IMPLEMENTATION PLAN:
-${plan}` : "";
-  const branchNote = resolved.branch ? `
-- You should be on branch: ${resolved.branch} \u2014 do NOT create or switch branches.` : "\n- Do NOT create or switch branches.";
-  const prNote = resolved.existingPR ? `
-- PR #${resolved.existingPR} already exists for this branch.` : "";
-  const closeNote = isGitHub ? `
-- The PR body MUST end with a blank line then 'Closes #${resolved.number}' on its own line (not inline with other text), so the issue auto-closes on merge.` : `
-- The PR body should reference Jira issue ${resolved.key}.`;
-  const unresolvedNote = flags.autonomous ? `
-- If the plan has unresolved questions, resolve them yourself using sensible defaults. Do NOT stop and wait.` : "";
-  await runAgent(
-    "implementor",
-    `Implement the following issue using strict TDD (red-green-refactor).
-
-${issueContext}${planSection}${customPromptSection}
-
-WORKFLOW:
-1. Read the codebase.
-2. TDD${plan ? " following the plan" : ""}.
-3. Refactor after all tests pass.
-4. Run check command, fix failures.
-5. Commit, push, and create a PR.
-
-CONSTRAINTS:${branchNote}${prNote}${closeNote}${unresolvedNote}
-- If blocked, write BLOCKED.md with the reason and stop.`,
-    { ...opts, tools: TOOLS_ALL }
-  );
-  if (signalExists(cwd, "blocked")) {
-    const reason = readSignal(cwd, "blocked") ?? "";
-    return {
-      content: [{ type: "text", text: `Implementor blocked:
-${reason}` }],
-      details: { pipeline: "implement", stages },
-      isError: true
-    };
-  }
+  const prompt = buildImplementorPrompt(issueContext, plan, flags.customPrompt, resolved, flags.autonomous);
+  await runImplementor(cwd, prompt, signal, stages, onUpdate);
+  if (signalExists(cwd, "blocked"))
+    return result(`Implementor blocked:
+${readSignal(cwd, "blocked") ?? ""}`, stages, true);
   await refactorAndReview(cwd, signal, onUpdate, ctx, stages, flags.skipReview);
-  let prNumber = "";
+  let prNumber = 0;
   if (resolved.branch) {
-    await exec(`git push -u origin ${resolved.branch}`, cwd);
-    prNumber = await exec(`gh pr list --head "${resolved.branch}" --json number --jq '.[0].number'`, cwd);
-    if (!prNumber || prNumber === "null") {
-      const prBody = buildPrBody(cwd, resolved);
-      await createPr(cwd, resolved.title, prBody, resolved.branch);
-      prNumber = await exec(`gh pr list --head "${resolved.branch}" --json number --jq '.[0].number'`, cwd);
-    }
+    const prResult = await ensurePr(cwd, resolved.title, buildPrBody(cwd, resolved), resolved.branch);
+    prNumber = prResult.number;
   }
-  if (!flags.autonomous && prNumber && prNumber !== "null") {
+  if (!flags.autonomous && prNumber > 0) {
     const mergeStage = emptyStage("merge");
     stages.push(mergeStage);
-    await exec(`gh pr merge ${prNumber} --squash --delete-branch`, cwd);
-    await exec("git checkout main && git pull", cwd);
+    await mergePr(cwd, prNumber);
+    await returnToMain(cwd);
     mergeStage.status = "done";
     mergeStage.output = `Merged PR #${prNumber}`;
-    onUpdate?.({
-      content: [{ type: "text", text: "Pipeline complete" }],
-      details: { pipeline: "implement", stages }
-    });
+    onUpdate?.({ content: [{ type: "text", text: "Pipeline complete" }], details: { pipeline: "implement", stages } });
   }
-  return {
-    content: [{ type: "text", text: `Implementation of ${issueLabel} complete.` }],
-    details: { pipeline: "implement", stages }
-  };
+  return result(`Implementation of ${issueLabel} complete.`, stages);
 }
 
 // src/pipelines/implement-all.ts
@@ -903,7 +1016,7 @@ async function runImplementAll(cwd, signal, onUpdate, ctx, flags) {
   const maxIterations = 50;
   while (iteration++ < maxIterations) {
     if (signal.aborted) break;
-    await exec("git checkout main && git pull --rebase", cwd);
+    await returnToMain(cwd, exec);
     const issuesJson = await exec(
       `gh issue list --state open --label "auto-generated" --json number,title,body --jq 'sort_by(.number)'`,
       cwd
@@ -970,25 +1083,20 @@ async function runImplementAll(cwd, signal, onUpdate, ctx, flags) {
       };
     }
     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 === "") {
+    await returnToMain(cwd, exec);
+    const prNum = await findPrNumber(cwd, branch, exec);
+    if (prNum != null) {
+      try {
+        await mergePr(cwd, prNum, exec);
         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", text: `Failed to merge PR #${prNum} for issue #${issueNum}.` }],
-            details: { pipeline: "implement-all", stages: allStages },
-            isError: true
-          };
-        }
+      } catch {
+        issueProgress.set(issueNum, { title: issueTitle, status: "failed" });
+        updateProgressWidget(ctx, issueProgress, sumUsage(allStages).cost);
+        return {
+          content: [{ type: "text", 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" });
@@ -1012,6 +1120,139 @@ async function runImplementAll(cwd, signal, onUpdate, ctx, flags) {
   };
 }
 
+// src/pipelines/review-comments.ts
+function buildCommentProposalPrompt(findings, prNum, repo) {
+  return `You have validated code review findings for PR #${prNum} in ${repo}.
+
+FINDINGS:
+${findings}
+
+Generate ready-to-run \`gh api\` commands to post each finding as a PR review comment. One command per finding.
+
+Format each as:
+
+**Finding N** \u2014 path/to/file.ts:LINE
+
+\`\`\`bash
+gh api repos/${repo}/pulls/${prNum}/comments \\
+  --method POST \\
+  --field body="<comment>" \\
+  --field commit_id="$(gh pr view ${prNum} --repo ${repo} --json headRefOid -q .headRefOid)" \\
+  --field path="path/to/file.ts" \\
+  --field line=LINE \\
+  --field side="RIGHT"
+\`\`\`
+
+Comment tone rules:
+- Write like a teammate, not an auditor. Casual, brief, direct.
+- 1-2 short sentences max. Lead with the suggestion, not the problem.
+- Use "might be worth..." / "could we..." / "what about..." / "small thing:"
+- No em dashes, no "Consider...", no "Note that...", no hedging filler.
+- Use GitHub \`\`\`suggestion\`\`\` blocks when proposing code changes.
+- Only generate commands for findings with a specific file + line.
+
+After the comments, add the review decision command:
+
+\`\`\`bash
+gh pr review ${prNum} --request-changes --body "Left a few comments" --repo ${repo}
+\`\`\`
+
+Output ONLY the commands, no other text.`;
+}
+function extractGhCommands(text) {
+  const blocks = text.match(/```bash\n([\s\S]*?)```/g) || [];
+  const commands = [];
+  for (const block of blocks) {
+    const cmd = block.replace(/```bash\n/, "").replace(/```$/, "").trim();
+    if (cmd.startsWith("gh ")) {
+      commands.push(cmd);
+    }
+  }
+  return commands;
+}
+async function proposeAndPostComments(findings, pr, opts) {
+  const { cwd, signal, stages, ctx, pipeline = "review", onUpdate } = opts;
+  const execFn = opts.execFn ?? exec;
+  const runAgentFn = await resolveRunAgent(opts.runAgentFn);
+  const proposalPrompt = buildCommentProposalPrompt(findings, pr.number, pr.repo);
+  stages.push(emptyStage("propose-comments"));
+  await runAgentFn("review-judge", proposalPrompt, {
+    agentsDir: AGENTS_DIR,
+    cwd,
+    signal,
+    stages,
+    pipeline,
+    onUpdate,
+    tools: TOOLS_READONLY
+  });
+  const commentStage = stages.find((s) => s.name === "propose-comments");
+  const proposedCommands = commentStage?.output || "";
+  if (!proposedCommands || !ctx.hasUI) return;
+  const reviewed = await ctx.ui.editor(
+    `Review PR comments for PR #${pr.number} (edit or close to skip)`,
+    `${findings}
+
+---
+
+Proposed commands (run these to post):
+
+${proposedCommands}`
+  );
+  if (reviewed == null) return;
+  const action = await ctx.ui.select("Post these review comments?", ["Post comments", "Skip"]);
+  if (action !== "Post comments") return;
+  const commands = extractGhCommands(reviewed);
+  for (const cmd of commands) {
+    await execFn(cmd, cwd);
+  }
+}
+
+// src/pipelines/review-diff.ts
+async function resolveDiffTarget(cwd, target, execFn = execSafe) {
+  if (target.match(/^\d+$/)) {
+    return { diffCmd: `gh pr diff ${target}`, prNumber: target };
+  }
+  if (target.startsWith("--branch")) {
+    const branch = target.replace("--branch", "").trim() || "HEAD";
+    return { diffCmd: `git diff main...${branch}` };
+  }
+  let prNumber;
+  const pr = await execFn("gh pr view --json number --jq .number", cwd);
+  if (pr && pr !== "") {
+    prNumber = pr;
+  }
+  return { diffCmd: "git diff main...HEAD", prNumber };
+}
+
+// src/pipelines/review.ts
+var reviewResult = (text, stages, isError) => ({
+  content: [{ type: "text", text }],
+  ...isError ? { isError } : {},
+  details: { pipeline: "review", stages }
+});
+async function runReview(cwd, target, signal, onUpdate, ctx, customPrompt) {
+  const stages = [];
+  const { diffCmd, prNumber } = await resolveDiffTarget(cwd, target);
+  if (ctx.hasUI && !customPrompt) {
+    const extra = await ctx.ui.input("Additional instructions?", "Skip");
+    if (extra?.trim()) customPrompt = extra.trim();
+  }
+  const diff = await exec(diffCmd, cwd);
+  if (!diff) return reviewResult("No changes to review.", stages);
+  const result2 = await runReviewPipeline(diff, { cwd, signal, stages, pipeline: "review", onUpdate, customPrompt });
+  if (result2.passed) return reviewResult("Review passed \u2014 no actionable findings.", stages);
+  const findings = result2.findings ?? "";
+  if (ctx.hasUI && prNumber) {
+    const repo = await exec("gh repo view --json nameWithOwner --jq .nameWithOwner", cwd);
+    await proposeAndPostComments(
+      findings,
+      { number: prNumber, repo },
+      { cwd, signal, stages, ctx, pipeline: "review", onUpdate }
+    );
+  }
+  return reviewResult(findings, stages, true);
+}
+
 // src/index.ts
 function parseImplFlags(args) {
   const skipPlan = args.includes("--skip-plan");
@@ -1042,47 +1283,6 @@ function parseReviewArgs(args) {
     customPrompt: trimmed.slice(firstSpace + 1).trim().replace(/^"(.*)"$/, "$1")
   };
 }
-function getDisplayItems(messages) {
-  const items = [];
-  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, args, fg) {
-  switch (name) {
-    case "bash": {
-      const cmd = args.command || "...";
-      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 || "...");
-    case "write":
-      return fg("muted", "write ") + fg("accent", args.file_path || args.path || "...");
-    case "edit":
-      return fg("muted", "edit ") + fg("accent", args.file_path || args.path || "...");
-    case "grep":
-      return fg("muted", "grep ") + fg("accent", `/${args.pattern || ""}/`);
-    case "find":
-      return fg("muted", "find ") + fg("accent", args.pattern || "*");
-    default:
-      return fg("accent", name);
-  }
-}
-function formatUsage(usage, model) {
-  const parts = [];
-  if (usage.turns) parts.push(`${usage.turns}t`);
-  if (usage.input) parts.push(`\u2191${usage.input < 1e3 ? usage.input : `${Math.round(usage.input / 1e3)}k`}`);
-  if (usage.output) parts.push(`\u2193${usage.output < 1e3 ? usage.output : `${Math.round(usage.output / 1e3)}k`}`);
-  if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
-  if (model) parts.push(model);
-  return parts.join(" ");
-}
 var ForgeflowDevParams = Type.Object({
   pipeline: Type.String({
     description: 'Which pipeline to run: "implement", "implement-all", "review", "architecture", or "discover-skills"'
@@ -1161,85 +1361,13 @@ function registerForgeflowDevTool(pi) {
         text += theme.fg("dim", `${prefix}${args.issue}`);
       }
       if (args.target) text += theme.fg("dim", ` ${args.target}`);
-      return new Text(text, 0, 0);
+      return new Text2(text, 0, 0);
     },
-    renderResult(result, { expanded }, theme) {
-      const details = result.details;
-      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);
+    renderResult(result2, { expanded }, theme) {
+      return renderResult(result2, expanded, theme, "forgeflow-dev");
     }
   });
 }
-function renderExpanded(details, theme) {
-  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", "\u2192 ")}${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, theme) {
-  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 += `
-  ${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 += `
-    ${theme.fg("muted", "\u2192 ")}${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, theme) {
-  return stage.status === "done" ? theme.fg("success", "\u2713") : stage.status === "running" ? theme.fg("warning", "\u27F3") : stage.status === "failed" ? theme.fg("error", "\u2717") : theme.fg("muted", "\u25CB");
-}
 var extension = (pi) => {
   registerForgeflowDevTool(pi);
   pi.registerCommand("implement", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@callumvass/forgeflow-dev",
-  "version": "0.4.4",
+  "version": "0.6.0",
   "type": "module",
   "description": "Dev pipeline for Pi — TDD implementation, code review, architecture, and skill discovery.",
   "keywords": [