issue-flow 0.3.0

package/dist/run-J62FIB5O.js

@@ -0,0 +1,288 @@
+#!/usr/bin/env node
+import {
+  runReview
+} from "./chunk-D4WBCVB4.js";
+import {
+  runInit
+} from "./chunk-JEUHCE3V.js";
+import {
+  runAnalyze
+} from "./chunk-7APADNBV.js";
+import {
+  runExecute
+} from "./chunk-V356G3JS.js";
+import {
+  runPlan
+} from "./chunk-ZOX7M2C2.js";
+import {
+  runPr
+} from "./chunk-7FRXZ2XA.js";
+import {
+  runPrd
+} from "./chunk-G36DIQ4J.js";
+import "./chunk-PINC2LST.js";
+import {
+  isoNow,
+  loadTaskPlan,
+  saveTaskPlan
+} from "./chunk-64FU2L2T.js";
+import "./chunk-OZVHOVDT.js";
+import {
+  printError,
+  printInfo,
+  printSuccess,
+  printWarning
+} from "./chunk-L7RIGFP6.js";
+
+// src/commands/run.ts
+import { join } from "path";
+import { execa } from "execa";
+
+// src/core/pipeline.ts
+var PIPELINE_PHASES = [
+  "init",
+  "analyze",
+  "prd",
+  "plan",
+  "execute",
+  "review",
+  "pr"
+];
+var PHASE_TO_FIELD = {
+  init: null,
+  analyze: "analyzeCompleted",
+  prd: "prdCompleted",
+  plan: "jsonCompleted",
+  execute: "executionCompleted",
+  review: "reviewCompleted",
+  pr: "prCreated"
+};
+var PipelineManager = class {
+  tasksJsonPath;
+  plan;
+  constructor(plan, tasksJsonPath) {
+    this.plan = plan;
+    this.tasksJsonPath = tasksJsonPath;
+  }
+  /**
+   * Reload state from disk.
+   */
+  async reload() {
+    this.plan = await loadTaskPlan(this.tasksJsonPath);
+  }
+  /**
+   * Check if a phase is complete.
+   */
+  isPhaseComplete(phase) {
+    const field = PHASE_TO_FIELD[phase];
+    if (field === null) return true;
+    return this.plan.pipeline?.[field] ?? false;
+  }
+  /**
+   * Get the first incomplete phase in the pipeline.
+   * Returns null if all phases are complete.
+   */
+  getNextPhase() {
+    for (const phase of PIPELINE_PHASES) {
+      if (!this.isPhaseComplete(phase)) {
+        return phase;
+      }
+    }
+    return null;
+  }
+  /**
+   * Get the current phase (alias for getNextPhase).
+   */
+  getCurrentPhase() {
+    return this.getNextPhase();
+  }
+  /**
+   * Check whether we can resume from a specific phase.
+   * All prerequisite phases must be complete.
+   */
+  canResume(fromPhase) {
+    const idx = PIPELINE_PHASES.indexOf(fromPhase);
+    if (idx < 0) return false;
+    for (let i = 0; i < idx; i++) {
+      if (!this.isPhaseComplete(PIPELINE_PHASES[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Mark a phase as complete and persist to disk.
+   */
+  async markPhaseComplete(phase) {
+    const field = PHASE_TO_FIELD[phase];
+    if (field === null) return;
+    this.plan = {
+      ...this.plan,
+      pipeline: {
+        ...this.plan.pipeline ?? {
+          analyzeCompleted: false,
+          prdCompleted: false,
+          jsonCompleted: false,
+          executionCompleted: false,
+          reviewCompleted: false,
+          prCreated: false
+        },
+        [field]: true
+      }
+    };
+    await saveTaskPlan(this.tasksJsonPath, this.plan);
+  }
+};
+
+// src/commands/run.ts
+async function runPipeline(issue, mode, from) {
+  const issueNumber = issue.replace(/^#/, "");
+  const issueDir = join("issues", issueNumber);
+  const tasksPath = join(issueDir, "tasks.json");
+  printInfo(`Starting pipeline for issue #${issueNumber} (mode: ${mode})`);
+  printInfo("Running prerequisite checks...");
+  const initCode = await runInit();
+  if (initCode !== 0) {
+    printError("Prerequisites not met. Fix the issues above and try again.");
+    return 1;
+  }
+  let startPhase = "analyze";
+  if (from) {
+    if (!PIPELINE_PHASES.includes(from)) {
+      printError(`Invalid phase: ${from}. Valid phases: ${PIPELINE_PHASES.join(", ")}`);
+      return 1;
+    }
+    startPhase = from;
+  } else {
+    try {
+      const plan = await loadTaskPlan(tasksPath);
+      const mgr = new PipelineManager(plan, tasksPath);
+      const nextPhase = mgr.getNextPhase();
+      if (nextPhase && nextPhase !== "init") {
+        startPhase = nextPhase;
+        printInfo(`Resuming from phase: ${startPhase}`);
+      }
+    } catch {
+    }
+  }
+  if (from) {
+    try {
+      const plan = await loadTaskPlan(tasksPath);
+      const mgr = new PipelineManager(plan, tasksPath);
+      if (!mgr.canResume(startPhase)) {
+        printError(`Cannot resume from ${startPhase}: prerequisite phases not complete`);
+        return 1;
+      }
+    } catch {
+      if (startPhase !== "analyze") {
+        printError(`Cannot resume from ${startPhase}: no pipeline state found`);
+        return 1;
+      }
+    }
+  }
+  const phaseOrder = ["analyze", "prd", "plan", "execute", "review", "pr"];
+  const startIdx = phaseOrder.indexOf(startPhase);
+  for (let i = startIdx; i < phaseOrder.length; i++) {
+    const phase = phaseOrder[i];
+    printInfo(`
+--- Phase: ${phase} ---`);
+    let code;
+    switch (phase) {
+      case "analyze":
+        code = await runAnalyze(issueNumber);
+        break;
+      case "prd":
+        code = await runPrd(issueNumber);
+        break;
+      case "plan":
+        code = await runPlan(issueNumber);
+        break;
+      case "execute":
+        code = await runExecute(void 0, { issue: issueNumber });
+        break;
+      case "review": {
+        let maxCycles = 3;
+        try {
+          const plan = await loadTaskPlan(tasksPath);
+          maxCycles = plan.maxCorrectionCycles;
+        } catch {
+        }
+        code = await runReview(issueNumber);
+        let cycle = 0;
+        while (code !== 0 && cycle < maxCycles) {
+          cycle++;
+          printWarning(`Review failed. Starting correction cycle ${cycle}/${maxCycles}...`);
+          try {
+            const plan = await loadTaskPlan(tasksPath);
+            plan.correctionCycle = cycle;
+            await saveTaskPlan(tasksPath, plan);
+          } catch {
+          }
+          const execCode = await runExecute(void 0, { issue: issueNumber });
+          if (execCode !== 0) {
+            printError("Correction execution failed");
+            return 1;
+          }
+          code = await runReview(issueNumber);
+        }
+        if (code !== 0) {
+          printError(`Review failed after ${maxCycles} correction cycles`);
+          return 1;
+        }
+        break;
+      }
+      case "pr":
+        code = await runPr(issueNumber);
+        break;
+      default:
+        code = 1;
+    }
+    if (code !== 0) {
+      printError(`Phase ${phase} failed with exit code ${code}`);
+      return 1;
+    }
+  }
+  printInfo("Closing issue...");
+  try {
+    await execa("gh", ["issue", "close", issueNumber], { reject: false });
+  } catch {
+    printWarning("Failed to close issue automatically");
+  }
+  let prUrl = "unknown";
+  try {
+    const proc = await execa("gh", ["pr", "list", "--head", "", "--json", "url", "--limit", "1"], {
+      reject: false
+    });
+    const parsed = JSON.parse(proc.stdout?.toString() ?? "[]");
+    if (parsed[0]?.url) {
+      prUrl = parsed[0].url;
+    }
+  } catch {
+  }
+  let branchName = "unknown";
+  try {
+    const proc = await execa("git", ["branch", "--show-current"], { reject: false });
+    branchName = proc.stdout?.toString().trim() ?? "unknown";
+  } catch {
+  }
+  let storyCount = 0;
+  try {
+    const plan = await loadTaskPlan(tasksPath);
+    storyCount = plan.userStories.length;
+    plan.issueStatus = "completed";
+    plan.completedAt = isoNow();
+    plan.lastAttemptAt = isoNow();
+    await saveTaskPlan(tasksPath, plan);
+  } catch {
+  }
+  console.log("");
+  printSuccess(`Pipeline complete for issue #${issueNumber}!`);
+  console.log(`  Branch: ${branchName}`);
+  console.log(`  Stories: ${storyCount}`);
+  console.log(`  PR: ${prUrl}`);
+  return 0;
+}
+export {
+  runPipeline
+};
+//# sourceMappingURL=run-J62FIB5O.js.map

package/dist/run-J62FIB5O.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/run.ts","../src/core/pipeline.ts"],"sourcesContent":["import { join } from 'node:path';\nimport { execa } from 'execa';\nimport { PIPELINE_PHASES, PipelineManager, type PipelinePhase } from '../core/pipeline.js';\nimport { isoNow, loadTaskPlan, saveTaskPlan } from '../core/state-manager.js';\nimport { printError, printInfo, printSuccess, printWarning } from '../ui/logger.js';\nimport { runAnalyze } from './analyze.js';\nimport { runExecute } from './execute.js';\nimport { runInit } from './init.js';\nimport { runPlan } from './plan.js';\nimport { runPr } from './pr.js';\nimport { runPrd } from './prd.js';\nimport { runReview } from './review.js';\n\nexport async function runPipeline(issue: string, mode: string, from?: string): Promise<number> {\n  const issueNumber = issue.replace(/^#/, '');\n  const issueDir = join('issues', issueNumber);\n  const tasksPath = join(issueDir, 'tasks.json');\n\n  printInfo(`Starting pipeline for issue #${issueNumber} (mode: ${mode})`);\n\n  // Phase 1: Init check\n  printInfo('Running prerequisite checks...');\n  const initCode = await runInit();\n  if (initCode !== 0) {\n    printError('Prerequisites not met. Fix the issues above and try again.');\n    return 1;\n  }\n\n  // Determine starting phase\n  let startPhase: PipelinePhase = 'analyze';\n  if (from) {\n    if (!PIPELINE_PHASES.includes(from as PipelinePhase)) {\n      printError(`Invalid phase: ${from}. Valid phases: ${PIPELINE_PHASES.join(', ')}`);\n      return 1;\n    }\n    startPhase = from as PipelinePhase;\n  } else {\n    // Try to auto-resume from pipeline state\n    try {\n      const plan = await loadTaskPlan(tasksPath);\n      const mgr = new PipelineManager(plan, tasksPath);\n      const nextPhase = mgr.getNextPhase();\n      if (nextPhase && nextPhase !== 'init') {\n        startPhase = nextPhase;\n        printInfo(`Resuming from phase: ${startPhase}`);\n      }\n    } catch {\n      // No tasks.json yet — start from beginning\n    }\n  }\n\n  // Validate resume prerequisites if starting from a later phase\n  if (from) {\n    try {\n      const plan = await loadTaskPlan(tasksPath);\n      const mgr = new PipelineManager(plan, tasksPath);\n      if (!mgr.canResume(startPhase)) {\n        printError(`Cannot resume from ${startPhase}: prerequisite phases not complete`);\n        return 1;\n      }\n    } catch {\n      if (startPhase !== 'analyze') {\n        printError(`Cannot resume from ${startPhase}: no pipeline state found`);\n        return 1;\n      }\n    }\n  }\n\n  const phaseOrder: PipelinePhase[] = ['analyze', 'prd', 'plan', 'execute', 'review', 'pr'];\n  const startIdx = phaseOrder.indexOf(startPhase);\n\n  for (let i = startIdx; i < phaseOrder.length; i++) {\n    const phase = phaseOrder[i];\n    printInfo(`\\n--- Phase: ${phase} ---`);\n\n    let code: number;\n    switch (phase) {\n      case 'analyze':\n        code = await runAnalyze(issueNumber);\n        break;\n      case 'prd':\n        code = await runPrd(issueNumber);\n        break;\n      case 'plan':\n        code = await runPlan(issueNumber);\n        break;\n      case 'execute':\n        code = await runExecute(undefined, { issue: issueNumber });\n        break;\n      case 'review': {\n        // Read maxCorrectionCycles\n        let maxCycles = 3;\n        try {\n          const plan = await loadTaskPlan(tasksPath);\n          maxCycles = plan.maxCorrectionCycles;\n        } catch {\n          /* use default */\n        }\n\n        code = await runReview(issueNumber);\n\n        // Auto-correction loop on failure\n        let cycle = 0;\n        while (code !== 0 && cycle < maxCycles) {\n          cycle++;\n          printWarning(`Review failed. Starting correction cycle ${cycle}/${maxCycles}...`);\n\n          // Update correction cycle in tasks.json\n          try {\n            const plan = await loadTaskPlan(tasksPath);\n            plan.correctionCycle = cycle;\n            await saveTaskPlan(tasksPath, plan);\n          } catch {\n            /* non-critical */\n          }\n\n          // Re-execute\n          const execCode = await runExecute(undefined, { issue: issueNumber });\n          if (execCode !== 0) {\n            printError('Correction execution failed');\n            return 1;\n          }\n\n          // Re-review\n          code = await runReview(issueNumber);\n        }\n\n        if (code !== 0) {\n          printError(`Review failed after ${maxCycles} correction cycles`);\n          return 1;\n        }\n        break;\n      }\n      case 'pr':\n        code = await runPr(issueNumber);\n        break;\n      default:\n        code = 1;\n    }\n\n    if (code !== 0) {\n      printError(`Phase ${phase} failed with exit code ${code}`);\n      return 1;\n    }\n  }\n\n  // Close the issue\n  printInfo('Closing issue...');\n  try {\n    await execa('gh', ['issue', 'close', issueNumber], { reject: false });\n  } catch {\n    printWarning('Failed to close issue automatically');\n  }\n\n  // Get PR URL for summary\n  let prUrl = 'unknown';\n  try {\n    const proc = await execa('gh', ['pr', 'list', '--head', '', '--json', 'url', '--limit', '1'], {\n      reject: false,\n    });\n    const parsed = JSON.parse(proc.stdout?.toString() ?? '[]');\n    if (parsed[0]?.url) {\n      prUrl = parsed[0].url;\n    }\n  } catch {\n    /* non-critical */\n  }\n\n  // Get branch and story count\n  let branchName = 'unknown';\n  try {\n    const proc = await execa('git', ['branch', '--show-current'], { reject: false });\n    branchName = proc.stdout?.toString().trim() ?? 'unknown';\n  } catch {\n    /* non-critical */\n  }\n\n  let storyCount = 0;\n  try {\n    const plan = await loadTaskPlan(tasksPath);\n    storyCount = plan.userStories.length;\n\n    // Mark as completed\n    plan.issueStatus = 'completed';\n    plan.completedAt = isoNow();\n    plan.lastAttemptAt = isoNow();\n    await saveTaskPlan(tasksPath, plan);\n  } catch {\n    /* non-critical */\n  }\n\n  console.log('');\n  printSuccess(`Pipeline complete for issue #${issueNumber}!`);\n  console.log(`  Branch: ${branchName}`);\n  console.log(`  Stories: ${storyCount}`);\n  console.log(`  PR: ${prUrl}`);\n\n  return 0;\n}\n","import type { PipelineState, TaskPlan } from '../types.js';\nimport { loadTaskPlan, saveTaskPlan } from './state-manager.js';\n\n/**\n * Ordered pipeline phases. Each phase must complete before the next can start.\n */\nexport const PIPELINE_PHASES = [\n  'init',\n  'analyze',\n  'prd',\n  'plan',\n  'execute',\n  'review',\n  'pr',\n] as const;\n\nexport type PipelinePhase = (typeof PIPELINE_PHASES)[number];\n\n/**\n * Map pipeline phases to their corresponding PipelineState field.\n * 'init' has no persisted state — it's a runtime-only check.\n */\nconst PHASE_TO_FIELD: Record<PipelinePhase, keyof PipelineState | null> = {\n  init: null,\n  analyze: 'analyzeCompleted',\n  prd: 'prdCompleted',\n  plan: 'jsonCompleted',\n  execute: 'executionCompleted',\n  review: 'reviewCompleted',\n  pr: 'prCreated',\n};\n\nexport class PipelineManager {\n  private tasksJsonPath: string;\n  private plan: TaskPlan;\n\n  constructor(plan: TaskPlan, tasksJsonPath: string) {\n    this.plan = plan;\n    this.tasksJsonPath = tasksJsonPath;\n  }\n\n  /**\n   * Reload state from disk.\n   */\n  async reload(): Promise<void> {\n    this.plan = await loadTaskPlan(this.tasksJsonPath);\n  }\n\n  /**\n   * Check if a phase is complete.\n   */\n  isPhaseComplete(phase: PipelinePhase): boolean {\n    const field = PHASE_TO_FIELD[phase];\n    if (field === null) return true; // init is always \"complete\" after running\n    return this.plan.pipeline?.[field] ?? false;\n  }\n\n  /**\n   * Get the first incomplete phase in the pipeline.\n   * Returns null if all phases are complete.\n   */\n  getNextPhase(): PipelinePhase | null {\n    for (const phase of PIPELINE_PHASES) {\n      if (!this.isPhaseComplete(phase)) {\n        return phase;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Get the current phase (alias for getNextPhase).\n   */\n  getCurrentPhase(): PipelinePhase | null {\n    return this.getNextPhase();\n  }\n\n  /**\n   * Check whether we can resume from a specific phase.\n   * All prerequisite phases must be complete.\n   */\n  canResume(fromPhase: PipelinePhase): boolean {\n    const idx = PIPELINE_PHASES.indexOf(fromPhase);\n    if (idx < 0) return false;\n\n    // All phases before fromPhase must be complete\n    for (let i = 0; i < idx; i++) {\n      if (!this.isPhaseComplete(PIPELINE_PHASES[i])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Mark a phase as complete and persist to disk.\n   */\n  async markPhaseComplete(phase: PipelinePhase): Promise<void> {\n    const field = PHASE_TO_FIELD[phase];\n    if (field === null) return; // init has no persisted state\n\n    this.plan = {\n      ...this.plan,\n      pipeline: {\n        ...(this.plan.pipeline ?? {\n          analyzeCompleted: false,\n          prdCompleted: false,\n          jsonCompleted: false,\n          executionCompleted: false,\n          reviewCompleted: false,\n          prCreated: false,\n        }),\n        [field]: true,\n      },\n    };\n\n    await saveTaskPlan(this.tasksJsonPath, this.plan);\n  }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "issue-flow",
+  "version": "0.3.0",
+  "description": "Unified CLI for orchestrating the full issue-flow pipeline via Claude Code Headless",
+  "type": "module",
+  "bin": {
+    "issue-flow": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "biome check src/",
+    "lint:fix": "biome check --write src/",
+    "format": "biome format --write src/",
+    "check": "biome check --write src/ && tsc --noEmit"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "prompts"
+  ],
+  "keywords": [
+    "ai",
+    "agent",
+    "claude",
+    "automation",
+    "cli",
+    "pipeline",
+    "headless",
+    "issue-flow",
+    "github"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fabioassuncao/issue-flow.git",
+    "directory": "packages/issue-flow"
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "execa": "^9.5.2",
+    "ora": "^8.2.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.10",
+    "@types/node": "^22.14.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.1"
+  }
+}

package/prompts/analyze.md

@@ -0,0 +1,28 @@
+You are analyzing GitHub issue #__ISSUE_NUMBER__ for this repository.
+
+Steps:
+1. Fetch the issue data using: gh issue view __ISSUE_NUMBER__ --json title,body,labels,comments
+2. Analyze the codebase to understand the affected areas, tech stack, and architecture
+3. Identify the scope, complexity, and key files/modules involved
+4. Produce a structured analysis
+
+Save your analysis to __ANALYSIS_PATH__ with this structure:
+
+# Issue Analysis: #__ISSUE_NUMBER__
+
+## Summary
+[Brief description of the issue]
+
+## Affected Areas
+[List files, modules, or systems affected]
+
+## Technical Context
+[Relevant architecture, patterns, dependencies]
+
+## Complexity Assessment
+[Low/Medium/High with justification]
+
+## Implementation Notes
+[Key considerations, risks, dependencies]
+
+IMPORTANT: You MUST write the analysis to the file path above. Do not just output it.

package/prompts/execute.md

@@ -0,0 +1,124 @@
+# Issue Flow Agent Instructions
+
+You are an autonomous coding agent working on a software project.
+
+## Your Task
+
+1. Read the PRD at `__PRD_FILE__`
+2. Read the progress log at `__PROGRESS_FILE__` (check Codebase Patterns section first)
+3. Check you're on the correct branch from PRD `branchName`. If not, check it out or create from main.
+4. Treat the issue as unresolved unless **every** `userStories[].passes` value is `true`
+5. Pick the **highest priority** user story where `passes: false`
+6. Implement that single user story
+7. Run quality checks (e.g., typecheck, lint, test - use whatever your project requires)
+8. Update CLAUDE.md files if you discover reusable patterns (see below)
+9. If checks pass, commit ALL changes with message: `feat: [Story ID] - [Story Title]`
+10. Update the PRD to set `passes: true` for the completed story
+11. Append your progress to `__PROGRESS_FILE__`
+
+## Progress Report Format
+
+APPEND to `__PROGRESS_FILE__` (never replace, always append):
+```
+## [Date/Time] - [Story ID]
+- What was implemented
+- Files changed
+- **Learnings for future iterations:**
+  - Patterns discovered (e.g., "this codebase uses X for Y")
+  - Gotchas encountered (e.g., "don't forget to update Z when changing W")
+  - Useful context (e.g., "the evaluation panel is in component X")
+---
+```
+
+The learnings section is critical - it helps future iterations avoid repeating mistakes and understand the codebase better.
+
+## Consolidate Patterns
+
+If you discover a **reusable pattern** that future iterations should know, add it to the `## Codebase Patterns` section at the TOP of `__PROGRESS_FILE__` (create it if it doesn't exist). This section should consolidate the most important learnings:
+
+```
+## Codebase Patterns
+- Example: Use `sql<number>` template for aggregations
+- Example: Always use `IF NOT EXISTS` for migrations
+- Example: Export types from actions.ts for UI components
+```
+
+Only add patterns that are **general and reusable**, not story-specific details.
+
+## Update CLAUDE.md Files
+
+Before committing, check if any edited files have learnings worth preserving in nearby CLAUDE.md files:
+
+1. **Identify directories with edited files** - Look at which directories you modified
+2. **Check for existing CLAUDE.md** - Look for CLAUDE.md in those directories or parent directories
+3. **Add valuable learnings** - If you discovered something future developers/agents should know:
+   - API patterns or conventions specific to that module
+   - Gotchas or non-obvious requirements
+   - Dependencies between files
+   - Testing approaches for that area
+   - Configuration or environment requirements
+
+**Examples of good CLAUDE.md additions:**
+- "When modifying X, also update Y to keep them in sync"
+- "This module uses pattern Z for all API calls"
+- "Tests require the dev server running on PORT 3000"
+- "Field names must match the template exactly"
+
+**Do NOT add:**
+- Story-specific implementation details
+- Temporary debugging notes
+- Information already in progress.txt
+
+Only update CLAUDE.md if you have **genuinely reusable knowledge** that would help future work in that directory.
+
+## Quality Requirements
+
+- ALL commits must pass your project's quality checks (typecheck, lint, test)
+- Do NOT commit broken code
+- Keep changes focused and minimal
+- Follow existing code patterns
+
+## Browser Testing (If Available)
+
+For any story that changes UI, verify it works in the browser if you have browser testing tools configured (e.g., via MCP):
+
+1. Navigate to the relevant page
+2. Verify the UI changes work as expected
+3. Take a screenshot if helpful for the progress log
+
+If no browser tools are available, note in your progress report that manual browser verification is needed.
+
+## Pipeline State Tracking
+
+The task plan may contain a `pipeline` object that tracks orchestrator phase completion. Update these fields as appropriate:
+
+- After completing a story: set `pipeline.executionCompleted` to `false` (still in progress)
+- After ALL stories complete: set `pipeline.executionCompleted` to `true`
+
+The task plan may also contain `correctionCycle` and `maxCorrectionCycles` fields. These track how many review-fix cycles have occurred. The execution loop does not manage the correction loop — that is handled by the orchestrator or manually.
+
+If these fields don't exist in the task plan (older format), ignore them — they are optional.
+
+## Stop Condition
+
+After completing a user story, check if ALL stories have `passes: true`.
+
+If ALL stories are complete and passing, first update the task plan metadata:
+- Set `issueStatus` to `completed`
+- Set `completedAt` to the current ISO timestamp
+- Set `lastAttemptAt` to the current ISO timestamp
+- Clear `lastError`
+- If `pipeline` object exists, set `pipeline.executionCompleted` to `true`
+
+Then reply with:
+<promise>COMPLETE</promise>
+
+If there are still stories with `passes: false`, end your response normally (another iteration will pick up the next story).
+If you need to stop for user guidance or another non-transient blocker, record it in top-level `lastError` and do not clear it.
+
+## Important
+
+- Work on ONE story per iteration
+- Commit frequently
+- Keep CI green
+- Read the Codebase Patterns section in `__PROGRESS_FILE__` before starting

package/prompts/generate.md

@@ -0,0 +1,19 @@
+You are creating a GitHub issue for this repository.
+
+The user provided this description:
+__USER_PROMPT__
+
+Steps:
+1. Analyze the project's tech stack, architecture, and codebase
+2. Check for duplicate issues: gh issue list --state open --search "<keywords>"
+3. Create a well-structured GitHub issue using gh issue create
+
+The issue should:
+- Have a clear, descriptive title
+- Include context about why the change is needed
+- Include acceptance criteria
+- Add appropriate labels (create them if they don't exist)
+
+Use: gh issue create --title "..." --body "..."
+
+IMPORTANT: Output the issue URL after creation so it can be parsed.

package/prompts/plan.md

@@ -0,0 +1,49 @@
+You are converting a PRD into a structured JSON task plan for issue #__ISSUE_NUMBER__.
+
+Here is the PRD:
+
+__PRD_CONTENT__
+
+Create a tasks.json file at __TASKS_PATH__ with this exact structure:
+
+{
+  "project": "<repo-name>",
+  "issueNumber": __ISSUE_NUMBER__,
+  "issueUrl": "<github-issue-url>",
+  "branchName": "issue/__ISSUE_NUMBER__-<slug>",
+  "description": "<brief description>",
+  "issueStatus": "pending",
+  "completedAt": null,
+  "lastAttemptAt": null,
+  "lastError": null,
+  "correctionCycle": 0,
+  "maxCorrectionCycles": 3,
+  "pipeline": {
+    "analyzeCompleted": true,
+    "prdCompleted": true,
+    "jsonCompleted": true,
+    "executionCompleted": false,
+    "reviewCompleted": false,
+    "prCreated": false
+  },
+  "userStories": [
+    {
+      "id": "US-001",
+      "title": "...",
+      "description": "As a ..., I want ... so that ...",
+      "acceptanceCriteria": ["..."],
+      "priority": 1,
+      "passes": false,
+      "notes": ""
+    }
+  ]
+}
+
+Rules:
+- Each user story from the PRD becomes one entry in userStories
+- Priority should order stories by dependency (build foundations first)
+- acceptanceCriteria must include "Typecheck passes" for code changes
+- Get the repo name and issue URL from: gh issue view __ISSUE_NUMBER__ --json url
+- The branchName should use a short kebab-case slug derived from the issue title
+
+IMPORTANT: You MUST write the tasks.json to the file path above. Do not just output it.

package/prompts/pr.md

@@ -0,0 +1,19 @@
+You are creating a pull request for issue #__ISSUE_NUMBER__ on branch __BRANCH_NAME__.
+
+Steps:
+1. Fetch the issue data: gh issue view __ISSUE_NUMBER__ --json title,body
+2. Read the task plan from __TASKS_PATH__ if it exists
+3. Review the git log for this branch: git log main..HEAD --oneline
+4. Review the diff: git diff main...HEAD --stat
+5. Create a well-structured PR using gh pr create
+
+The PR should:
+- Have a clear, concise title (under 70 characters)
+- Reference the issue: "Closes #__ISSUE_NUMBER__"
+- Include a summary of changes
+- Include a test plan
+
+Use this command format:
+gh pr create --title "..." --body "..." --base main
+
+IMPORTANT: Output the PR URL after creation so it can be parsed.

package/prompts/prd.md

@@ -0,0 +1,30 @@
+You are generating a Product Requirements Document (PRD) for GitHub issue #__ISSUE_NUMBER__ in this repository.__ANALYSIS_CONTEXT__
+
+Steps:
+1. If no analysis was provided above, fetch the issue data using: gh issue view __ISSUE_NUMBER__ --json title,body,labels,comments
+2. Analyze the codebase to understand the context
+3. Generate a structured PRD
+
+Save the PRD to __PRD_PATH__ with this structure:
+
+# PRD: [Issue Title]
+
+## Context
+[Why this change is needed]
+
+## Goals
+[What success looks like]
+
+## User Stories
+[US-001, US-002, etc. with acceptance criteria]
+
+## Technical Approach
+[High-level implementation strategy]
+
+## Out of Scope
+[What is explicitly NOT included]
+
+## Dependencies
+[External dependencies or prerequisites]
+
+IMPORTANT: You MUST write the PRD to the file path above. Do not just output it.

package/prompts/review.md

@@ -0,0 +1,27 @@
+You are reviewing whether GitHub issue #__ISSUE_NUMBER__ has been fully resolved.
+
+IMPORTANT: You are running in --orchestrator mode. Do NOT close the issue directly. Only report results.
+
+Steps:
+1. Fetch the issue data using: gh issue view __ISSUE_NUMBER__ --json title,body,labels
+2. Read the task plan from __TASKS_PATH__ to understand what was supposed to be implemented
+3. Analyze the codebase to verify all acceptance criteria are met
+4. Run the project's test suite and typecheck
+5. Check for regressions
+
+At the end, output your result in this exact format:
+
+<review-result>
+STATUS: PASS
+</review-result>
+
+Or if there are issues:
+
+<review-result>
+STATUS: FAIL
+FINDINGS:
+- Finding 1
+- Finding 2
+</review-result>
+
+IMPORTANT: You MUST include the <review-result> block in your output.