@callumvass/forgeflow-pm 0.1.0

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@callumvass/forgeflow-pm",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "PM pipeline for Pi — PRD refinement, issue creation, and continue.",
+  "keywords": [
+    "pi-package"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/callumvass/forgeflow.git",
+    "directory": "packages/pm"
+  },
+  "publishConfig": {
+    "provenance": true
+  },
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ],
+    "skills": [
+      "./skills"
+    ],
+    "agents": [
+      "./agents"
+    ]
+  },
+  "scripts": {
+    "build": "tsup"
+  },
+  "dependencies": {
+    "@callumvass/forgeflow-shared": "*"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-agent-core": "*",
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*",
+    "@sinclair/typebox": "*"
+  }
+}

package/skills/issue-template/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: issue-template
+description: Standard format and rules for creating GitHub issues for autonomous agent implementation.
+---
+
+# Issue Template Skill
+
+## Issue Template
+
+Every issue MUST follow this exact format:
+
+```
+Title: <short descriptive title>
+
+Body:
+## Context
+<Provide enough detail for an agent to implement THIS slice. Include: user-observable behavior, relevant data model (conceptual), API contracts, technology choices, edge cases. Do NOT include: type definitions, internal state shapes, config blocks, file layout, or framework-specific patterns. Keep under ~60 lines.>
+
+## Acceptance Criteria
+<Bulleted checklist describing what the USER sees/experiences. Not implementation details.>
+- [ ] User does X and sees Y
+- [ ] ...
+
+## Test Plan
+<Specific tests that must pass. FIRST test must be a trigger test.>
+- [ ] Trigger: <entry-point → observable output, proving the slice is wired end-to-end>
+- [ ] Boundary: <describe test through real runtime or route-level render>
+- [ ] Unit (only if pure algorithm): <describe algorithmic edge case test>
+
+## Implementation Hints
+<Concrete guidance: files to create/modify, key APIs, rough approach. Keep it actionable.>
+
+## Dependencies
+<Which previous issues must be complete first, if any>
+```
+
+## Creating Issues
+
+- Use `gh issue create` to create each issue.
+- Add the `auto-generated` label to every issue (create the label first if it doesn't exist).
+- After creating each issue, note its number so you can reference it in subsequent issues' Dependencies sections.
+
+## Rules
+
+- The Context section is CRITICAL — the agent works from this alone. Include behavioral requirements, data model concepts, API contracts, and edge cases inline. Do NOT say "see PRD.md".
+- Acceptance criteria must describe user-observable behavior, not code structure.
+- Each vertical slice must cross all necessary layers to deliver a working flow.
+- **Design is per-slice, not a final pass.** If DESIGN.md exists, every slice that touches UI must implement its screens using the design system.
+- **No standalone validation/edge-case issues.** Validation, error handling, and edge cases belong in the slice that introduces the behavior.
+- **No standalone polish issues.** Accessibility, responsive layout, and design compliance belong in each slice.

package/skills/prd-quality/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: prd-quality
+description: PRD completeness and quality criteria for evaluating product requirements documents.
+---
+
+This skill defines the quality criteria for evaluating whether a PRD is complete and implementation-ready.
+
+## Completeness Criteria
+
+A PRD is ready for implementation when it satisfies ALL of the following:
+
+### 1. Problem Statement & Goals
+- Clear description of the problem being solved
+- Measurable success criteria or goals
+- Why this matters (user pain, business value)
+
+### 2. User Stories / Use Cases
+- Clear actors (who does what)
+- Each story follows a complete flow from trigger to outcome
+- Covers primary happy paths and key alternative paths
+
+### 3. Functional Requirements
+- Detailed enough that a developer can implement without further clarification
+- Covers inputs, outputs, and transformations for each feature
+- API contracts as prose: "POST /api/rooms creates a room and returns a room code" — NOT code blocks
+- Data model as concepts: "a room tracks voters, their votes, and the current poll" — NOT type definitions
+
+### 4. Non-Functional Requirements
+- Performance expectations (latency, throughput)
+- Security considerations (auth model, data protection, input validation)
+- Scalability constraints or targets
+- Reliability/availability requirements if relevant
+
+### 5. Edge Cases & Error Handling
+- Each flow identifies what can go wrong
+- Error states have defined user-facing behavior
+- Boundary conditions are addressed (empty states, limits, concurrent access)
+
+### 6. Scope Boundaries
+- Explicit "in scope" and "out of scope" sections
+- No ambiguity about what will and won't be built
+
+### 6a. Phase Structure (for multi-phase projects)
+- If the project has prior work, the PRD should contain a `## Done` section summarizing completed work
+- The `## Next` section describes what's being built now
+- `## Done` is treated as accepted context — not re-evaluated for completeness
+- Only `## Next` is evaluated against these criteria
+
+### 7. Vertical-Slice Readiness
+- Requirements are structured around user-observable flows, not technical layers
+- Each feature can be decomposed into end-to-end slices
+- No requirement depends on a fully-built layer that doesn't yet exist
+
+### 8. Implementation Clarity
+- Enough technical detail to know WHAT to build and which technologies to use — not HOW to structure code
+- Technology choices specified where they matter, with brief rationale
+- Key library/dependency choices include version or API generation details when relevant
+- Integration points with existing systems documented
+- Do NOT include: type definitions, internal state shapes, file/directory layout, framework-specific patterns, config file contents, or specific hex colors/pixel values
+
+### 9. Specification Minimalism
+- PRD describes behavior (what the system does), not implementation (how code is structured)
+- ZERO code blocks allowed in the PRD
+- "Swap test": if a detail would change when swapping to an equivalent library but the behavior stays the same, it's implementation detail — remove it
+- Technology choices name the tool and justify why — they do not prescribe usage patterns
+- Data models describe entities and relationships conceptually, not as language-level types
+- API contracts define endpoints and response descriptions in prose, not code blocks
+- Target ~150-200 lines for the entire PRD
+- A PRD with complete behavioral requirements at 150 lines is BETTER than one with implementation detail at 300 lines

package/src/index.ts

@@ -0,0 +1,280 @@
+import { type AnyCtx, getFinalOutput, type PipelineDetails, type StageResult } from "@callumvass/forgeflow-shared";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Container, Markdown, Spacer, Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { runContinue } from "./pipelines/continue.js";
+import { runCreateIssue, runCreateIssues } from "./pipelines/create-issues.js";
+import { runPrdQa } from "./pipelines/prd-qa.js";
+
+// ─── Display helpers ──────────────────────────────────────────────────
+
+type DisplayItem = { type: "text"; text: string } | { type: "toolCall"; name: string; args: Record<string, unknown> };
+
+interface ForgeflowPmInput {
+  pipeline: string;
+  maxIterations?: number;
+  issue?: string;
+}
+
+function getDisplayItems(messages: AnyCtx[]): DisplayItem[] {
+  const items: DisplayItem[] = [];
+  for (const msg of messages) {
+    if (msg.role === "assistant") {
+      for (const part of msg.content) {
+        if (part.type === "text") items.push({ type: "text", text: part.text });
+        else if (part.type === "toolCall") items.push({ type: "toolCall", name: part.name, args: part.arguments });
+      }
+    }
+  }
+  return items;
+}
+
+function formatToolCallShort(
+  name: string,
+  args: Record<string, unknown>,
+  fg: (c: string, t: string) => string,
+): string {
+  switch (name) {
+    case "bash": {
+      const cmd = (args.command as string) || "...";
+      return fg("muted", "$ ") + fg("toolOutput", cmd.length > 60 ? `${cmd.slice(0, 60)}...` : cmd);
+    }
+    case "read":
+      return fg("muted", "read ") + fg("accent", (args.file_path || args.path || "...") as string);
+    case "write":
+      return fg("muted", "write ") + fg("accent", (args.file_path || args.path || "...") as string);
+    case "edit":
+      return fg("muted", "edit ") + fg("accent", (args.file_path || args.path || "...") as string);
+    case "grep":
+      return fg("muted", "grep ") + fg("accent", `/${args.pattern || ""}/`);
+    case "find":
+      return fg("muted", "find ") + fg("accent", (args.pattern || "*") as string);
+    default:
+      return fg("accent", name);
+  }
+}
+
+function formatUsage(usage: { input: number; output: number; cost: number; turns: number }, model?: string): string {
+  const parts: string[] = [];
+  if (usage.turns) parts.push(`${usage.turns}t`);
+  if (usage.input) parts.push(`↑${usage.input < 1000 ? usage.input : `${Math.round(usage.input / 1000)}k`}`);
+  if (usage.output) parts.push(`↓${usage.output < 1000 ? usage.output : `${Math.round(usage.output / 1000)}k`}`);
+  if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
+  if (model) parts.push(model);
+  return parts.join(" ");
+}
+
+// ─── Tool registration ────────────────────────────────────────────────
+
+const 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: ExtensionAPI) {
+  pi.registerTool({
+    name: "forgeflow-pm",
+    label: "Forgeflow PM",
+    description: [
+      "Run forgeflow PM pipelines: continue (update PRD Done/Next→QA→create 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 as AnyCtx,
+
+    async execute(
+      _toolCallId: string,
+      _params: unknown,
+      signal: AbortSignal | undefined,
+      onUpdate: AnyCtx,
+      ctx: AnyCtx,
+    ) {
+      const params = _params as ForgeflowPmInput;
+      const cwd = ctx.cwd as string;
+      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: [] } as PipelineDetails,
+            };
+        }
+      } finally {
+        if (ctx.hasUI) {
+          ctx.ui.setStatus("forgeflow-pm", undefined);
+          ctx.ui.setWidget("forgeflow-pm", undefined);
+        }
+      }
+    },
+
+    renderCall(_args: unknown, theme: AnyCtx) {
+      const args = _args as ForgeflowPmInput;
+      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: AnyCtx, { expanded }: { expanded: boolean }, theme: AnyCtx) {
+      const details = result.details as PipelineDetails | undefined;
+      if (!details || details.stages.length === 0) {
+        const text = result.content[0];
+        return new Text(text?.type === "text" ? text.text : "(no output)", 0, 0);
+      }
+
+      if (expanded) {
+        return renderExpanded(details, theme);
+      }
+      return renderCollapsed(details, theme);
+    },
+  });
+}
+
+// ─── Rendering ────────────────────────────────────────────────────────
+
+function renderExpanded(details: PipelineDetails, theme: AnyCtx) {
+  const container = new Container();
+  container.addChild(
+    new Text(theme.fg("toolTitle", theme.bold("forgeflow-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", "→ ")}${formatToolCallShort(item.name, item.args, theme.fg.bind(theme))}`,
+            0,
+            0,
+          ),
+        );
+      }
+    }
+
+    const output = getFinalOutput(stage.messages);
+    if (output) {
+      container.addChild(new Spacer(1));
+      try {
+        const { getMarkdownTheme } = require("@mariozechner/pi-coding-agent");
+        container.addChild(new Markdown(output.trim(), 0, 0, getMarkdownTheme()));
+      } catch {
+        container.addChild(new Text(theme.fg("toolOutput", output.slice(0, 500)), 0, 0));
+      }
+    }
+
+    const usageStr = formatUsage(stage.usage, stage.model);
+    if (usageStr) container.addChild(new Text(theme.fg("dim", usageStr), 0, 0));
+    container.addChild(new Spacer(1));
+  }
+
+  return container;
+}
+
+function renderCollapsed(details: PipelineDetails, theme: AnyCtx) {
+  let text = theme.fg("toolTitle", theme.bold("forgeflow-pm ")) + theme.fg("accent", details.pipeline);
+  for (const stage of details.stages) {
+    const icon = stageIcon(stage, theme);
+    text += `\n  ${icon} ${theme.fg("toolTitle", stage.name)}`;
+
+    if (stage.status === "running") {
+      const items = getDisplayItems(stage.messages);
+      const last = items.filter((i) => i.type === "toolCall").slice(-3);
+      for (const item of last) {
+        if (item.type === "toolCall") {
+          text += `\n    ${theme.fg("muted", "→ ")}${formatToolCallShort(item.name, item.args, theme.fg.bind(theme))}`;
+        }
+      }
+    } else if (stage.status === "done" || stage.status === "failed") {
+      const preview = stage.output.split("\n")[0]?.slice(0, 80) || "(no output)";
+      text += theme.fg("dim", ` ${preview}`);
+      const usageStr = formatUsage(stage.usage, stage.model);
+      if (usageStr) text += ` ${theme.fg("dim", usageStr)}`;
+    }
+  }
+  return new Text(text, 0, 0);
+}
+
+function stageIcon(stage: StageResult, theme: AnyCtx): string {
+  return stage.status === "done"
+    ? theme.fg("success", "✓")
+    : stage.status === "running"
+      ? theme.fg("warning", "⟳")
+      : stage.status === "failed"
+        ? theme.fg("error", "✗")
+        : theme.fg("muted", "○");
+}
+
+// ─── Extension entry point ────────────────────────────────────────────
+
+const extension: (pi: ExtensionAPI) => void = (pi) => {
+  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 — pass it as-is.`,
+      );
+    },
+  });
+
+  pi.registerCommand("prd-qa", {
+    description: "Refine PRD.md via critic → architect → 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 — pass it as-is.`,
+      );
+    },
+  });
+};
+
+export default extension;

package/src/pipelines/continue.ts

@@ -0,0 +1,138 @@
+import * as fs from "node:fs";
+import {
+  type AnyCtx,
+  emptyStage,
+  runAgent,
+  type StageResult,
+  signalExists,
+  TOOLS_ALL,
+  TOOLS_NO_EDIT,
+} from "@callumvass/forgeflow-shared";
+import { AGENTS_DIR } from "../resolve.js";
+
+/**
+ * Continue pipeline: update PRD with Done/Next, run QA loop, create issues.
+ */
+export async function runContinue(
+  cwd: string,
+  description: string,
+  maxIterations: number,
+  signal: AbortSignal,
+  onUpdate: AnyCtx,
+  ctx: AnyCtx,
+) {
+  if (!fs.existsSync(`${cwd}/PRD.md`)) {
+    return {
+      content: [{ type: "text" as const, text: "PRD.md not found." }],
+      details: { pipeline: "continue", stages: [] },
+    };
+  }
+
+  const stages: StageResult[] = [];
+  const opts = { agentsDir: AGENTS_DIR, cwd, signal, stages, pipeline: "continue", onUpdate };
+
+  // Phase 1: Update PRD with Done/Next structure
+  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 — 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 — 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 — user stories, functional requirements, edge cases, scope boundaries.
+   - Remove any phase markers like 'Phase 1 (Complete)' — use Done/Next instead.
+
+5. Keep the total PRD under 200 lines. The Done section should be especially concise — 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" as const, text: `PRD update failed.\nStderr: ${archResult.stderr.slice(0, 300)}` }],
+      details: { pipeline: "continue", stages },
+      isError: true,
+    };
+  }
+
+  // Approval gate after PRD update
+  if (ctx.hasUI) {
+    const prdContent = fs.readFileSync(`${cwd}/PRD.md`, "utf-8");
+    const edited = await ctx.ui.editor("Review updated PRD (Done/Next structure)", prdContent);
+    if (edited != null && edited !== prdContent) {
+      fs.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" as const, text: "PRD updated. Stopped before QA." }],
+        details: { pipeline: "continue", stages },
+      };
+    }
+  }
+
+  // Phase 2: PRD QA loop on the Next section
+  for (let i = 1; i <= maxIterations; i++) {
+    stages.push(emptyStage("prd-critic"));
+    const criticResult = await runAgent(
+      "prd-critic",
+      "Review PRD.md for completeness — 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" as const, text: `Critic failed.\nStderr: ${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 = fs.readFileSync(`${cwd}/PRD.md`, "utf-8");
+      const edited = await ctx.ui.editor(`QA iteration ${i} — Review PRD`, prdContent);
+      if (edited != null && edited !== prdContent) {
+        fs.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;
+    }
+  }
+
+  // Phase 3: Create issues from the Next section
+  stages.push(emptyStage("issue-creator"));
+  await runAgent(
+    "issue-creator",
+    "Decompose PRD.md into vertical-slice GitHub issues. Focus on the ## Next section — the ## Done section is context only. Read the issue-template skill for the standard format.",
+    { ...opts, tools: TOOLS_NO_EDIT },
+  );
+
+  return {
+    content: [{ type: "text" as const, text: "Continue pipeline complete. PRD updated, QA'd, and issues created." }],
+    details: { pipeline: "continue", stages },
+  };
+}

package/src/pipelines/create-issues.ts

@@ -0,0 +1,45 @@
+import * as fs from "node:fs";
+import { type AnyCtx, emptyStage, runAgent, TOOLS_NO_EDIT } from "@callumvass/forgeflow-shared";
+import { AGENTS_DIR } from "../resolve.js";
+
+export async function runCreateIssue(cwd: string, idea: string, signal: AbortSignal, onUpdate: AnyCtx, _ctx: AnyCtx) {
+  if (!idea) {
+    return {
+      content: [{ type: "text" as const, 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" as const, text: "Issue created." }],
+    details: { pipeline: "create-issue", stages },
+  };
+}
+
+export async function runCreateIssues(cwd: string, signal: AbortSignal, onUpdate: AnyCtx, _ctx: AnyCtx) {
+  if (!fs.existsSync(`${cwd}/PRD.md`)) {
+    return {
+      content: [{ type: "text" as const, 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" as const, text: "Issue creation complete." }],
+    details: { pipeline: "create-issues", stages },
+  };
+}