@callumvass/forgeflow-dev 0.1.0

package/extensions/index.js

@@ -0,0 +1,1279 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// ../shared/dist/constants.js
+var TOOLS_ALL = ["read", "write", "edit", "bash", "grep", "find"];
+var TOOLS_READONLY = ["read", "bash", "grep", "find"];
+var TOOLS_NO_EDIT = ["read", "write", "bash", "grep", "find"];
+var SIGNALS = {
+  questions: "QUESTIONS.md",
+  findings: "FINDINGS.md",
+  blocked: "BLOCKED.md"
+};
+
+// ../shared/dist/run-agent.js
+import { spawn } 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/types.js
+function emptyUsage() {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+}
+function emptyStage(name) {
+  return {
+    name,
+    status: "pending",
+    messages: [],
+    exitCode: -1,
+    stderr: "",
+    output: "",
+    usage: emptyUsage()
+  };
+}
+function getFinalOutput(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role === "assistant") {
+      for (const part of msg.content) {
+        if (typeof part === "object" && "type" in part && part.type === "text" && "text" in part) {
+          return part.text;
+        }
+      }
+    }
+  }
+  return "";
+}
+function sumUsage(stages) {
+  const total = emptyUsage();
+  for (const s of stages) {
+    total.input += s.usage.input;
+    total.output += s.usage.output;
+    total.cacheRead += s.usage.cacheRead;
+    total.cacheWrite += s.usage.cacheWrite;
+    total.cost += s.usage.cost;
+    total.turns += s.usage.turns;
+  }
+  return total;
+}
+
+// ../shared/dist/run-agent.js
+function getPiInvocation(args) {
+  const currentScript = process.argv[1];
+  if (currentScript && fs.existsSync(currentScript)) {
+    return { command: process.execPath, args: [currentScript, ...args] };
+  }
+  const execName = path.basename(process.execPath).toLowerCase();
+  if (!/^(node|bun)(\.exe)?$/.test(execName)) {
+    return { command: process.execPath, args };
+  }
+  return { command: "pi", args };
+}
+async function writePromptToTempFile(name, prompt) {
+  const tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "forgeflow-"));
+  const filePath = path.join(tmpDir, `prompt-${name}.md`);
+  await withFileMutationQueue(filePath, async () => {
+    await fs.promises.writeFile(filePath, prompt, { encoding: "utf-8", mode: 384 });
+  });
+  return { dir: tmpDir, filePath };
+}
+async function runAgent(agentName, task, options) {
+  const agentPath = path.join(options.agentsDir, `${agentName}.md`);
+  const lookupName = options.stageName ?? agentName;
+  const stage = options.stages.find((s) => s.name === lookupName && s.status === "pending") ?? options.stages.find((s) => s.name === lookupName);
+  if (!stage) {
+    const s = emptyStage(agentName);
+    s.status = "failed";
+    s.output = "Stage not found in pipeline";
+    return s;
+  }
+  stage.status = "running";
+  emitUpdate(options);
+  const tools = options.tools ?? ["read", "write", "edit", "bash", "grep", "find"];
+  const args = ["--mode", "json", "-p", "--no-session", "--tools", tools.join(",")];
+  let tmpDir = null;
+  let tmpFile = null;
+  try {
+    const systemPrompt = fs.readFileSync(agentPath, "utf-8");
+    const tmp = await writePromptToTempFile(agentName, systemPrompt);
+    tmpDir = tmp.dir;
+    tmpFile = tmp.filePath;
+    args.push("--append-system-prompt", tmpFile);
+    args.push(`Task: ${task}`);
+    const exitCode = await new Promise((resolve2) => {
+      const invocation = getPiInvocation(args);
+      const proc = spawn(invocation.command, invocation.args, {
+        cwd: options.cwd,
+        shell: false,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let buffer = "";
+      const processLine = (line) => {
+        if (!line.trim())
+          return;
+        let event;
+        try {
+          event = JSON.parse(line);
+        } catch {
+          return;
+        }
+        if (event.type === "message_end" && event.message) {
+          const msg = event.message;
+          stage.messages.push(msg);
+          if (msg.role === "assistant") {
+            stage.usage.turns++;
+            const usage = msg.usage;
+            if (usage) {
+              stage.usage.input += usage.input || 0;
+              stage.usage.output += usage.output || 0;
+              stage.usage.cacheRead += usage.cacheRead || 0;
+              stage.usage.cacheWrite += usage.cacheWrite || 0;
+              stage.usage.cost += usage.cost?.total || 0;
+            }
+            if (!stage.model && msg.model)
+              stage.model = msg.model;
+          }
+          emitUpdate(options);
+        }
+        if (event.type === "tool_result_end" && event.message) {
+          stage.messages.push(event.message);
+          emitUpdate(options);
+        }
+      };
+      proc.stdout.on("data", (data) => {
+        buffer += data.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines)
+          processLine(line);
+      });
+      proc.stderr.on("data", (data) => {
+        stage.stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        if (buffer.trim())
+          processLine(buffer);
+        resolve2(code ?? 0);
+      });
+      proc.on("error", () => resolve2(1));
+      if (options.signal) {
+        const kill = () => {
+          proc.kill("SIGTERM");
+          setTimeout(() => {
+            if (!proc.killed)
+              proc.kill("SIGKILL");
+          }, 5e3);
+        };
+        if (options.signal.aborted)
+          kill();
+        else
+          options.signal.addEventListener("abort", kill, { once: true });
+      }
+    });
+    stage.exitCode = exitCode;
+    stage.status = exitCode === 0 ? "done" : "failed";
+    for (let i = stage.messages.length - 1; i >= 0; i--) {
+      const msg = stage.messages[i];
+      if (msg.role === "assistant") {
+        for (const part of msg.content) {
+          if (typeof part === "object" && "type" in part && part.type === "text" && "text" in part) {
+            stage.output = part.text;
+            break;
+          }
+        }
+        if (stage.output)
+          break;
+      }
+    }
+    emitUpdate(options);
+    return stage;
+  } finally {
+    if (tmpFile)
+      try {
+        fs.unlinkSync(tmpFile);
+      } catch {
+      }
+    if (tmpDir)
+      try {
+        fs.rmdirSync(tmpDir);
+      } catch {
+      }
+  }
+}
+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];
+        if (part?.type === "toolCall") {
+          const name = part.name;
+          const args = part.arguments ?? {};
+          switch (name) {
+            case "bash": {
+              const cmd = (args.command || "").slice(0, 60);
+              return cmd ? `$ ${cmd}` : name;
+            }
+            case "read":
+            case "write":
+            case "edit":
+              return `${name} ${args.file_path ?? args.path ?? ""}`;
+            case "grep":
+              return `grep /${args.pattern ?? ""}/`;
+            case "find":
+              return `find ${args.pattern ?? ""}`;
+            default:
+              return name;
+          }
+        }
+      }
+    }
+  }
+  return "";
+}
+function emitUpdate(options) {
+  if (!options.onUpdate)
+    return;
+  const running = options.stages.find((s) => s.status === "running");
+  let text;
+  if (running) {
+    const lastTool = getLastToolCall(running.messages);
+    text = lastTool ? `[${running.name}] ${lastTool}` : `[${running.name}] running...`;
+  } else {
+    text = options.stages.every((s) => s.status === "done") ? "Pipeline complete" : "Processing...";
+  }
+  options.onUpdate({
+    content: [{ type: "text", text }],
+    details: { pipeline: options.pipeline, stages: options.stages }
+  });
+}
+
+// ../shared/dist/signals.js
+import * as fs2 from "fs";
+import * as path2 from "path";
+function signalPath(cwd, signal) {
+  return path2.join(cwd, SIGNALS[signal]);
+}
+function signalExists(cwd, signal) {
+  return fs2.existsSync(signalPath(cwd, signal));
+}
+function readSignal(cwd, signal) {
+  const p = signalPath(cwd, signal);
+  try {
+    return fs2.readFileSync(p, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function cleanSignal(cwd, signal) {
+  try {
+    fs2.unlinkSync(signalPath(cwd, signal));
+  } catch {
+  }
+}
+
+// src/index.ts
+import { Container, Markdown, Spacer, Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+
+// src/resolve.ts
+import * as path3 from "path";
+import { fileURLToPath } from "url";
+var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+var AGENTS_DIR = path3.resolve(__dirname, "..", "agents");
+
+// src/pipelines/architecture.ts
+async function runArchitecture(cwd, signal, onUpdate, ctx) {
+  const stages = [emptyStage("architecture-reviewer")];
+  const opts = { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline: "architecture", onUpdate };
+  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", text: `Exploration failed: ${exploreResult.output}` }],
+      details: { pipeline: "architecture", stages },
+      isError: true
+    };
+  }
+  if (!ctx.hasUI) {
+    return {
+      content: [{ type: "text", text: exploreResult.output }],
+      details: { pipeline: "architecture", stages }
+    };
+  }
+  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 \u2014 generate RFC", "Skip"]);
+  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.
+
+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}
+
+Run \`/implement ${issueNum}\` to implement it.` : "Architecture RFC issue created.";
+  return {
+    content: [{ type: "text", text: summary }],
+    details: { pipeline: "architecture", stages }
+  };
+}
+
+// src/pipelines/discover-skills.ts
+async function runDiscoverSkills(cwd, query, signal, onUpdate, _ctx) {
+  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}" \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 });
+  return {
+    content: [{ type: "text", text: result.output || "No skills found." }],
+    details: { pipeline: "discover-skills", stages }
+  };
+}
+
+// src/utils/exec.ts
+import { spawn as spawn2 } from "child_process";
+function exec(cmd, cwd) {
+  return new Promise((resolve2) => {
+    const proc = spawn2("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
+function slugify(text, maxLen = 40) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, maxLen).replace(/-$/, "");
+}
+var JIRA_KEY_RE = /^[A-Z]+-\d+$/;
+var JIRA_BRANCH_RE = /feat\/([A-Z]+-\d+)/;
+async function ensureBranch(cwd, branch) {
+  const currentBranch = await exec("git branch --show-current", cwd);
+  if (currentBranch === branch) return;
+  const exists = await exec(`git rev-parse --verify ${branch} 2>/dev/null && echo yes || echo no`, cwd);
+  if (exists === "yes") {
+    await exec(`git checkout ${branch}`, cwd);
+  } else {
+    await exec(`git checkout -b ${branch}`, cwd);
+  }
+}
+async function resolveIssue(cwd, issueArg) {
+  if (issueArg && JIRA_KEY_RE.test(issueArg)) {
+    return resolveJiraIssue(cwd, issueArg);
+  }
+  if (issueArg && /^\d+$/.test(issueArg)) {
+    return resolveGitHubIssue(cwd, parseInt(issueArg, 10));
+  }
+  if (issueArg) {
+    return { source: "github", key: "", number: 0, title: issueArg, body: issueArg, branch: "" };
+  }
+  const branch = await exec("git branch --show-current", cwd);
+  const jiraMatch = branch.match(JIRA_BRANCH_RE);
+  if (jiraMatch) {
+    return resolveJiraIssue(cwd, jiraMatch[1], branch);
+  }
+  const ghMatch = branch.match(/(?:feat\/)?issue-(\d+)/);
+  if (ghMatch) {
+    return resolveGitHubIssue(cwd, parseInt(ghMatch[1], 10));
+  }
+  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);
+  if (!issueJson) return `Could not fetch issue #${issueNum}.`;
+  let issue;
+  try {
+    issue = JSON.parse(issueJson);
+  } catch {
+    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;
+  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);
+  if (!raw) return `Could not fetch Jira issue ${jiraKey}.`;
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return `Could not parse Jira issue ${jiraKey}.`;
+  }
+  const fields = data.fields ?? {};
+  const title = fields.summary ?? jiraKey;
+  const bodyParts = [];
+  if (fields.description) bodyParts.push(fields.description);
+  if (fields.acceptance_criteria) bodyParts.push(`## Acceptance Criteria
+${fields.acceptance_criteria}`);
+  if (fields.status?.name) bodyParts.push(`**Status:** ${fields.status.name}`);
+  if (fields.priority?.name) bodyParts.push(`**Priority:** ${fields.priority.name}`);
+  if (fields.story_points != null) bodyParts.push(`**Story Points:** ${fields.story_points}`);
+  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;
+  return { source: "jira", key: jiraKey, number: 0, title, body, branch, existingPR };
+}
+
+// src/utils/ui.ts
+function setForgeflowStatus(ctx, text) {
+  if (ctx.hasUI) ctx.ui.setStatus("forgeflow-dev", text);
+}
+function setForgeflowWidget(ctx, lines) {
+  if (ctx.hasUI) ctx.ui.setWidget("forgeflow-dev", lines);
+}
+function updateProgressWidget(ctx, progress, totalCost) {
+  let done = 0;
+  for (const [, info] of progress) {
+    if (info.status === "done") done++;
+  }
+  let header = `implement-all \xB7 ${done}/${progress.size}`;
+  if (totalCost > 0) header += ` \xB7 $${totalCost.toFixed(2)}`;
+  const lines = [header];
+  for (const [num, info] of progress) {
+    const icon = info.status === "done" ? "\u2713" : info.status === "running" ? "\u27F3" : info.status === "failed" ? "\u2717" : "\u25CB";
+    const title = info.title.length > 50 ? `${info.title.slice(0, 50)}...` : info.title;
+    lines.push(`  ${icon} #${num} ${title}`);
+  }
+  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 ? `
+
+ADDITIONAL INSTRUCTIONS FROM USER:
+${options.customPrompt}` : "";
+  cleanSignal(cwd, "findings");
+  stages.push(emptyStage("code-reviewer"));
+  await runAgent("code-reviewer", `Review the following diff:
+
+${diff}${extraInstructions}`, {
+    ...opts,
+    tools: TOOLS_NO_EDIT
+  });
+  if (!signalExists(cwd, "findings")) {
+    return { content: [{ type: "text", text: "Review passed \u2014 no actionable findings." }] };
+  }
+  stages.push(emptyStage("review-judge"));
+  const findings = readSignal(cwd, "findings") ?? "";
+  await runAgent(
+    "review-judge",
+    `Validate the following code review findings against the actual code:
+
+${findings}`,
+    { ...opts, tools: TOOLS_NO_EDIT }
+  );
+  if (!signalExists(cwd, "findings")) {
+    return { content: [{ type: "text", text: "Review passed \u2014 judge filtered all findings." }] };
+  }
+  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 };
+}
+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;
+  }
+  const result = await runReviewInline(cwd, signal, onUpdate, ctx, stages, diffCmd, "review", {
+    prNumber,
+    interactive: ctx.hasUI,
+    customPrompt
+  });
+  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 : "";
+    stages.push(emptyStage("fix-findings"));
+    await runAgent(
+      "implementor",
+      `Fix the following code review findings:
+
+${findings}
+
+RULES:
+- Fix only the cited issues. Do not refactor or improve unrelated code.
+- Run the check command after fixes.
+- Commit and push the fixes.`,
+      { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline, onUpdate, tools: TOOLS_ALL, stageName: "fix-findings" }
+    );
+    cleanSignal(cwd, "findings");
+  }
+}
+async function refactorAndReview(cwd, signal, onUpdate, ctx, stages, skipReview, pipeline = "implement") {
+  if (!stages.some((s) => s.name === "refactorer")) stages.push(emptyStage("refactorer"));
+  await runAgent(
+    "refactorer",
+    "Review code added in this branch (git diff main...HEAD). Refactor if clear wins exist. Run checks after changes. Commit and push if changed.",
+    { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline, onUpdate, tools: TOOLS_ALL }
+  );
+  if (!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 questions = [];
+  for (const m of section.matchAll(/^- (.+)$/gm)) {
+    if (m[1]) questions.push(m[1]);
+  }
+  if (questions.length === 0) return plan;
+  let updatedSection = section;
+  for (const q of questions) {
+    const answer = await ctx.ui.input(`${q}`, "Skip to use defaults");
+    if (answer != null && answer.trim() !== "") {
+      updatedSection = updatedSection.replace(`- ${q}`, `- ${q}
+  **Answer:** ${answer.trim()}`);
+    }
+  }
+  return plan.replace(`### Unresolved Questions
+${section}`, `### Unresolved Questions
+${updatedSection}`);
+}
+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}
+
+${resolved.body}` : `Jira ${resolved.key}: ${resolved.title}
+
+${resolved.body}`;
+  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 (resolved.branch) {
+    const branchExists = await exec(
+      `git rev-parse --verify ${resolved.branch} 2>/dev/null && echo yes || echo no`,
+      cwd
+    );
+    if (branchExists === "yes") {
+      await ensureBranch(cwd, resolved.branch);
+      const ahead = await exec(`git rev-list main..${resolved.branch} --count`, cwd);
+      if (parseInt(ahead, 10) > 0) {
+        await exec(`git push -u origin ${resolved.branch}`, cwd);
+        const prBody = isGitHub ? `Closes #${resolved.number}` : `Jira: ${resolved.key}`;
+        await exec(`gh pr create --title "${resolved.title}" --body "${prBody}" --head ${resolved.branch}`, cwd);
+        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 }
+        };
+      }
+    }
+  }
+  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 };
+  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 }
+        };
+      }
+    }
+  }
+  if (resolved.branch) {
+    const currentBranch = await exec("git branch --show-current", cwd);
+    if (currentBranch === "main" || currentBranch === "master") {
+      const dirty = await exec("git status --porcelain", cwd);
+      if (dirty) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Cannot switch to ${resolved.branch} \u2014 working tree is dirty. Please commit or stash your changes first.`
+            }
+          ],
+          details: { pipeline: "implement", stages: [] },
+          isError: true
+        };
+      }
+      await ensureBranch(cwd, resolved.branch);
+      const afterBranch = await exec("git branch --show-current", cwd);
+      if (afterBranch !== resolved.branch) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to switch to ${resolved.branch} (still on ${afterBranch}). Check git state and retry.`
+            }
+          ],
+          details: { pipeline: "implement", stages: [] },
+          isError: true
+        };
+      }
+    }
+  }
+  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 include 'Closes #${resolved.number}' 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
+    };
+  }
+  await refactorAndReview(cwd, signal, onUpdate, ctx, stages, flags.skipReview);
+  let prNumber = "";
+  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 = isGitHub ? `Closes #${resolved.number}` : `Jira: ${resolved.key}`;
+      await exec(`gh pr create --title "${resolved.title}" --body "${prBody}" --head ${resolved.branch}`, cwd);
+      prNumber = await exec(`gh pr list --head "${resolved.branch}" --json number --jq '.[0].number'`, cwd);
+    }
+  }
+  if (!flags.autonomous && prNumber && prNumber !== "null") {
+    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);
+    mergeStage.status = "done";
+    mergeStage.output = `Merged PR #${prNumber}`;
+    onUpdate?.({
+      content: [{ type: "text", text: "Pipeline complete" }],
+      details: { pipeline: "implement", stages }
+    });
+  }
+  return {
+    content: [{ type: "text", text: `Implementation of ${issueLabel} complete.` }],
+    details: { pipeline: "implement", stages }
+  };
+}
+
+// src/pipelines/implement-all.ts
+function getReadyIssues(issues, completed) {
+  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);
+}
+async function runImplementAll(cwd, signal, onUpdate, ctx, flags) {
+  const allStages = [];
+  const issueProgress = /* @__PURE__ */ new Map();
+  const closedJson = await exec(
+    `gh issue list --state closed --label "auto-generated" --json number --jq '.[].number'`,
+    cwd
+  );
+  const completed = new Set(closedJson ? closedJson.split("\n").filter(Boolean).map(Number) : []);
+  let iteration = 0;
+  const maxIterations = 50;
+  while (iteration++ < maxIterations) {
+    if (signal.aborted) break;
+    await exec("git checkout main && git pull --rebase", cwd);
+    const issuesJson = await exec(
+      `gh issue list --state open --label "auto-generated" --json number,title,body --jq 'sort_by(.number)'`,
+      cwd
+    );
+    let issues;
+    try {
+      issues = JSON.parse(issuesJson || "[]");
+    } catch {
+      issues = [];
+    }
+    if (issues.length === 0) {
+      return {
+        content: [{ type: "text", text: "All issues implemented." }],
+        details: { pipeline: "implement-all", stages: allStages }
+      };
+    }
+    for (const issue of issues) {
+      if (!issueProgress.has(issue.number)) {
+        issueProgress.set(issue.number, { title: issue.title, status: "pending" });
+      }
+    }
+    const ready = getReadyIssues(issues, completed);
+    if (ready.length === 0) {
+      return {
+        content: [
+          { type: "text", text: `${issues.length} issues remain but all have unresolved dependencies.` }
+        ],
+        details: { pipeline: "implement-all", stages: allStages },
+        isError: true
+      };
+    }
+    const issueNum = ready[0];
+    const issueTitle = issues.find((i) => i.number === issueNum)?.title ?? `#${issueNum}`;
+    issueProgress.set(issueNum, { title: issueTitle, status: "running" });
+    setForgeflowStatus(
+      ctx,
+      `implement-all \xB7 ${completed.size}/${completed.size + issues.length} \xB7 #${issueNum} ${issueTitle}`
+    );
+    updateProgressWidget(ctx, issueProgress, sumUsage(allStages).cost);
+    allStages.push(emptyStage(`implement-${issueNum}`));
+    const implResult = await runImplement(cwd, String(issueNum), signal, onUpdate, ctx, {
+      ...flags,
+      autonomous: true
+    });
+    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.details?.stages;
+      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",
+            text: `Failed on issue #${issueNum}: ${implResult.content[0]?.type === "text" ? implResult.content[0].text : "unknown error"}`
+          }
+        ],
+        details: { pipeline: "implement-all", stages: allStages },
+        isError: true
+      };
+    }
+    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", 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", text: `No PR found for issue #${issueNum} after implementation.` }],
+        details: { pipeline: "implement-all", stages: allStages },
+        isError: true
+      };
+    }
+    issueProgress.set(issueNum, { title: issueTitle, status: "done" });
+    setForgeflowStatus(
+      ctx,
+      `implement-all \xB7 ${completed.size}/${completed.size + issues.length - 1} \xB7 $${sumUsage(allStages).cost.toFixed(2)}`
+    );
+    updateProgressWidget(ctx, issueProgress, sumUsage(allStages).cost);
+  }
+  return {
+    content: [{ type: "text", text: `Reached max iterations (${maxIterations}).` }],
+    details: { pipeline: "implement-all", stages: allStages }
+  };
+}
+
+// src/index.ts
+function parseImplFlags(args) {
+  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) {
+  const trimmed = args.trim();
+  if (!trimmed) return { target: "", customPrompt: "" };
+  if (trimmed.startsWith("--branch")) {
+    const afterFlag = trimmed.replace(/^--branch\s*/, "").trim();
+    const firstSpace2 = afterFlag.indexOf(" ");
+    if (firstSpace2 === -1) return { target: `--branch ${afterFlag}`, customPrompt: "" };
+    return {
+      target: `--branch ${afterFlag.slice(0, firstSpace2)}`,
+      customPrompt: afterFlag.slice(firstSpace2 + 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) {
+  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"'
+  }),
+  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) {
+  pi.registerTool({
+    name: "forgeflow-dev",
+    label: "Forgeflow Dev",
+    description: [
+      "Run forgeflow dev pipelines: implement (plan\u2192TDD\u2192refactor a single issue),",
+      "implement-all (loop through all open issues autonomously), review (deterministic checks\u2192code review\u2192judge),",
+      "architecture (analyze codebase for structural friction\u2192create RFC issues),",
+      "discover-skills (find and install domain-specific plugins).",
+      "Each pipeline spawns specialized sub-agents with isolated context."
+    ].join(" "),
+    parameters: ForgeflowDevParams,
+    async execute(_toolCallId, _params, signal, onUpdate, ctx) {
+      const params = _params;
+      const cwd = ctx.cwd;
+      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: [] }
+            };
+        }
+      } finally {
+        if (ctx.hasUI) {
+          ctx.ui.setStatus("forgeflow-dev", void 0);
+          ctx.ui.setWidget("forgeflow-dev", void 0);
+        }
+      }
+    },
+    renderCall(_args, theme) {
+      const args = _args;
+      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, { 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);
+    }
+  });
+}
+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", {
+    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 \u2014 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 \u2014 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 \u2014 run autonomously.`
+      );
+    }
+  });
+  pi.registerCommand("review", {
+    description: "Run code review: deterministic checks \u2192 reviewer \u2192 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 \u2014 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 \u2014 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 \u2014 do not summarize or reformat it.`
+        );
+      }
+    }
+  });
+};
+var index_default = extension;
+export {
+  index_default as default
+};