@callumvass/forgeflow-pm 0.1.0

package/extensions/index.js

@@ -0,0 +1,695 @@
+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_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 "";
+}
+
+// ../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));
+}
+
+// src/index.ts
+import { Container, Markdown, Spacer, Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+
+// src/pipelines/continue.ts
+import * as fs3 from "fs";
+
+// 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/continue.ts
+async function runContinue(cwd, description, maxIterations, signal, onUpdate, ctx) {
+  if (!fs3.existsSync(`${cwd}/PRD.md`)) {
+    return {
+      content: [{ type: "text", text: "PRD.md not found." }],
+      details: { pipeline: "continue", stages: [] }
+    };
+  }
+  const stages = [];
+  const opts = { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline: "continue", onUpdate };
+  stages.push(emptyStage("prd-architect"));
+  const updatePrompt = `You are updating a PRD for the next phase of work on an existing project.
+
+1. Read PRD.md to understand the product spec.
+2. Explore the codebase thoroughly \u2014 file structure, existing features, git log, tests, what's actually built.
+3. Compare what the PRD describes vs what exists in code.
+4. Rewrite PRD.md with this structure:
+   - Keep the Problem Statement, Goals, Tech Stack, and other top-level sections
+   - Add or update a \`## Done\` section: a concise summary of what's already built (based on your codebase exploration, not just what the PRD previously said). Keep it brief \u2014 bullet points or short paragraphs describing completed user-facing capabilities.
+   - Add or update a \`## Next\` section: the upcoming work.${description ? ` The user wants the next phase to focus on: ${description}` : ""}
+   - The \`## Next\` section should follow all PRD quality standards \u2014 user stories, functional requirements, edge cases, scope boundaries.
+   - Remove any phase markers like 'Phase 1 (Complete)' \u2014 use Done/Next instead.
+
+5. Keep the total PRD under 200 lines. The Done section should be especially concise \u2014 it's context, not spec.
+
+CRITICAL RULES:
+- Do NOT include code blocks, type definitions, or implementation detail.
+- The Done section summarizes capabilities ('users can create runs and see streaming output'), not architecture ('Hono server with SSE endpoints').
+- The Next section must be specific enough to create vertical-slice issues from.
+- If no description was provided for Next, infer it from the existing PRD's roadmap, scope boundaries, or TODO items.`;
+  const archResult = await runAgent("prd-architect", updatePrompt, { ...opts, tools: TOOLS_ALL });
+  if (archResult.status === "failed") {
+    return {
+      content: [{ type: "text", text: `PRD update failed.
+Stderr: ${archResult.stderr.slice(0, 300)}` }],
+      details: { pipeline: "continue", stages },
+      isError: true
+    };
+  }
+  if (ctx.hasUI) {
+    const prdContent = fs3.readFileSync(`${cwd}/PRD.md`, "utf-8");
+    const edited = await ctx.ui.editor("Review updated PRD (Done/Next structure)", prdContent);
+    if (edited != null && edited !== prdContent) {
+      fs3.writeFileSync(`${cwd}/PRD.md`, edited, "utf-8");
+    }
+    const action = await ctx.ui.select("PRD updated with Done/Next. What next?", ["Continue to QA", "Stop here"]);
+    if (action === "Stop here" || action == null) {
+      return {
+        content: [{ type: "text", text: "PRD updated. Stopped before QA." }],
+        details: { pipeline: "continue", stages }
+      };
+    }
+  }
+  for (let i = 1; i <= maxIterations; i++) {
+    stages.push(emptyStage("prd-critic"));
+    const criticResult = await runAgent(
+      "prd-critic",
+      "Review PRD.md for completeness \u2014 focus on the ## Next section. If it needs refinement, create QUESTIONS.md. If it's complete, do NOT create QUESTIONS.md.",
+      { ...opts, tools: TOOLS_NO_EDIT }
+    );
+    if (!signalExists(cwd, "questions")) {
+      if (criticResult.status === "failed") {
+        return {
+          content: [{ type: "text", text: `Critic failed.
+Stderr: ${criticResult.stderr.slice(0, 300)}` }],
+          details: { pipeline: "continue", stages },
+          isError: true
+        };
+      }
+      break;
+    }
+    stages.push(emptyStage("prd-architect"));
+    await runAgent(
+      "prd-architect",
+      "Read PRD.md and answer all questions in QUESTIONS.md. Write answers inline in QUESTIONS.md.",
+      { ...opts, tools: TOOLS_ALL }
+    );
+    stages.push(emptyStage("prd-integrator"));
+    await runAgent(
+      "prd-integrator",
+      "Incorporate answers from QUESTIONS.md into PRD.md, then delete QUESTIONS.md.",
+      opts
+    );
+    if (ctx.hasUI) {
+      const prdContent = fs3.readFileSync(`${cwd}/PRD.md`, "utf-8");
+      const edited = await ctx.ui.editor(`QA iteration ${i} \u2014 Review PRD`, prdContent);
+      if (edited != null && edited !== prdContent) {
+        fs3.writeFileSync(`${cwd}/PRD.md`, edited, "utf-8");
+      }
+      const action = await ctx.ui.select("PRD updated. What next?", ["Continue refining", "Accept PRD"]);
+      if (action === "Accept PRD" || action == null) break;
+    }
+  }
+  stages.push(emptyStage("issue-creator"));
+  await runAgent(
+    "issue-creator",
+    "Decompose PRD.md into vertical-slice GitHub issues. Focus on the ## Next section \u2014 the ## Done section is context only. Read the issue-template skill for the standard format.",
+    { ...opts, tools: TOOLS_NO_EDIT }
+  );
+  return {
+    content: [{ type: "text", text: "Continue pipeline complete. PRD updated, QA'd, and issues created." }],
+    details: { pipeline: "continue", stages }
+  };
+}
+
+// src/pipelines/create-issues.ts
+import * as fs4 from "fs";
+async function runCreateIssue(cwd, idea, signal, onUpdate, _ctx) {
+  if (!idea) {
+    return {
+      content: [{ type: "text", text: "No feature idea provided." }],
+      details: { pipeline: "create-issue", stages: [] }
+    };
+  }
+  const stages = [emptyStage("single-issue-creator")];
+  const opts = { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline: "create-issue", onUpdate };
+  await runAgent("single-issue-creator", idea, { ...opts, tools: TOOLS_NO_EDIT });
+  return {
+    content: [{ type: "text", text: "Issue created." }],
+    details: { pipeline: "create-issue", stages }
+  };
+}
+async function runCreateIssues(cwd, signal, onUpdate, _ctx) {
+  if (!fs4.existsSync(`${cwd}/PRD.md`)) {
+    return {
+      content: [{ type: "text", text: "PRD.md not found." }],
+      details: { pipeline: "create-issues", stages: [] }
+    };
+  }
+  const stages = [emptyStage("issue-creator")];
+  const opts = { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline: "create-issues", onUpdate };
+  await runAgent(
+    "issue-creator",
+    "Decompose PRD.md into vertical-slice GitHub issues. Read the issue-template skill for the standard format.",
+    { ...opts, tools: TOOLS_NO_EDIT }
+  );
+  return {
+    content: [{ type: "text", text: "Issue creation complete." }],
+    details: { pipeline: "create-issues", stages }
+  };
+}
+
+// src/pipelines/prd-qa.ts
+import * as fs5 from "fs";
+async function runPrdQa(cwd, maxIterations, signal, onUpdate, ctx) {
+  if (!fs5.existsSync(`${cwd}/PRD.md`)) {
+    return {
+      content: [{ type: "text", text: "PRD.md not found." }],
+      details: { pipeline: "prd-qa", stages: [] }
+    };
+  }
+  const stages = [];
+  const opts = { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline: "prd-qa", onUpdate };
+  for (let i = 1; i <= maxIterations; i++) {
+    stages.push(emptyStage("prd-critic"));
+    const criticResult = await runAgent(
+      "prd-critic",
+      "Review PRD.md for completeness. If it needs refinement, create QUESTIONS.md. If it's complete, do NOT create QUESTIONS.md.",
+      { ...opts, tools: TOOLS_NO_EDIT }
+    );
+    if (!signalExists(cwd, "questions")) {
+      if (criticResult.status === "failed") {
+        return {
+          content: [{ type: "text", text: `Critic failed.
+Stderr: ${criticResult.stderr.slice(0, 300)}` }],
+          details: { pipeline: "prd-qa", stages },
+          isError: true
+        };
+      }
+      return {
+        content: [{ type: "text", text: "PRD refinement complete. Ready for /create-issues." }],
+        details: { pipeline: "prd-qa", stages }
+      };
+    }
+    stages.push(emptyStage("prd-architect"));
+    await runAgent(
+      "prd-architect",
+      "Read PRD.md and answer all questions in QUESTIONS.md. Write answers inline in QUESTIONS.md.",
+      { ...opts, tools: TOOLS_ALL }
+    );
+    stages.push(emptyStage("prd-integrator"));
+    await runAgent(
+      "prd-integrator",
+      "Incorporate answers from QUESTIONS.md into PRD.md, then delete QUESTIONS.md.",
+      opts
+    );
+    if (ctx.hasUI) {
+      const prdContent = fs5.readFileSync(`${cwd}/PRD.md`, "utf-8");
+      const edited = await ctx.ui.editor(`Iteration ${i} \u2014 Review PRD (edit or close to continue)`, prdContent);
+      if (edited != null && edited !== prdContent) {
+        fs5.writeFileSync(`${cwd}/PRD.md`, edited, "utf-8");
+      }
+      const action = await ctx.ui.select("PRD updated. What next?", ["Continue refining", "Accept PRD"]);
+      if (action === "Accept PRD" || action == null) {
+        return {
+          content: [{ type: "text", text: "PRD accepted." }],
+          details: { pipeline: "prd-qa", stages }
+        };
+      }
+    }
+  }
+  return {
+    content: [{ type: "text", text: `PRD refinement did not complete after ${maxIterations} iterations.` }],
+    details: { pipeline: "prd-qa", stages }
+  };
+}
+
+// src/index.ts
+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 ForgeflowPmParams = Type.Object({
+  pipeline: Type.String({
+    description: 'Which pipeline to run: "continue", "prd-qa", "create-issues", or "create-issue"'
+  }),
+  maxIterations: Type.Optional(Type.Number({ description: "Max iterations for prd-qa (default 10)" })),
+  issue: Type.Optional(Type.String({ description: "Feature idea for create-issue, or description for continue" }))
+});
+function registerForgeflowPmTool(pi) {
+  pi.registerTool({
+    name: "forgeflow-pm",
+    label: "Forgeflow PM",
+    description: [
+      "Run forgeflow PM pipelines: continue (update PRD Done/Next\u2192QA\u2192create issues for next phase),",
+      "prd-qa (refine PRD), create-issues (decompose PRD into GitHub issues),",
+      "create-issue (single issue from a feature idea).",
+      "Each pipeline spawns specialized sub-agents with isolated context."
+    ].join(" "),
+    parameters: ForgeflowPmParams,
+    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 "continue":
+            return await runContinue(cwd, params.issue ?? "", params.maxIterations ?? 10, sig, onUpdate, ctx);
+          case "prd-qa":
+            return await runPrdQa(cwd, params.maxIterations ?? 10, sig, onUpdate, ctx);
+          case "create-issues":
+            return await runCreateIssues(cwd, sig, onUpdate, ctx);
+          case "create-issue":
+            return await runCreateIssue(cwd, params.issue ?? "", sig, onUpdate, ctx);
+          default:
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Unknown pipeline: ${params.pipeline}. Use: continue, prd-qa, create-issues, create-issue`
+                }
+              ],
+              details: { pipeline: params.pipeline, stages: [] }
+            };
+        }
+      } finally {
+        if (ctx.hasUI) {
+          ctx.ui.setStatus("forgeflow-pm", void 0);
+          ctx.ui.setWidget("forgeflow-pm", void 0);
+        }
+      }
+    },
+    renderCall(_args, theme) {
+      const args = _args;
+      const pipeline = args.pipeline || "?";
+      let text = theme.fg("toolTitle", theme.bold("forgeflow-pm ")) + theme.fg("accent", pipeline);
+      if (args.issue) text += theme.fg("dim", ` "${args.issue}"`);
+      if (args.maxIterations) text += theme.fg("muted", ` (max ${args.maxIterations})`);
+      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-pm ")) + 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-pm ")) + 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) => {
+  registerForgeflowPmTool(pi);
+  pi.registerCommand("continue", {
+    description: 'Update PRD with Done/Next based on codebase state, QA the Next section, then create issues. Usage: /continue ["description of next phase"]',
+    handler: async (args) => {
+      const trimmed = args.trim().replace(/^"(.*)"$/, "$1");
+      const descPart = trimmed ? `, issue="${trimmed}"` : "";
+      pi.sendUserMessage(
+        `Call the forgeflow-pm tool now with these exact parameters: pipeline="continue"${descPart}. Do not interpret the description \u2014 pass it as-is.`
+      );
+    }
+  });
+  pi.registerCommand("prd-qa", {
+    description: "Refine PRD.md via critic \u2192 architect \u2192 integrator loop",
+    handler: async (args) => {
+      const maxIter = parseInt(args, 10) || 10;
+      pi.sendUserMessage(
+        `Call the forgeflow-pm tool now with these exact parameters: pipeline="prd-qa", maxIterations=${maxIter}.`
+      );
+    }
+  });
+  pi.registerCommand("create-issues", {
+    description: "Decompose PRD.md into vertical-slice GitHub issues",
+    handler: async () => {
+      pi.sendUserMessage(`Call the forgeflow-pm tool now with these exact parameters: pipeline="create-issues".`);
+    }
+  });
+  pi.registerCommand("create-issue", {
+    description: "Create a single GitHub issue from a feature idea",
+    handler: async (args) => {
+      if (!args.trim()) {
+        pi.sendUserMessage('I need a feature idea. Usage: /create-issue "Add user authentication"');
+        return;
+      }
+      pi.sendUserMessage(
+        `Call the forgeflow-pm tool now with these exact parameters: pipeline="create-issue", issue="${args.trim()}". Do not interpret the issue text \u2014 pass it as-is.`
+      );
+    }
+  });
+};
+var index_default = extension;
+export {
+  index_default as default
+};