Planny hit the gym and lost some weight

Trimmed the mascot ASCII art across all prompts and installer.
Planny is now more aerodynamic and 40% less chunky.

.gitignore

@@ -1,3 +1,15 @@
 specs/
-dist/
+specs--completed/
 CLAUDE.md
+dist/
+plan2code-loop/dist
+plan2code-loop/node_modules
+plan2code-loop/package-lock.json
+plan2code-metrics/dist
+plan2code-metrics/node_modules
+plan2code-metrics/package-lock.json
+.plan2code-loop
+.plan2code-metrics
+nul
+node_modules/
+package-lock.json

.husky/pre-commit

@@ -0,0 +1 @@
+node scripts/validate-char-count.js

.npmignore

@@ -0,0 +1,19 @@
+# Exclude user-generated spec files
+specs/
+specs--completed/
+
+# Exclude development files
+.husky/
+.git/
+.gitignore
+CLAUDE.md
+
+# Exclude generated files (installer generates dist/ dynamically)
+dist/
+
+# Exclude dependencies (installer will run npm install if needed)
+node_modules/
+package-lock.json
+plan2code-loop/node_modules/
+plan2code-loop/package-lock.json
+plan2code-loop/dist/

AGENTS.md

@@ -0,0 +1,298 @@
+# AGENTS.md
+
+This file provides guidance to AI coding agents like Claude Code (claude.ai/code), Cursor AI, Codex, Gemini CLI, GitHub Copilot, and other AI coding assistants when working with code in this repository.
+
+## Project Overview
+
+Plan2Code is a structured 4-step workflow methodology for AI-assisted software development. It provides prompt templates that can be installed globally or per-project for various AI coding tools (Claude Code, Cursor, Copilot, Continue, Windsurf, Codeium).
+
+**Version:** Check `version.json` for current version
+**Author:** Justin Parker
+**License:** MIT
+
+## Architecture
+
+```
+plan2code/
+├── src/                    # Source workflow prompts (8 markdown files)
+├── plan2code-loop/         # Autonomous loop CLI tool (Node.js/TypeScript)
+│   ├── src/                # TypeScript source
+│   └── dist/               # Built output (tsup)
+├── plan2code-metrics/      # Recursive self-improvement toolchain
+│   ├── src/                # TypeScript source
+│   │   └── prompts/        # Internal AI prompt templates (no char limit)
+│   └── dist/               # Built output (tsup)
+├── scripts/                # Development scripts
+│   └── validate-char-count.js  # Pre-commit character count validator
+├── dist/                   # Generated distribution files (auto-generated)
+│   ├── global-commands/    # For global installation (~/.claude/, etc.)
+│   └── local-commands/     # For per-project installation (.claude/, etc.)
+├── .husky/                 # Git hooks (husky)
+│   └── pre-commit          # Runs character count validation
+├── docs/                   # Documentation and assets
+├── specs/                  # Feature specs (if any in-progress)
+├── install.js              # Interactive installer (Node.js)
+├── package.json            # Root package (husky only, private: true)
+├── version.json            # Version metadata
+└── README.md               # User documentation
+```
+
+## Key Files
+
+| File | Purpose |
+|------|---------|
+| `install.js` | Main installer - generates and installs workflow files to AI tool directories |
+| `src/plan2code-*.md` | Source workflow prompts (the "source of truth") |
+| `scripts/validate-char-count.js` | Pre-commit validator ensuring all source prompts ≤ 11,000 chars |
+| `version.json` | Version metadata (name, version, description) |
+| `QUICK-REFERENCE.md` | User quick-reference card |
+
+## Workflow Prompts (in `src/`)
+
+| File | Step | Purpose |
+|------|------|---------|
+| `plan2code---init.md` | Init | Generate AGENTS.md for projects |
+| `plan2code---init-update.md` | Update | Update AGENTS.md with learnings |
+| `plan2code---quick-task.md` | 0 | Lightweight planning for small tasks |
+| `plan2code-1--plan.md` | 1 | Requirements analysis & architecture |
+| `plan2code-1b--revise-plan.md` | 1b | Mid-implementation revisions |
+| `plan2code-2--document.md` | 2 | Create implementation specs |
+| `plan2code-3--implement.md` | 3 | Execute implementation (phase by phase) |
+| `plan2code-4--finalize.md` | 4 | Validate, summarize, feedback, archive (7 steps) |
+
+## Plan2Code Loop (`plan2code-loop/`)
+
+A separate Node.js CLI tool that autonomously implements specs by looping through tasks.
+
+### Loop Architecture
+
+The loop uses an **LLM-driven discovery** approach:
+- Node app just orchestrates iterations and parses completion markers
+- The LLM reads spec files (`overview.md`, `phase-X.md`) to discover tasks
+- The LLM finds unchecked checkboxes, implements ONE task per iteration, marks it complete
+- No regex parsing of markdown in Node - the AI handles all task discovery
+
+### Loop Commands
+
+```bash
+# Build the loop CLI
+cd plan2code-loop && npm run build
+
+# Run the loop (after linking) - fully interactive
+plan2code-loop
+```
+
+The CLI auto-detects specs in `./specs/`, prompts for selection if multiple found, and handles session continuation interactively. Session state is stored per-spec in `specs/<feature>/.plan2code-loop/`.
+
+### Loop Modes
+
+The CLI asks users to choose a loop mode:
+- **One task per loop** (default) - Each agent invocation implements exactly one task. The Node controller handles git commits.
+- **One phase per loop** - Each agent invocation implements all remaining tasks in the current phase. The LLM handles git commits (with JIRA ticket ID if provided). The controller parses multiple completion markers from a single iteration.
+
+### Completion Markers
+
+The LLM must output one of these formats:
+- `TASK_COMPLETE: 1.1 - Task description` - Task done successfully
+- `TASK_BLOCKED: 1.1 - Reason` - Cannot complete task
+- `PHASE_COMPLETE` - Current phase finished (phase mode only)
+- `LOOP_COMPLETE` - All phases finished
+
+## Plan2Code Metrics (`plan2code-metrics/`)
+
+A recursive self-improvement toolchain for plan2code contributors. Collects run metrics, aggregates by prompt generation, diagnoses weak steps via AI, and proposes surgical prompt edits.
+
+### Metrics Data Flow
+
+```
+Collect → Aggregate → Analyze → Improve → Apply
+```
+
+1. **Collector** reads project artifacts (`specs/<feature>/`) → writes `RunMetrics` JSON per run
+2. **Aggregator** groups runs by prompt SHA fingerprint (cohorts) → `aggregated.json`
+3. **Analyzer** invokes AI with aggregated metrics + prompt contents → diagnosis markdown
+4. **Improver** invokes AI with diagnosis → validated `PromptEdit[]` proposals (char limit + verbatim checks)
+5. **Applier** shows interactive diffs → patches `src/plan2code-*.md` files
+
+### Metrics Commands
+
+```bash
+cd plan2code-metrics && npm run build  # Build the CLI
+plan2code-metrics                      # Run (fully interactive, no flags)
+```
+
+### Metrics CLI Menu
+
+| Option | Action |
+|--------|--------|
+| Collect | Read spec artifacts → run JSON |
+| Import | Copy run JSON from another project |
+| View | Display cohort metrics with health indicators |
+| Analyze | AI diagnosis of weak metrics |
+| Propose | AI improvement proposals with validation |
+| Apply | Interactive diff review + file patching |
+
+### Key Files
+
+| File | Purpose |
+|------|---------|
+| `types.ts` | All interfaces (`RunMetrics`, `UserFeedback`, `CohortMetrics`, etc.) + `METRIC_TARGETS` |
+| `collector.ts` | Reads project artifacts → run JSON (parses plan drafts, overview.md, loop logs) |
+| `aggregator.ts` | Merges runs by prompt generation (SHA cohort) → `aggregated.json` |
+| `analyzer.ts` | AI diagnosis via `prompts/analyze.md` template |
+| `improver.ts` | AI proposals via `prompts/improve.md` + validation (char count, old_text match) |
+| `applier.ts` | Interactive diff review + file patching |
+| `cli.ts` | Menu-driven interactive CLI (100% prompts, no flags) |
+| `invoke-llm.ts` | Unified LLM interface (Claude Code or Copilot CLI) |
+
+### User Feedback
+
+The collector parses an optional `## User Feedback` table from `overview.md`:
+
+```markdown
+## User Feedback
+| Field | Value |
+|-------|-------|
+| Rating | 8 |
+| Reason | Smooth workflow |
+| Went Well | Planning was thorough |
+| Went Poorly | Some tasks unclear |
+```
+
+Feedback is collected during finalize (Step 5) or retroactively via the CLI. Pipe characters in values are escaped as `\|`. The aggregator computes `avg_user_rating` and `feedback_count` per cohort.
+
+### Supported AI Agents
+
+- **Claude Code** (recommended): `claude` CLI with `--inputFile` for prompt delivery
+- **GitHub Copilot CLI**: `copilot` CLI with stdin prompt delivery
+
+### Metric Targets
+
+| Metric | Target | Direction |
+|--------|--------|-----------|
+| `avg_confidence` | ≥ 90 | higher is better |
+| `avg_task_completion_rate` | ≥ 0.95 | higher is better |
+| `avg_blocker_count` | ≤ 1.5 | lower is better |
+| `avg_completion_marker_success_rate` | ≥ 0.95 | higher is better |
+| `avg_verification_failures_found` | ≤ 1.0 | lower is better |
+| `archival_success_rate` | ≥ 0.99 | higher is better |
+| `avg_user_rating` | ≥ 7.0 | higher is better |
+
+Data stored in `.plan2code-metrics/` (runs/, aggregated.json, proposals/).
+
+## Development Commands
+
+```bash
+# Install dev dependencies (sets up husky pre-commit hooks)
+npm install
+
+# Run the interactive installer (always interactive — any CLI args are silently ignored)
+node install.js
+
+# Plan2Code Loop
+cd plan2code-loop && npm install   # First time setup
+cd plan2code-loop && npm run build # Build the CLI
+
+# Plan2Code Metrics
+cd plan2code-metrics && npm install   # First time setup
+cd plan2code-metrics && npm run build # Build the CLI
+```
+
+### Installer Menu Options
+
+**Main menu:**
+
+| Option | Action |
+|--------|--------|
+| `I` | Install Plan2Code for all platforms + loop CLI |
+| `U` | Uninstall Plan2Code files + loop CLI (confirmation required) |
+| `C` | Open CUSTOM sub-menu |
+| `Q` | Quit |
+
+**CUSTOM sub-menu (`C`):**
+
+| Option | Action |
+|--------|--------|
+| `L` | Show local (per-project) install instructions |
+| `O` | Install plan2code-loop CLI only |
+| `M` | Install plan2code-metrics CLI only |
+| `Q` | Return to main menu |
+
+## How the Installer Works
+
+1. **Reads source prompts** from `src/plan2code-*.md`
+2. **Generates platform-specific files** with appropriate headers (YAML frontmatter for some platforms)
+3. **Writes to `dist/`** subdirectories organized by destination type
+4. **Copies to target directories** (global: `~/.claude/commands/`, etc.)
+
+### Platform-Specific File Formats
+
+| Platform | Extension / File | Local Dir | Global Dir | Header |
+|----------|-----------------|-----------|------------|--------|
+| Claude Code | `.md` | — | — | None |
+| Cursor | `.md` | — | — | None |
+| Copilot CLI | `.md` | — | — | YAML frontmatter |
+| Continue | `.prompt.md` | — | — | YAML frontmatter |
+| Windsurf | `.md` | — | — | YAML frontmatter |
+| VS Code Copilot | `.prompt.md` | — | — | YAML frontmatter |
+| Codeium | `.md` | — | — | YAML frontmatter |
+| Claude Code (Skills) | `SKILL.md` in subdir | `.claude/skills/<skill-name>/` | `~/.claude/skills/<skill-name>/` | YAML frontmatter + `disable-model-invocation: true` |
+| Agent Skills (Amp · Gemini CLI · OpenCode) | `SKILL.md` in subdir | `.agents/skills/<skill-name>/` | `~/.agents/skills/<skill-name>/` | YAML frontmatter (no disable flag) |
+| Crush | `SKILL.md` in subdir | — (global only) | `~/.config/crush/skills/<skill-name>/` (Unix) / `%LOCALAPPDATA%\crush\skills\<skill-name>\` (Windows) | YAML frontmatter |
+| Gemini CLI (TOML) | `.toml` | `.gemini/commands/` | `~/.gemini/commands/` | None (TOML fields: `description`, `prompt`) |
+
+## Naming Convention
+
+Workflow files follow a strict naming pattern:
+- **Utilities:** `plan2code---<name>.md` (triple dash)
+- **Numbered steps:** `plan2code-<N>--<name>.md` (single dash, number, double dash)
+
+Examples:
+- `plan2code---init.md` (utility)
+- `plan2code-1--plan.md` (step 1)
+- `plan2code-1b--revise-plan.md` (step 1b)
+
+## Editing Workflow Prompts
+
+When modifying workflow prompts in `src/`:
+
+1. Edit the source file in `src/`
+2. Run `node install.js` to regenerate distribution files
+3. Test the workflow in your AI tool of choice
+4. The `dist/` folder is regenerated automatically - don't edit files there directly
+
+## Code Style
+
+- **install.js:** CommonJS, Node.js built-ins only (no external deps), ANSI colors via `COLORS` constant, readline-based prompts
+- **plan2code-loop & plan2code-metrics:** TypeScript + ESM, built with tsup (target ES2022, moduleResolution: bundler)
+  - External deps: `@inquirer/prompts`, `chalk`, `execa`, `ora`
+  - Interactive CLI via `@inquirer/prompts` (select, input, confirm)
+- **File operations:** Synchronous fs in all packages
+
+## Gotchas/Pitfalls
+
+- **Version sync:** When adding a new version to `CHANGELOG.md`, also update `version.json` and `package.json` to match. The installer displays the version from `version.json` in its header.
+- **Loop `.gitignore` setup:** `ensureGitignore()` runs at startup in `Controller.run()` as a pre-flight step, not just inside `createTaskCommit()`. This is critical for phase mode where the Node controller doesn't handle commits — without it, `git add -A` would stage spec files.
+- **Workflow file character limit:** All `src/plan2code-*.md` files must be ≤ 11,000 characters. A husky pre-commit hook enforces this. The 11,000 limit leaves buffer for platform-specific YAML headers (106-142 chars) to stay under Windsurf's 12,000 char limit.
+- **Metrics internal prompts have no char limit:** Files in `plan2code-metrics/src/prompts/` are NOT subject to the 11,000 char limit — only `src/plan2code-*.md` consumer-facing prompts are.
+- **User Feedback table format:** The `## User Feedback` markdown table in `overview.md` has a strict format the collector regex depends on. Field names must be exactly `Rating`, `Reason`, `Went Well`, `Went Poorly`. Pipe characters in values must be escaped as `\|`.
+
+## Git Commit Messages
+
+- **AI Assisted footer:** All git commit messages must include `AI Assisted` as the final line, separated from the message body by a blank line
+- **Commit paths:** This is enforced across all commit surfaces:
+  - Loop task mode: `createTaskCommit()` in `plan2code-loop/src/utils/git.ts` appends the footer automatically
+  - Loop phase mode: Prompt template instructs the LLM to add `-m "AI Assisted"` as the final flag
+  - Implement mode: User-facing commit suggestions in `src/plan2code-3--implement.md` include the footer
+- **Init workflow:** `src/plan2code---init.md` generates AGENTS.md files with a Git Commit Messages section that includes this convention by default
+
+## Mascot
+
+The project has a mascot called "Planny" - an ASCII art robot that appears in installer output and workflow prompts. Mascot variants are defined in `MASCOT` constant in `install.js` and appear in workflow markdown files.
+
+```
+   ╭───╮
+   │ ● │
+   │ ◡ │
+   ╰───╯
+```

CHANGELOG.md

@@ -2,6 +2,275 @@
 
 All notable changes to Plan2Code will be documented in this file.
 
+## v1.8.1
+
+### ✨ Added
+
+- **User feedback collection** — Optional 1-10 rating with reason, what went well, and what went poorly
+  - Finalize prompt (Step 5) asks for optional feedback before archival, writes structured table to `overview.md`
+  - Collector parses `## User Feedback` table from `overview.md` into `RunMetrics.user_feedback`
+  - Aggregator computes `avg_user_rating` and `feedback_count` per cohort
+  - CLI offers interactive feedback collection if none found during metrics collection
+  - Analysis and improvement prompts reference `avg_user_rating` metric target (≥ 7.0)
+  - `UserFeedback` type exported from public API
+- **Pipe-safe feedback parsing** — User text containing `|` characters is escaped on write and correctly unescaped on parse using negative lookbehind regex
+
+### 🐛 Fixed
+
+- **Duplicate run files** — Interactive feedback no longer creates a second run JSON; the original is deleted before re-collecting
+- **Finalize step ordering** — Feedback collection moved to Step 5 (before archival at Step 6), ensuring `overview.md` is written while still in the active spec directory
+
+## v1.8.0
+
+### ✨ Added
+
+- **plan2code-metrics** — New recursive self-improvement toolchain for plan2code contributors (`plan2code-metrics/`)
+  - Fully interactive menu-driven CLI — no flags, all inputs collected via prompts
+  - **Collect** metrics from completed project specs (plan, document, implement, finalize steps)
+  - **Import** run data from other projects for cross-project aggregation
+  - **View** metrics status with health indicators and generation-over-generation deltas
+  - **Analyze** weak steps via AI-powered diagnosis (Claude Code or GitHub Copilot CLI)
+  - **Generate** surgical improvement proposals with automatic validation (char count limits, edit verification)
+  - **Review and apply** proposals with interactive diff review
+  - Cohort-based aggregation groups runs by prompt generation (SHA fingerprint of prompt files)
+  - Supports both Claude Code and GitHub Copilot CLI as AI backends
+  - Standalone TypeScript package with tsup build (ESM), installed via `npm link`
+
+### 🔧 Changed
+
+- **plan2code-4--finalize.md** — Added "Metrics Capture (Contributors)" note in Step 6 directing contributors to run `plan2code-metrics` after finalization
+- **plan2code-loop index.ts** — Added dim hint "run plan2code-metrics" after session summary
+
+## v1.7.0
+
+### ✨ Added
+
+- **4 new platform targets** — Gemini CLI, Crush, Amp, and OpenCode now supported
+  - Gemini CLI installs as TOML commands (`.gemini/commands/plan2code-*.toml`)
+  - Crush installs as skill subdirs (`~/.config/crush/skills/` on Unix, `%LOCALAPPDATA%\crush\skills\` on Windows)
+  - Amp and OpenCode covered via shared Agent Skills target (`.agents/skills/`)
+- **Claude Code Skills format** — Migrated from flat `.claude/commands/*.md` to `.claude/skills/<skill-name>/SKILL.md` with `disable-model-invocation: true` frontmatter
+- **Agent Skills cross-tool target** — Single `.agents/skills/` install covers Amp, Gemini CLI, and OpenCode simultaneously
+- **Legacy cleanup** — Old `.claude/commands/plan2code-*.md` files automatically removed on install and uninstall
+- **TOML generation** — New `generateTomlContent()` produces Gemini CLI command files using TOML literal multi-line strings
+
+### 🔧 Changed
+
+- `AGENTS.md` Platform-Specific File Formats table expanded to 5 columns with 4 new platform rows
+- `docs/index.html` hero section updated with 4 new platform pills
+- `README.md` Supported Platforms list updated with 4 new platforms
+
+## v1.6.2
+
+### 🔧 Changed
+
+- **Installer menu simplified** — Replaced the 7-platform picker with a clean 4-option menu (I/U/C/Q)
+  - `I` — Install Plan2Code for all platforms + loop CLI
+  - `U` — Uninstall (with confirmation prompt)
+  - `C` — CUSTOM sub-menu: `L` (local install instructions), `O` (loop CLI only), `Q` (back)
+  - `Q` — Quit
+  - Any CLI arguments (e.g. `--dry-run`, `--platform`) are now silently ignored; installer always runs interactively
+- **README installation section** — npx install method promoted to primary recommended install path; updated menu example
+
+### 🗑️ Removed
+
+- CLI flags `--dry-run`, `--platform`, `--local`, `--uninstall`, `--help`, `--loop`, `--uninstall-loop` (all removed; installer is always interactive)
+- `displayHelp()` function removed from `install.js`
+
+## v1.6.1
+
+### ✨ Added
+
+- **NPX installation support** - Team members can now install directly from GitHub without cloning
+  - Added `name`, `version`, and `bin` fields to `package.json` for npm compatibility
+  - Installation via `npx git+ssh://git@github.com/jparkerweb/plan2code.git` (SSH)
+  - Installation via `npx git+https://github.com/jparkerweb/plan2code.git` (HTTPS)
+  - Installer runs from temporary location and cleans up automatically
+  - Updated README.md with Quick Start section showing both authentication methods
+  - Added `.npmignore` file to suppress npm warnings during npx execution
+
+## v1.6.0
+
+### 🏎️ Improved
+
+- **Reduced workflow file sizes** - All 4 over-target source prompts compressed to ≤ 11,000 characters for Windsurf IDE compatibility (12,000 char limit minus header buffer)
+  - `plan2code-3--implement.md` - 14,806 → 8,533 chars (42% reduction)
+  - `plan2code-1--plan.md` - 13,587 → 10,348 chars (24% reduction)
+  - `plan2code-4--finalize.md` - 12,012 → 8,586 chars (29% reduction)
+  - `plan2code-2--document.md` - 11,842 → 9,031 chars (24% reduction)
+  - All functional workflow behavior preserved
+  - Compression techniques: template-to-section-list specs, removed bad examples, consolidated redundant sections, simplified decorative boxes, imperative directives
+
+### 🧪 Testing
+
+- **Pre-commit character count validation** - Husky pre-commit hook prevents workflow files from exceeding 11,000 characters
+  - `scripts/validate-char-count.js` - Cross-platform Node.js validation script using only built-in modules
+  - `.husky/pre-commit` - Git hook trigger calling the validation script
+  - Root `package.json` with husky as sole devDependency (`private: true`)
+  - `.gitignore` updated with `node_modules/` and `package-lock.json`
+
+## v1.5.4
+
+### ✨ Added
+
+- **AI Assisted commit attribution** - All git commit messages now include an `AI Assisted` footer for transparency
+  - **Init mode** - Generated AGENTS.md files include a Git Commit Messages section instructing agents to always append `AI Assisted`
+  - **Init-update mode** - New "Git Commit Messages" menu option (option 7) for adding or modifying commit message conventions
+  - **Loop task mode** - `createTaskCommit()` automatically appends `AI Assisted` footer to every commit
+  - **Loop phase mode** - Prompt template instructs LLM to include `-m "AI Assisted"` as final flag on every commit
+  - **Implement mode** - User-facing git commit suggestions after phase approval include `-m "AI Assisted"`
+
+### 🔧 Changed
+
+- **README loop install instructions** - Replaced inline text with formatted code block showing both install options
+
+## v1.5.3
+
+### ✨ Added
+
+- **Loop mode selection** - Plan2Code Loop now asks users to choose between two loop modes:
+  - **One task per loop** (default) - Each agent invocation implements exactly one task. Node controller handles git commits after each task. Same behavior as before.
+  - **One phase per loop** - Each agent invocation implements all remaining tasks in the current phase. The LLM handles git commits after each task (with JIRA ticket ID). Ideal for related tasks and smart models with higher context windows.
+- **Phase-mode prompt template** - New `LOOP_PROMPT_TEMPLATE_PHASE` instructs the LLM to complete all tasks in the current phase, create git commits per task, and output `TASK_COMPLETE` markers for each
+- **Multi-marker completion detection** - New `checkForAllCompletions()` function parses all `TASK_COMPLETE`, `TASK_BLOCKED`, and `PREREQ_COMPLETE` markers from a single agent output
+- **`PHASE_COMPLETE` marker** - New completion marker for phase mode indicating current phase is done (distinct from `LOOP_COMPLETE` which means all phases done)
+- **`loopMode` config field** - New `SessionConfig.loopMode` field (`'task' | 'phase'`) persisted in session state for resume support
+- **Documentation auto-discovery** - Documentation workflow now auto-discovers features to document
+  - Automatically finds `specs/*/PLAN-DRAFT-*.md` files
+  - If only one feature exists, uses it without prompting
+  - If multiple features exist, presents list and asks user to choose
+  - Automatically reads `PLAN-CONVERSATION-*.md` if present (optional, for context)
+- **Documentation Verification Pass** - Documentation workflow now cross-references against PLAN-DRAFT before finalizing
+  - New Process Step 7 with sub-steps: 7A (re-read PLAN-DRAFT), 7B (cross-reference sections), 7C (fix gaps), 7D (output summary)
+  - New "Documentation Verification Pass" section with mapping table showing which PLAN-DRAFT sections to verify against which spec files
+  - Gap handling: Missing items added with `<!-- VERIFICATION: Added - FR-X from PLAN-DRAFT -->` markers
+  - Session end output now includes verification summary table showing Items in PLAN-DRAFT / Covered / Added per section
+  - Added reminders: "Always run verification pass before finalizing" and "PLAN-DRAFT is the source of truth"
+- **Conversation Logging** - Planning workflow now saves the full planning conversation before creating PLAN-DRAFT
+  - New file: `specs/<feature-name>/PLAN-CONVERSATION-<YYYYMMDD>.md` created in Phase 7
+  - Contains full conversation transcript organized by phase with speaker attribution (`[AGENT]` vs `[USER RESPONSE]`)
+  - Decision summary tables with user quotes, confirmed requirements, approved technologies, and assumptions
+  - Serves as source of truth for plan verification
+- **PLAN-DRAFT Verification Pass** - New STEP 7C verifies PLAN-DRAFT against conversation log
+  - Cross-references all requirements, tech decisions, risks, and assumptions
+  - Missing items added with `<!-- VERIFICATION: Added from Phase X -->` markers
+  - Outputs verification summary showing what was captured vs added
+- **Conversation Log field in PLAN-DRAFT** - New header field links to the conversation log file
+
+### 🔧 Changed
+
+- **Installer default option** - Pressing Enter without selecting an option now defaults to `A` (Install to ALL platforms + loop CLI) instead of quitting
+- **Planning output location changed** - PLAN-DRAFT and conversation log now created in feature subdirectory
+  - New location: `specs/<feature-name>/PLAN-DRAFT-<date>.md` and `specs/<feature-name>/PLAN-CONVERSATION-<date>.md`
+  - Date format: YYYYMMDD (e.g., `20250204`) instead of full timestamp
+  - Uppercase `PLAN-CONVERSATION` for consistency with `PLAN-DRAFT`
+  - Feature directory created during planning (Step 1) instead of documentation (Step 2)
+  - Documentation step no longer archives PLAN-DRAFT (already in correct location)
+- **Planning Phase 7 restructured** - Now has three sub-steps:
+  - STEP 7A: Save Conversation Log (new)
+  - STEP 7B: Create PLAN-DRAFT (existing behavior, uses same timestamp)
+  - STEP 7C: Verification Pass (new)
+- **Session End example updated** - Now shows both conversation log and PLAN-DRAFT files
+- **Important Reminders expanded** - Added reminders about conversation log and verification pass
+
+### 🐛 Fixed
+
+- **`.gitignore` missing `specs/` entries in phase mode** - `ensureGitignore()` only ran inside `createTaskCommit()`, which is never called in phase mode. Moved `ensureGitRepo()` and `ensureGitignore()` to run once at startup in `Controller.run()` as a pre-flight step, ensuring `.gitignore` entries are set before the first iteration regardless of loop mode
+
+## v1.5.2
+
+### ✨ Added
+
+- **AI Agent File Sync** - Init and Init-Update workflows now detect and sync other AI agent config files
+  - Detects 6 file types: CLAUDE.md, GEMINI.md, .cursorrules, .github/copilot-instructions.md, .cursor/rules/, .windsurf/rules/
+  - Offers to replace with references to AGENTS.md as single source of truth
+  - User confirmation required before any modifications
+  - Correct relative paths for each file location (./AGENTS.md, ../AGENTS.md, ../../AGENTS.md)
+- **Knowledge Transfer** - Init mode now uses existing CLAUDE.md content as context when creating new AGENTS.md
+  - Preserves project knowledge during migration to AGENTS.md
+
+## v1.5.1
+
+### ✨ Added
+
+- **Prerequisite verification workflow** - Agents now verify/complete prerequisites before starting phase tasks
+  - Implementation mode processes prerequisites in order: verify, complete, or mark assumed
+  - Loop prompt treats prerequisites as "Task 0.X" - one per iteration before tasks
+  - New completion markers: `PREREQ_COMPLETE` and `PREREQ_ASSUMED`
+- **New checkbox state `[?]`** - "Assumed complete, couldn't verify" for prerequisites that can't be validated
+  - Use when prerequisite cannot be programmatically verified (e.g., "Design approved by stakeholder")
+  - Agents skip `[?]` items like `[x]` items
+- **Re-opened phase handling in Revision mode** - Properly handle adding tasks to completed phases
+  - New "Re-opening" impact type (Medium-High risk) in impact assessment
+  - New tasks in completed phases get `🆕 ADDED` flag
+  - Phase checkbox changes from `[x]` to `[ ]` in overview.md when new tasks added
+  - "Phases Re-opened" section in revision summary
+  - Consistency check now verifies phase completion status matches task completion
+
+### 🔧 Changed
+
+- **Installer UI refresh** - Cleaner, narrower layout for better terminal compatibility
+  - Narrower menu boxes (65 characters instead of 76)
+  - Smaller mascot display at end of installation
+  - Added first-time user documentation link after successful install
+  - Updated menu descriptions to show "+ loop CLI" for relevant options
+- **Planning workflow guardrails** - Prevent users from skipping the documentation step
+  - Added critical reminder after Phase 7 to direct to `/plan2code-2--document`
+  - Added workflow order reminder in Session End section: Plan → Document → Implement → Finalize
+  - Updated example closing message to emphasize documentation as next step
+  - Added workflow order to Important Reminders section
+- **AGENTS.md pre-flight message** - Improved guidance for new projects
+  - Message now explains that new projects can continue without AGENTS.md
+  - Suggests creating basic AGENTS.md first with rules can still be valuable
+
+## v1.5.0 - 2026-01-22
+
+### ✨ Added
+
+- **Plan2Code Loop** - New autonomous CLI tool for hands-off spec implementation
+  - Separate Node.js/TypeScript tool in `plan2code-loop/` directory
+  - LLM-driven task discovery - AI reads spec files and finds unchecked tasks
+  - Iterates through tasks one at a time, marking checkboxes as complete
+  - Structured completion markers: `TASK_COMPLETE: 1.1 - description`
+  - Session persistence with scratchpad and iteration logging
+  - Supports Claude Code and GitHub Copilot CLI agents
+- **Installer integration** for loop CLI
+  - Option `A` now installs prompts to all platforms AND builds/links the loop CLI
+  - Option `O` builds and links plan2code-loop CLI only
+  - Option `U` uninstalls prompts AND unlinks the loop CLI
+
+### 📝 Documentation
+
+- Updated README.md with "Autonomous Loop" section explaining when to use loop vs manual Step 3
+- Updated QUICK-REFERENCE.md with loop commands and decision tree
+- Updated AGENTS.md with loop architecture, commands, and completion markers
+
+## v1.4.0 - 2026-01-09
+
+### ✨ Added
+
+- **Parallel Phase Execution** - Run multiple implementation phases simultaneously in separate agent instances
+  - Documentation Mode auto-detects parallel-eligible phases based on file conflicts and dependencies
+  - Implementation Mode presents phase selection UI when parallel options are available
+  - New "Parallel Execution Groups" section in `overview.md` tracks which phases can run together
+  - Conflict detection criteria: file overlap, prerequisite dependencies, data/output dependencies, shared state
+  - Users can start multiple `/plan2code-3--implement` sessions to work on different parallel phases
+- **In-Progress Phase Tracking** - Track which phases are actively being worked on
+  - New `[/]` checkbox status indicates a phase is in-progress (between `[ ]` pending and `[x]` complete)
+  - Phases marked `[/]` when an agent starts working, `[x]` when user approves completion
+  - Aborted phases stay `[/]` to enable resume - never reset back to `[ ]`
+  - Parallel selection UI shows `[IN PROGRESS]` vs `[AVAILABLE]` status for each phase
+  - Single in-progress phase prompts user to confirm resume (prevents accidental overlap)
+  - Supports multiple agent sessions on parallel phases with clear visibility of what's active
+
+### 🔧 Changed
+
+- **Documentation Mode process** - Added step 6 "Analyze phases for parallel execution eligibility"
+- **Implementation Mode detection** - Now checks for parallel siblings before starting phase
+- **Implementation Mode phase selection** - 4-case decision logic for parallel, resume, auto-start scenarios
+- **Session end summaries** - Documentation Mode now reports parallel execution groups
+- **Abort handling** - Phases remain `[/]` on abort with clear resume instructions
+
 ## v1.3.3 - 2025-12-30
 
 ### ✨ Added
@@ -22,6 +291,7 @@ All notable changes to Plan2Code will be documented in this file.
 
 ## v1.3.2 - 2025-12-25
 
+
 ### 🔧 Changed
 
 - **Phase file naming convention** - Changed from `Phase X.md` to `phase-X.md` (lowercase, hyphen instead of space)

QUICK-REFERENCE.md

@@ -1,13 +1,13 @@
-# Plan2Code Quick Reference
+# Plam2Code Quick Reference
 
 ## Commands
 
 | Step   | Command                         | Input           | Output                              |
-| ------ | ---------------------------| --------------- | ------------------------- |
+| ------ | ------------------------------- | --------------- | ----------------------------------- |
 | Init   | /plan2code---init             | None            | AGENTS.md file                      |
 | Update | /plan2code---init-update      | AGENTS.md       | Updated AGENTS.md                   |
 | 0      | /plan2code---quick-task       | Requirements    | Conversational plan                 |
-| 1      | /plan2code-1--plan         | Requirements    | PLAN-DRAFT.md             |
+| 1      | /plan2code-1--plan            | Requirements    | PLAN-CONVERSATION-<date>.md + PLAN-DRAFT-<date>.md |
 | 1b     | /plan2code-1b--revise-plan    | Specs + changes | Updated specs                       |
 | 2      | /plan2code-2--document        | PLAN-DRAFT.md   | overview.md + Phase files           |
 | 3      | /plan2code-3--implement       | overview.md     | Implemented code                    |
@@ -17,33 +17,54 @@
 
 ```
 specs/
-├── PLAN-DRAFT-<timestamp>.md    # From Step 1
 └── <feature-name>/
+    ├── PLAN-DRAFT-<date>.md          # From Step 1 (verified plan)
+    ├── PLAN-CONVERSATION-<date>.md   # From Step 1 (conversation log)
     ├── overview.md                   # From Step 2
-    └── Phase X.md               # From Step 2
+    └── phase-X.md                    # From Step 2
 
 specs--completed/                     # After Step 4
 └── <feature-name>/                   # Archived specs
 ```
 
+Note: `<date>` uses YYYYMMDD format (e.g., `20250204`)
+
 ## Key Rules
 
 - Start NEW conversation for each step (and each implementation phase)
-- ONE phase per conversation
+- ONE phase per conversation (but parallel phases can run in separate instances)
 - Reply "approved" to complete phases
 - 90% confidence required before planning completes
 - Never look in `specs--completed/` (it's archived specs)
 
+## Phase Status
+
+| Checkbox | Status | Meaning |
+|----------|--------|---------|
+| `[ ]` | Pending | Not started |
+| `[/]` | In Progress | Agent working (or paused) |
+| `[x]` | Complete | Approved |
+
+## Parallel Execution
+
+When phases have no file conflicts or dependencies, they can run simultaneously:
+
+1. Documentation Mode auto-detects parallel-eligible phases
+2. Implementation Mode shows selection UI with status for each phase
+3. Run multiple `/plan2code-3--implement` instances on different phases
+4. `[/]` status shows which phases are actively being worked on
+
 ## Quick Troubleshooting
 
 | Issue                  | Solution                                          |
-| ---------------------- | ----------------------------------------------- |
+| ---------------------- | ------------------------------------------------- |
 | Lost context mid-phase | Attach spec files, say "resume from Task X.Y"     |
 | Wrong phase started    | Say "abort", start correct phase                  |
 | Need to change plan    | Use `/plan2code-1b--revise-plan`                |
 | Multiple spec folders  | Specify which: "Continue with specs/user-auth/"   |
 | Need AGENTS.md file    | Use `/plan2code---init` to generate one         |
 | Update AGENTS.md       | Use `/plan2code---init-update` after sessions   |
+| Run phases in parallel | Check Parallel Execution Groups in overview.md    |
 
 ## Workflow Decision
 
@@ -59,8 +80,31 @@ Is it a quick, small task?
 └── No → /plan2code-1--plan (full workflow)
          ├── /plan2code-2--document
          ├── /plan2code-3--implement (repeat per phase)
+         │   └── OR: plan2code-loop (autonomous alternative)
          └── /plan2code-4--finalize
 
 Need to revise mid-implementation?
 └── /plan2code-1b--revise-plan
 ```
+
+## Autonomous Loop (Alternative)
+
+The `plan2code-loop` CLI is an **alternative** to Step 3, not a replacement.
+
+| Approach | Use When |
+|----------|----------|
+| `/plan2code-3--implement` | You want interactive control per phase |
+| `plan2code-loop` | You want hands-off autonomous execution |
+
+```bash
+plan2code-loop   # Fully interactive - auto-detects specs, prompts for options
+```
+
+### Loop Modes
+
+| Mode | Description |
+|------|-------------|
+| **One task per loop** (default) | One task per agent invocation. Node handles git commits. |
+| **One phase per loop** | All tasks in a phase per invocation. LLM handles git commits. Best for smart models with larger context. |
+
+Session state stored per-spec in `specs/<feature>/.plan2code-loop/`

README.md

@@ -2,7 +2,7 @@
 
 A structured 4-step workflow for developing features and projects with AI assistance. This methodology emphasizes thorough planning before implementation, ensuring well-documented, maintainable code.
 
-<img src="docs/plan2code.jpg" alt="Plan2Code Workflow" height="400">
+<img src="docs/desk.jpg" alt="Plan2Code Workflow" height="275">
 
 ## Overview
 
@@ -15,8 +15,8 @@ A structured 4-step workflow for developing features and projects with AI assist
       New Chat               New Chat           New Chat (per phase)        New Chat
 ```
 
-| Command | Use When |
+| Command                          | When to Use                                              |
-|---------|----------|
+|----------------------------------|----------------------------------------------------------|
 | `/plan2code---init`            | Generate AGENTS.md file for new/existing projects        |
 | `/plan2code---init-update`     | Update AGENTS.md with new learnings from coding sessions |
 | `/plan2code---quick-task`      | Small, quick tasks that don't need full workflow         |
@@ -38,115 +38,96 @@ See [QUICK-REFERENCE.md](QUICK-REFERENCE.md) for full reference card.
 
 ## Installation
 
-### Prerequisites
+Plan2Code includes an interactive installer that generates and installs workflow files for all major AI coding assistants.
-
-**Node.js** (v14 or later) is required. If you don't have it:
-- Download from [nodejs.org](https://nodejs.org/)
-- Or: `brew install node` (macOS) | `winget install OpenJS.NodeJS` (Windows) | `sudo apt install nodejs` (Linux)
-
-### Quick Start
-
-```bash
-git clone https://github.com/jparkerweb/plan2code.git
-cd plan2code
-node install.js
-```
-
-The interactive installer will guide you through:
-- **Global installation** (recommended) - commands available in all projects
-- **Local/project installation** - commands for a specific project only
-- **Uninstall** - remove previously installed files
 
 <img src="docs/install-script.jpg" width="600">
 
+### Prerequisites
+
+The install script requires **Node.js** (v14 or later). If you don't have Node.js installed:
+
+1. Download from [nodejs.org](https://nodejs.org/) (recommended)
+2. Or use a package manager:
+   - **macOS:** `brew install node`
+   - **Windows:** `winget install OpenJS.NodeJS` or `choco install nodejs`
+   - **Linux:** `sudo apt install nodejs` (Debian/Ubuntu) or `sudo dnf install nodejs` (Fedora)
+
 ### Supported Platforms
 
-| Platform | Global Location | Invocation |
+- Claude Code
-|----------|-----------------|------------|
+- Cursor
-| Claude Code | `~/.claude/commands/` | `/plan2code-1--plan` |
+- Windsurf
-| Copilot CLI | `~/.copilot/agents/` | `--agent=plan2code-1--plan` |
+- Continue
-| VS Code Copilot | `~/Library/Application Support/Code/User/prompts/` | Slash commands |
+- Codeium (IntelliJ)
-| Windsurf | `~/.codeium/windsurf/global_workflows/` | `/plan2code-1--plan` |
+- GitHub Copilot CLI
-| Cursor | `~/.cursor/commands/` | `/plan2code-1--plan` |
+- VS Code GitHub Copilot
-| Continue | `~/.continue/prompts/` | `/plan2code-1--plan` |
+- Gemini CLI
-| Antigravity | `.agent/workflows/` (project only) | `/plan2code-1--plan` |
+- Crush
+- Amp
+- OpenCode
 
-### CLI Options
+### Install via npx (Recommended — No Clone Required)
 
+Run the interactive installer directly using `npx` with your preferred GitHub authentication method:
+
+**If you use SSH keys:**
 ```bash
-node install.js                    # Interactive menu
+npx git+ssh://git@github.com/jparkerweb/plan2code.git
-node install.js --platform claude  # Install specific platform
-node install.js --local            # Install to current project instead of global
-node install.js --dry-run          # Preview what would be installed
-node install.js --uninstall        # Remove installed files
-node install.js --help             # Show all options
 ```
 
----
+**If you use HTTPS authentication:**
-
-<details>
-<summary>Platform Details</summary>
-
-### Claude Code CLI
-
-Type `/plan2code-1--plan` in chat. Restart Claude Code after installation.
-
-**Docs:** [Claude Code Slash Commands](https://code.claude.com/docs/en/slash-commands)
-
-### GitHub Copilot CLI
-
 ```bash
-copilot --agent=plan2code-1--plan --prompt "I want to build a REST API"
+npx git+https://github.com/jparkerweb/plan2code.git
 ```
 
-Requires: `npm install -g @github/copilot@latest`
+This downloads the installer to a temporary location, runs it, installs the workflow files to your machine, and cleans up automatically. The installed workflows remain on your system and work independently. To update or reinstall, simply run the command again.
 
-**Docs:** [GitHub Copilot CLI Custom Agents](https://docs.github.com/en/copilot/concepts/agents/about-copilot-cli)
+### Standard Installation (Clone Method)
 
-### VS Code GitHub Copilot
+#### No Clone Required
 
-Open Copilot Chat (`Ctrl+Shift+I`), type `/` to see prompts. Requires per-project install via `node install.js --local`.
+Run the interactive installer directly using `npx` with your preferred GitHub authentication method:
 
-**Docs:** [VS Code Copilot Prompt Files](https://code.visualstudio.com/docs/copilot/customization/prompt-files)
+**If you use SSH keys:**
+```bash
+npx git+ssh://git@github.com/jparkerweb/plan2code.git
+```
 
-### Windsurf IDE
+**If you use HTTPS authentication:**
+```bash
+npx git+https://github.com/jparkerweb/plan2code.git
+```
 
-Type `/plan2code-1--plan` in Cascade. Note: 12,000 character limit per workflow.
+This downloads the installer to a temporary location, runs it, installs the workflow files to your machine, and cleans up automatically. The installed workflows remain on your system and work independently. To update or reinstall, simply run the command again.
 
-**Docs:** [Windsurf Workflows](https://docs.windsurf.com/windsurf/cascade/workflows)
+#### Standard Installation (Clone Method)
 
-### Cursor AI
+```bash
+# Clone the repository
+git clone https://github.com/jparkerweb/plan2code.git
+cd plan2code
 
-Type `/` in chat, select command from dropdown.
+# Run the interactive installer
+node install.js
 
-**Docs:** [Cursor Commands](https://docs.cursor.com/agent/chat/commands)
+# OPTIONAL: Install dev dependencies (ONLY if you plan to modify/contribute to Plan2Code)
+npm install
+```
 
-### Google Antigravity
+The installer displays an interactive menu:
 
-Type `/plan2code-1--plan` in chat. Requires per-project install via `node install.js --local`.
+```
+╔════════════════════════════════════════════════════════════════╗
+║ INSTALL PLAN2CODE                                            ║
+╠════════════════════════════════════════════════════════════════╣
+║  I.  INSTALL    Install Plan2Code for all platforms          ║
+║  U.  UNINSTALL  Remove Plan2Code files                       ║
+║  C.  CUSTOM     Advanced options                               ║
+║  Q.  QUIT       Exit                                           ║
+╚════════════════════════════════════════════════════════════════╝
 
-**Docs:** [Customize Antigravity](https://atamel.dev/posts/2025/11-25_customize_antigravity_rules_workflows/)
+SELECT OPTION (I, U, C, Q) [I]:
-
+```
-### Continue (VS Code/JetBrains)
-
-Type `/plan2code-1--plan` in chat. Install the Continue extension first.
-
-**Docs:** [Continue Prompts](https://docs.continue.dev/customize/deep-dives/prompts)
-
-</details>
-
----
-
-<details>
-<summary>Manual Installation</summary>
-
-If your AI tool isn't listed or you prefer manual setup:
-
-1. **Copy/Paste:** Copy contents from `src/plan2code-*.md` files into your conversation
-2. **File Reference:** Tell the AI: `Please follow the instructions in src/plan2code-1--plan.md`
-3. **Custom Integration:** Adapt files from `dist/` directories to your tool's format
-
-</details>
 
 ---
 
@@ -180,7 +161,7 @@ Fresh conversations prevent context pollution and ensure the AI focuses on the c
 5. **Technical Specification** - Break down implementation phases, identify risks
 6. **Transition Decision** - Finalize plan when confidence reaches 90%+
 
-**Output:** `specs/PLAN-DRAFT-<timestamp>.md` containing the complete implementation plan
+**Output:** `specs/<feature-name>/PLAN-DRAFT-<date>.md` and `specs/<feature-name>/PLAN-CONVERSATION-<date>.md` (date format: YYYYMMDD)
 
 **Key Behaviors:**
 
@@ -195,19 +176,21 @@ Fresh conversations prevent context pollution and ensure the AI focuses on the c
 
 **Purpose:** Transform the planning output into structured, actionable implementation documents.
 
-**Required Context:** Attach or reference the `specs/PLAN-DRAFT-<timestamp>.md` from Step 1 (or provide the planning conversation).
+**Required Context:** Attach or reference the `specs/<feature-name>/PLAN-DRAFT-<date>.md` from Step 1 (or provide the planning conversation).
 
 **Output Structure:**
 
 ```
 specs/
 └── <feature-name>/
-    ├── overview.md          # High-level overview with phase checkboxes
+    ├── overview.md          # High-level overview with phase checkboxes and parallel groups
     ├── Phase 1.md           # Detailed tasks for Phase 1
     ├── Phase 2.md           # Detailed tasks for Phase 2
     └── Phase N.md           # ...additional phases
 ```
 
+The `overview.md` includes a "Parallel Execution Groups" section that identifies which phases can be run simultaneously in separate agent instances.
+
 **Document Format:**
 
 - Each phase file contains detailed one-story-point tasks
@@ -228,11 +211,14 @@ specs/
 **Workflow:**
 
 1. Identify the next uncompleted phase (unchecked in `overview.md`)
-2. Implement ALL tasks in that phase exactly as specified
+2. Check for parallel execution options (if phases can run simultaneously)
-3. Update `Phase X.md` checkboxes as tasks complete `[x]`
+3. Implement ALL tasks in that phase exactly as specified
-4. Update `overview.md` phase checkbox when phase completes
+4. Update `Phase X.md` checkboxes as tasks complete `[x]`
-5. Perform code review to ensure nothing was missed
+5. Update `overview.md` phase checkbox when phase completes
-6. Add completion summary to the phase document
+6. Perform code review to ensure nothing was missed
+7. Add completion summary to the phase document
+
+**Parallel Execution:** If the next phase is part of a parallel-eligible group, you'll be prompted to choose which phase to implement. This allows running multiple agent instances simultaneously on different phases that don't conflict with each other.
 
 **Key Rules:**
 
@@ -260,35 +246,17 @@ specs/
 
 ---
 
-## How to Use These Prompts
+## How to Use
 
-### Option 1: Platform-Specific Slash Commands (Recommended)
+After running `node install.js`, use the slash commands directly in your AI tool:
-
-This repository includes pre-configured workflow files for all major AI coding assistants. See the [Installation](#installation) section above for platform-specific setup instructions.
-
-**Quick commands after setup:**
 
 ```
-/plan           # Start planning a new feature
+/plan2code-1--plan           # Start planning a new feature
-/document       # Create implementation docs from plan
+/plan2code-2--document       # Create implementation docs from plan
-/implement      # Begin/continue implementation
+/plan2code-3--implement      # Begin/continue implementation
-/finalize       # Wrap up after all phases complete
+/plan2code-4--finalize       # Wrap up after all phases complete
 ```
 
-### Option 2: Direct File Reference
-
-Reference the prompt files directly in your conversation:
-
-```
-Please follow the instructions in src/plan2code-1--plan.md
-
-I want to build a user authentication system with OAuth support.
-```
-
-### Option 3: Copy/Paste
-
-Copy the contents of each prompt file and paste at the beginning of your conversation when starting that step.
-
 ---
 
 ## Complete Workflow Example
@@ -305,14 +273,14 @@ AI:   🤔 [REQUIREMENTS ANALYSIS]
       ... asks clarifying questions, works through phases ...
 
 AI:   🤔 [TRANSITION DECISION]
-      Confidence: 92%. Creating specs/PLAN DRAFT.md...
+      Confidence: 92%. Creating specs/task-api/PLAN-DRAFT-20250204.md...
 ```
 
 **Session 2 - Documentation (New Chat):**
 
 ```
 User: [Paste or invoke Step 2 prompt]
-      [Attach: specs/PLAN DRAFT.md]
+      [Attach: specs/task-api/PLAN-DRAFT-20250204.md]
 
 AI:   📝 [DOCUMENTATION]
       Creating specs/task-api/overview.md...
@@ -372,18 +340,24 @@ AI:   🧹 [SPEC CLEANUP]
 
 The checkbox system enables seamless progress tracking across multiple sessions:
 
-**overview.md:**
+**Phase Status (overview.md):**
+
+| Checkbox | Status | Meaning |
+|----------|--------|---------|
+| `[ ]` | Pending | Not yet started |
+| `[/]` | In Progress | Agent actively working (or paused/aborted) |
+| `[x]` | Complete | Finished and approved |
 
 ```markdown
 ## Phases
 
 - [x] Phase 1: Project Setup
 - [x] Phase 2: Database Models
-- [ ] Phase 3: API Endpoints <- Next phase to implement
+- [/] Phase 3: API Endpoints <- In progress (agent working)
-- [ ] Phase 4: Authentication
+- [ ] Phase 4: Authentication <- Next available
 ```
 
-**Phase 3.md:**
+**Task Status (phase-X.md):**
 
 ```markdown
 ## Tasks
@@ -395,6 +369,8 @@ The checkbox system enables seamless progress tracking across multiple sessions:
 - [ ] Implement DELETE /tasks/:id
 ```
 
+The `[/]` status enables parallel execution - multiple agents can work on different phases simultaneously, and you can see which phases are actively being worked on.
+
 ---
 
 ## Best Practices
@@ -415,12 +391,69 @@ The checkbox system enables seamless progress tracking across multiple sessions:
 | Step               | Required Input                                       |
 | ------------------ | ---------------------------------------------------- |
 | Step 1 (Plan)      | None (describe your feature/project)                 |
-| Step 2 (Document)  | `specs/PLAN DRAFT.md` or planning conversation       |
+| Step 2 (Document)  | `specs/<feature>/PLAN-DRAFT-<date>.md` or planning conversation |
 | Step 3 (Implement) | `specs/<feature>/overview.md` (auto-detects phase)   |
 | Step 4 (Finalize)  | `specs/<feature>/overview.md`                        |
 
 ---
 
+## Autonomous Loop (Alternative to Step 3)
+
+For hands-off implementation, Plan2Code includes an optional autonomous loop CLI that iterates through your spec tasks automatically.
+
+> **Note:** The loop is an **alternative** to `/plan2code-3--implement`, not a replacement. Use the manual Step 3 workflow when you want direct control over each phase, or use the loop when you prefer autonomous execution.
+
+### When to Use Each
+
+| Approach | Best For |
+|----------|----------|
+| `/plan2code-3--implement` | Interactive control, reviewing each phase, complex logic requiring human judgment |
+| `plan2code-loop` | Straightforward implementations, batch processing, overnight runs |
+
+### Installing the Loop
+
+```bash
+# From the plan2code root directory:
+
+# Option 1: Install everything (recommended)
+node install.js  # Select I at the menu
+
+# Option 2: Install loop only
+node install.js  # Select C, then O at the menu
+```
+
+### Using the Loop
+
+```bash
+# Run the loop - fully interactive
+plan2code-loop
+```
+
+The CLI will:
+1. Auto-detect specs in `./specs/` directory
+2. Let you select a spec if multiple are found
+3. Prompt to continue if an existing session is found
+4. Ask for JIRA ticket ID, agent selection, loop mode, and max iterations
+
+### Loop Modes
+
+| Mode | Behavior | Git Commits | Best For |
+|------|----------|-------------|----------|
+| **One task per loop** (default) | Each agent call implements one task | Node controller commits after each task | Smaller models, cautious execution |
+| **One phase per loop** | Each agent call implements all tasks in a phase | LLM commits after each task (with JIRA ID) | Smart models with larger context windows, related tasks |
+
+Session state is stored per-spec in `specs/<feature>/.plan2code-loop/`, keeping each feature's progress isolated.
+
+The loop will:
+1. Read your `overview.md` and phase files
+2. Find the first unchecked task (or phase, in phase mode)
+3. Implement it and mark the checkbox complete
+4. Repeat until all tasks are done or max iterations reached
+
+See [plan2code-loop/](plan2code-loop/) for full documentation.
+
+---
+
 ## File Structure After Complete Implementation
 
 ```
@@ -456,9 +489,9 @@ Feel free to modify these prompts to fit your workflow:
 
 **Slash commands/workflows not recognized:**
 
-- Check if your project's `.gitignore` includes patterns like `.windsurf/`, `.cursor/`, `.continue/`, or `.agent/`
+- Ensure you ran `node install.js` and selected the appropriate platform
-- Many AI tools don't recognize workflows in gitignored directories
+- Restart your AI tool after installation
-- Solution: Use global installation by copying the directories to your home directory (e.g., `cp -r .windsurf ~/`)
+- For per-project installation, ensure the directory isn't in `.gitignore`
 
 **AI jumps ahead to implementation during planning:**
 
@@ -481,5 +514,3 @@ Feel free to modify these prompts to fit your workflow:
 **Too many/few phases:**
 
 - Adjust during Step 2 (Documentation) - phases should represent logical groupings of work
-
-

package.json

@@ -0,0 +1,14 @@
+{
+  "name": "plan2code",
+  "version": "1.8.1",
+  "private": true,
+  "bin": {
+    "plan2code": "./install.js"
+  },
+  "scripts": {
+    "prepare": "husky"
+  },
+  "devDependencies": {
+    "husky": "^9.0.0"
+  }
+}

plan2code-loop/README.md

@@ -0,0 +1,210 @@
+# Plan2Code Loop
+
+An autonomous CLI tool that implements Plan2Code specs by looping through tasks automatically.
+
+> **Note:** This is an **alternative** to `/plan2code-3--implement`, not a replacement. Use the manual Step 3 workflow when you want interactive control over each phase, or use this loop when you prefer hands-off autonomous execution.
+
+## Installation
+
+```bash
+# From the plan2code root directory:
+
+# Option 1: Install everything (recommended)
+node install.js  # Select option A
+
+# Option 2: Install loop only
+node install.js  # Select option O
+
+# Option 3: Manual build and link
+cd plan2code-loop
+npm install
+npm run build
+npm link
+```
+
+## Usage
+
+Simply run the command - everything is interactive:
+
+```bash
+plan2code-loop
+```
+
+The CLI will:
+1. Auto-detect specs in `./specs/` directory
+2. Let you select a spec if multiple are found
+3. Prompt to continue if an existing session is found
+4. Ask for JIRA ticket ID, agent selection, loop mode, and max iterations
+
+## How It Works
+
+The loop uses an **LLM-driven discovery** approach:
+
+1. **Spec Selection** - Interactive menu to select from discovered specs
+2. **Task Discovery** - The AI reads `overview.md` and phase files to find unchecked tasks
+3. **Implementation** - The AI implements tasks (one per iteration in task mode, or all in a phase in phase mode)
+4. **Checkbox Update** - The AI marks tasks complete in the markdown file
+5. **Scratchpad Update** - The AI appends notes to the per-spec scratchpad
+6. **Completion Marker** - The AI outputs structured markers (e.g., `TASK_COMPLETE: 1.1 - description`)
+7. **Loop** - Repeat until all tasks done or max iterations reached
+
+### Loop Modes
+
+The CLI asks you to choose a loop mode:
+
+| Mode | Behavior | Git Commits | Best For |
+|------|----------|-------------|----------|
+| **One task per loop** (default) | Each agent invocation implements exactly one task | Node controller commits after each task | Smaller models, careful step-by-step execution |
+| **One phase per loop** | Each agent invocation implements all remaining tasks in the current phase | LLM commits after each task (with JIRA ID if provided) | Smart models with larger context windows, keeping related tasks together |
+
+### Why LLM-Driven?
+
+The Node app does NOT parse markdown to find tasks. Instead, the AI reads the spec files directly and decides what to work on. This is:
+
+- **More flexible** - Works with any reasonable markdown format
+- **Smarter** - AI can handle edge cases and ambiguity
+- **Simpler** - Node code is just orchestration, not parsing
+
+## Completion Markers
+
+The AI must output one of these markers at the end of each iteration:
+
+```
+TASK_COMPLETE: 1.1 - Initialize project structure
+TASK_BLOCKED: 2.3 - Missing API credentials
+PHASE_COMPLETE
+LOOP_COMPLETE
+```
+
+| Marker | Meaning |
+|--------|---------|
+| `TASK_COMPLETE: X.X - desc` | Task implemented and marked complete |
+| `TASK_BLOCKED: X.X - reason` | Cannot complete task (explains why) |
+| `PHASE_COMPLETE` | Current phase finished (phase mode only) |
+| `LOOP_COMPLETE` | All phases finished |
+
+In **phase mode**, the AI outputs multiple `TASK_COMPLETE` markers (one per task) within a single iteration, followed by `PHASE_COMPLETE` or `LOOP_COMPLETE`.
+
+## Session Files
+
+Session state is stored **per-spec** inside the spec directory:
+
+```
+specs/my-feature/
+├── overview.md
+├── phase-1.md
+├── phase-2.md
+└── .plan2code-loop/        # Per-spec session state
+    ├── config.json           # Session configuration
+    ├── scratchpad.md         # LLM-managed progress notes
+    ├── iteration.log         # JSON log of each iteration
+    └── spec.hash             # Hash for detecting spec changes
+```
+
+The scratchpad is managed by the LLM itself - after each task, the AI appends notes about what was done, decisions made, and files changed. This helps future iterations skip exploration.
+
+## Supported Agents
+
+| Agent | Status |
+|-------|--------|
+| Claude Code | Supported |
+| GitHub Copilot CLI | Supported |
+
+The loop uses your configured default model for each agent.
+
+## Example Session
+
+```
+$ plan2code-loop
+
+    ╭──────────────────────────────────────╮
+    │                                      │
+    │   🔮  Plany's Loop               │
+    │       Autonomous Implementation      │
+    │                                      │
+    ╰──────────────────────────────────────╯
+
+Found spec: specs/todo-app
+  Feature: Todo App
+  Phases: 0/3
+  Tasks: 0/15
+
+══════════════════════════════════════════════
+Spec: Todo App
+══════════════════════════════════════════════
+Phases: 0/3
+Tasks: 0/15
+
+? JIRA Ticket ID (optional): PROJ-123
+? Select AI agent: Claude Code
+? Tasks per loop iteration: One task per loop (default)
+? Maximum iterations: 100
+
+Starting Plan2Code Loop
+══════════════════════════════════════════════
+Agent: Claude Code
+Model: default
+Spec: C:\projects\my-app\specs\todo-app
+Loop mode: One task per loop
+Max iterations: 100
+
+Iteration 1/100
+[1/100] Task 1.1: Initialize project with Vite (45s)
+✓ Completed: Task 1.1: Initialize project with Vite
+
+Iteration 2/100
+[2/100] Task 1.2: Configure TypeScript (32s)
+✓ Completed: Task 1.2: Configure TypeScript
+
+...
+
+Session Summary
+══════════════════════════════════════════════
+Total iterations: 12
+Tasks completed: 12
+Exit reason: all_complete
+
+Session files saved to specs/todo-app/.plan2code-loop:
+  - config.json (session configuration)
+  - scratchpad.md (LLM-managed notes)
+  - iteration.log (history)
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Link for global usage
+npm link
+
+# Unlink
+npm unlink
+```
+
+## Architecture
+
+```
+src/
+├── bin/plan2code-loop.ts   # CLI entry point
+├── index.ts                  # Main exports
+├── controller.ts             # Loop orchestration
+├── cli.ts                    # Interactive prompts
+├── agents/                   # Agent implementations
+│   ├── claude-code.ts
+│   └── copilot-cli.ts
+├── prompt/                   # Prompt building
+│   ├── templates.ts
+│   └── builder.ts
+├── state/                    # Session state management
+│   └── manager.ts
+├── spec/                     # Spec utilities (for CLI display)
+│   └── utils.ts
+└── utils/                    # Utilities
+    ├── completion.ts         # Marker parsing
+    └── logger.ts
+```

plan2code-loop/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "plan2code-loop",
+  "version": "1.6.2",
+  "description": "Plan2Code Loop - Autonomous spec-driven implementation CLI",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "plan2code-loop": "./dist/bin/plan2code-loop.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "agent",
+    "automation",
+    "claude",
+    "copilot",
+    "spec-driven"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "start": "node dist/bin/plan2code-loop.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.1.0",
+    "chalk": "^5.6.2",
+    "execa": "^9.6.1",
+    "fs-extra": "^11.3.3",
+    "ora": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.0.3",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}
+

plan2code-loop/src/agents/claude-code.ts

@@ -0,0 +1,82 @@
+import type { Agent, AgentConfig, AgentExecutionOptions, AgentExecutionResult } from './types.js';
+import { executeCommand } from '../utils/process.js';
+import { writeFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+const claudeCodeConfig: AgentConfig = {
+  name: 'claude-code',
+  displayName: 'Claude Code',
+  command: 'claude',
+  models: [
+    { value: 'default', label: 'Default (use Claude config)' },
+  ],
+  defaultModel: 'default',
+  flags: {
+    prompt: '--print',
+    model: '--model',
+    skipPermissions: '--dangerously-skip-permissions',
+  },
+};
+
+class ClaudeCodeAgent implements Agent {
+  readonly config = claudeCodeConfig;
+
+  async execute(options: AgentExecutionOptions): Promise<AgentExecutionResult> {
+    // Write prompt to temp file - more reliable than stdin on Windows
+    const tempFile = join(tmpdir(), `plan2code-prompt-${Date.now()}.txt`);
+    writeFileSync(tempFile, options.prompt, 'utf-8');
+
+    try {
+      // Build args: flags first, then read prompt from temp file via shell
+      const args: string[] = [
+        this.config.flags.prompt,  // --print for non-interactive mode
+        this.config.flags.skipPermissions,
+      ];
+
+      // Only add --model if not using default
+      if (options.model && options.model !== 'default') {
+        args.push(this.config.flags.model, options.model);
+      }
+
+      // Use stdin from the temp file
+      const result = await executeCommand({
+        command: this.config.command,
+        args,
+        cwd: options.cwd,
+        timeout: options.timeout,
+        signal: options.signal,
+        stdinFile: tempFile,
+      });
+
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode,
+        timedOut: result.timedOut,
+        cancelled: result.cancelled,
+        duration: result.duration,
+      };
+    } finally {
+      // Clean up temp file
+      try {
+        unlinkSync(tempFile);
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+  }
+
+  async isAvailable(): Promise<boolean> {
+    // Run claude --version to verify it's actually installed and working
+    const result = await executeCommand({
+      command: this.config.command,
+      args: ['--version'],
+      cwd: process.cwd(),
+      timeout: 5000,
+    });
+    return result.exitCode === 0;
+  }
+}
+
+export const claudeCodeAgent = new ClaudeCodeAgent();

plan2code-loop/src/agents/copilot-cli.ts

@@ -0,0 +1,70 @@
+import type { Agent, AgentConfig, AgentExecutionOptions, AgentExecutionResult } from './types.js';
+import { executeCommand } from '../utils/process.js';
+
+const copilotCliConfig: AgentConfig = {
+  name: 'copilot-cli',
+  displayName: 'GitHub Copilot CLI',
+  command: 'copilot',
+  models: [
+    { value: 'claude-sonnet-4', label: 'Claude Sonnet 4 (Default)' },
+    { value: 'claude-sonnet-4.5', label: 'Claude Sonnet 4.5' },
+    { value: 'claude-opus-4.5', label: 'Claude Opus 4.5' },
+    { value: 'gpt-5', label: 'GPT-5' },
+    { value: 'gpt-5-mini', label: 'GPT-5 Mini' },
+    { value: 'gemini-3-pro-preview', label: 'Gemini 3 Pro' },
+  ],
+  defaultModel: 'claude-sonnet-4',
+  flags: {
+    prompt: '-p',
+    model: '--model',
+    skipPermissions: '--allow-all-tools',
+    silent: '-s',
+  },
+};
+
+class CopilotCliAgent implements Agent {
+  readonly config = copilotCliConfig;
+
+  async execute(options: AgentExecutionOptions): Promise<AgentExecutionResult> {
+    // Use stdin for prompt to handle multi-line text properly
+    const args: string[] = [];
+
+    // Only add --model if not using default
+    if (options.model && options.model !== 'default') {
+      args.push(this.config.flags.model, options.model);
+    }
+
+    args.push(this.config.flags.skipPermissions, this.config.flags.silent!);
+
+    const result = await executeCommand({
+      command: this.config.command,
+      args,
+      cwd: options.cwd,
+      timeout: options.timeout,
+      signal: options.signal,
+      stdin: options.prompt,
+    });
+
+    return {
+      stdout: result.stdout,
+      stderr: result.stderr,
+      exitCode: result.exitCode,
+      timedOut: result.timedOut,
+      cancelled: result.cancelled,
+      duration: result.duration,
+    };
+  }
+
+  async isAvailable(): Promise<boolean> {
+    // Run copilot --version to verify it's installed
+    const result = await executeCommand({
+      command: this.config.command,
+      args: ['--version'],
+      cwd: process.cwd(),
+      timeout: 5000,
+    });
+    return result.exitCode === 0;
+  }
+}
+
+export const copilotCliAgent = new CopilotCliAgent();

plan2code-loop/src/agents/index.ts

@@ -0,0 +1,19 @@
+export type {
+  Agent,
+  AgentConfig,
+  AgentExecutionOptions,
+  AgentExecutionResult,
+  ModelOption,
+} from './types.js';
+
+export { agentRegistry } from './registry.js';
+export { claudeCodeAgent } from './claude-code.js';
+export { copilotCliAgent } from './copilot-cli.js';
+
+// Register all agents
+import { agentRegistry } from './registry.js';
+import { claudeCodeAgent } from './claude-code.js';
+import { copilotCliAgent } from './copilot-cli.js';
+
+agentRegistry.register(claudeCodeAgent);
+agentRegistry.register(copilotCliAgent);

plan2code-loop/src/agents/registry.ts

@@ -0,0 +1,34 @@
+import type { Agent } from './types.js';
+
+class AgentRegistry {
+  private agents: Map<string, Agent> = new Map();
+
+  register(agent: Agent): void {
+    this.agents.set(agent.config.name, agent);
+  }
+
+  get(name: string): Agent | undefined {
+    return this.agents.get(name);
+  }
+
+  getAll(): Agent[] {
+    return Array.from(this.agents.values());
+  }
+
+  getAvailable(): Promise<Agent[]> {
+    return Promise.all(
+      this.getAll().map(async (agent) => ({
+        agent,
+        available: await agent.isAvailable(),
+      }))
+    ).then((results) =>
+      results.filter((r) => r.available).map((r) => r.agent)
+    );
+  }
+
+  getNames(): string[] {
+    return Array.from(this.agents.keys());
+  }
+}
+
+export const agentRegistry = new AgentRegistry();

plan2code-loop/src/agents/types.ts

@@ -0,0 +1,42 @@
+export interface ModelOption {
+  value: string;
+  label: string;
+}
+
+export interface AgentConfig {
+  name: string;
+  displayName: string;
+  command: string;
+  models: ModelOption[];
+  defaultModel: string;
+  flags: {
+    prompt: string;
+    model: string;
+    skipPermissions: string;
+    silent?: string;
+  };
+}
+
+export interface AgentExecutionOptions {
+  prompt: string;
+  model: string;
+  timeout: number;       // milliseconds
+  verbose: boolean;
+  cwd: string;
+  signal?: AbortSignal;  // For cancellation
+}
+
+export interface AgentExecutionResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  timedOut: boolean;
+  cancelled: boolean;
+  duration: number;      // milliseconds
+}
+
+export interface Agent {
+  config: AgentConfig;
+  execute(options: AgentExecutionOptions): Promise<AgentExecutionResult>;
+  isAvailable(): Promise<boolean>;
+}

plan2code-loop/src/bin/plan2code-loop.ts

@@ -0,0 +1,34 @@
+import { run } from '../index.js';
+import { logger } from '../utils/index.js';
+
+async function main() {
+  try {
+    const result = await run();
+
+    if (!result) {
+      process.exit(0);
+    }
+
+    // Exit codes per spec
+    switch (result.exitReason) {
+      case 'all_complete':
+        logger.success('Loop completed successfully - all tasks done!');
+        process.exit(0);
+      case 'max_iterations':
+        logger.warning('Loop ended: max iterations reached');
+        process.exit(1);
+      case 'interrupted':
+        logger.info('Loop interrupted by user');
+        process.exit(2);
+      case 'error':
+        logger.error('Loop ended with error');
+        process.exit(3);
+    }
+
+  } catch (error) {
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(3);
+  }
+}
+
+main();

plan2code-loop/src/cli.ts

@@ -0,0 +1,239 @@
+import path from 'path';
+import { confirm, input, select } from '@inquirer/prompts';
+import { agentRegistry } from './agents/index.js';
+import { StateManager, type SessionConfig, type LoopMode } from './state/index.js';
+import { detectSpecDirectories, getSpecProgress } from './spec/utils.js';
+import { logger } from './utils/index.js';
+
+export interface SessionSetupResult {
+  config: SessionConfig;
+  isResume: boolean;
+}
+
+/**
+ * Detect and select a spec directory
+ */
+async function selectSpec(cwd: string = process.cwd()): Promise<string | null> {
+  // Auto-detect spec directories
+  const specDirs = await detectSpecDirectories(cwd);
+
+  if (specDirs.length === 0) {
+    logger.error('No spec directories found!');
+    logger.info('Expected: specs/<feature>/overview.md');
+    logger.info('');
+    logger.info('To get started:');
+    logger.info('');
+    logger.info('1. Create a spec using `plan2code-1--plan`');
+    logger.info('   command in our AI Agent');
+    logger.info('');
+    logger.info('2. Come back here and run `plan2code-loop`');
+    logger.info('   as an alternative to `plan2code-3--implement`');
+    logger.info('');
+    return null;
+  }
+
+  if (specDirs.length === 1) {
+    const spec = specDirs[0];
+    const progress = await getSpecProgress(spec);
+    logger.info(`Found spec: ${path.relative(cwd, spec)}`);
+    logger.dim(`  Feature: ${progress.featureName}`);
+    logger.dim(`  Phases: ${progress.totalPhases}`);
+    return spec;
+  }
+
+  // Multiple specs - let user choose
+  const choices = await Promise.all(
+    specDirs.map(async (spec) => {
+      const progress = await getSpecProgress(spec);
+      const relativePath = path.relative(cwd, spec);
+      return {
+        name: `${progress.featureName} (${progress.totalPhases} phases) - ${relativePath}`,
+        value: spec,
+      };
+    })
+  );
+
+  const selectedSpec = await select({
+    message: 'Select spec to implement:',
+    choices,
+  });
+
+  return selectedSpec;
+}
+
+/**
+ * Select AI agent
+ */
+async function selectAgent(): Promise<string> {
+  const allAgents = agentRegistry.getAll();
+
+  const agentName = await select({
+    message: 'Select AI agent:',
+    choices: allAgents.map((agent) => ({
+      name: agent.config.displayName,
+      value: agent.config.name,
+    })),
+  });
+
+  return agentName;
+}
+
+/**
+ * Prompt for JIRA ticket ID
+ */
+async function promptJiraTicketId(): Promise<string | undefined> {
+  const ticketId = await input({
+    message: 'JIRA Ticket ID (optional, for commit messages):',
+  });
+
+  return ticketId.trim() || undefined;
+}
+
+/**
+ * Select maximum iterations
+ */
+async function selectMaxIterations(): Promise<number> {
+  const choices = [15, 30, 50, 75, 100, 125, 150, 200];
+
+  const max = await select({
+    message: 'Maximum iterations:',
+    choices: choices.map((n) => ({
+      name: n.toString(),
+      value: n,
+    })),
+    default: 100,
+  });
+
+  return max;
+}
+
+/**
+ * Select loop mode: one task per loop or one phase per loop
+ */
+async function selectLoopMode(): Promise<LoopMode> {
+  const mode = await select<LoopMode>({
+    message: 'Tasks per loop iteration:',
+    choices: [
+      {
+        name: 'One task per loop (default)',
+        value: 'task' as LoopMode,
+      },
+      {
+        name: 'One phase per loop (related tasks together)',
+        value: 'phase' as LoopMode,
+      },
+    ],
+    default: 'task',
+  });
+
+  return mode;
+}
+
+/**
+ * Handle existing session - returns action to take
+ */
+async function handleExistingSession(
+  stateManager: StateManager,
+  specPath: string
+): Promise<'continue' | 'fresh' | 'new'> {
+  const state = await stateManager.detectSessionState(specPath);
+
+  if (state === 'new') {
+    return 'new';
+  }
+
+  if (state === 'continue') {
+    const config = await stateManager.readConfig();
+    const lastIter = config?.currentIteration ?? 0;
+
+    logger.info(`Found existing session at iteration ${lastIter}`);
+
+    const continueSession = await confirm({
+      message: 'Continue previous session?',
+      default: true,
+    });
+
+    return continueSession ? 'continue' : 'fresh';
+  }
+
+  if (state === 'changed') {
+    logger.warning('Spec has changed since last session.');
+
+    const startFresh = await confirm({
+      message: 'Start fresh? (This will clear previous progress)',
+      default: false,
+    });
+
+    return startFresh ? 'fresh' : 'continue';
+  }
+
+  return 'new';
+}
+
+/**
+ * Setup session via interactive prompts
+ */
+export async function setupSession(
+  stateManager: StateManager
+): Promise<SessionSetupResult | null> {
+  // Show Planny welcome
+  logger.welcome();
+
+  // Select spec
+  const specPath = await selectSpec(process.cwd());
+  if (!specPath) {
+    return null;
+  }
+
+  // Set spec path on state manager for per-spec state directory
+  stateManager.setSpecPath(specPath);
+
+  // Show spec progress
+  const progress = await getSpecProgress(specPath);
+  console.log();
+  logger.header(`Spec: ${progress.featureName}`);
+  logger.info(`Phases: ${progress.totalPhases}`);
+  console.log();
+
+  // Check for existing session
+  const sessionAction = await handleExistingSession(stateManager, specPath);
+
+  if (sessionAction === 'continue') {
+    const existingConfig = await stateManager.readConfig();
+    if (existingConfig) {
+      const agent = await selectAgent();
+      existingConfig.agent = agent;
+      await stateManager.writeConfig(existingConfig);
+      logger.info('Resuming previous session...');
+      return { config: existingConfig, isResume: true };
+    }
+  }
+
+  if (sessionAction === 'fresh') {
+    await stateManager.clearState();
+  }
+
+  // Collect new session configuration
+  const jiraTicketId = await promptJiraTicketId();
+  const agent = await selectAgent();
+  const loopMode = await selectLoopMode();
+  const maxIterations = await selectMaxIterations();
+
+  const config: SessionConfig = {
+    agent,
+    model: 'default',
+    maxIterations,
+    specPath,
+    timeout: 30,
+    verbose: false,
+    startedAt: new Date().toISOString(),
+    currentIteration: 0,
+    jiraTicketId,
+    loopMode,
+  };
+
+  // Initialize session
+  await stateManager.initializeNewSession(config);
+
+  return { config, isResume: false };
+}

plan2code-loop/src/controller.ts

@@ -0,0 +1,452 @@
+import { agentRegistry, type Agent, type AgentExecutionResult } from './agents/index.js';
+import { StateManager, type SessionConfig, type IterationLogEntry } from './state/index.js';
+import { buildLoopPrompt } from './prompt/index.js';
+import { checkForCompletion, checkForAllCompletions, logger, ensureGitRepo, ensureGitignore, type CompletionCheckResult } from './utils/index.js';
+
+export interface TaskCompleteInfo {
+  marker: string;
+  taskId?: string;
+  taskName?: string;
+}
+
+export interface ControllerOptions {
+  config: SessionConfig;
+  stateManager: StateManager;
+  onIteration?: (iteration: number, max: number) => void;
+  onTaskComplete?: (info: TaskCompleteInfo) => void | Promise<void>;
+  onLoopComplete?: () => void;
+}
+
+export interface LoopResult {
+  completed: boolean;
+  iterations: number;
+  finalMarker?: string;
+  exitReason: 'all_complete' | 'max_iterations' | 'interrupted' | 'error';
+  tasksCompleted: number;
+  prereqsCompleted: number;
+  error?: Error;
+}
+
+export class Controller {
+  private readonly config: SessionConfig;
+  private readonly stateManager: StateManager;
+  private readonly agent: Agent;
+  private readonly onIteration?: (iteration: number, max: number) => void;
+  private readonly onTaskComplete?: (info: TaskCompleteInfo) => void | Promise<void>;
+  private readonly onLoopComplete?: () => void;
+  private interrupted = false;
+  private abortController: AbortController | null = null;
+  private tasksCompleted = 0;
+  private prereqsCompleted = 0;
+
+  constructor(options: ControllerOptions) {
+    this.config = options.config;
+    this.stateManager = options.stateManager;
+    this.onIteration = options.onIteration;
+    this.onTaskComplete = options.onTaskComplete;
+    this.onLoopComplete = options.onLoopComplete;
+
+    const agent = agentRegistry.get(this.config.agent);
+    if (!agent) {
+      throw new Error(`Agent not found: ${this.config.agent}`);
+    }
+    this.agent = agent;
+  }
+
+  private async buildPrompt(): Promise<string> {
+    return buildLoopPrompt({
+      specPath: this.config.specPath,
+      iteration: this.config.currentIteration + 1,
+      maxIterations: this.config.maxIterations,
+      stateManager: this.stateManager,
+      loopMode: this.config.loopMode || 'task',
+      jiraTicketId: this.config.jiraTicketId,
+    });
+  }
+
+  private async executeIteration(prompt: string): Promise<AgentExecutionResult> {
+    const timeoutMs = this.config.timeout * 60 * 1000;
+
+    // Create new AbortController for this iteration
+    this.abortController = new AbortController();
+
+    const result = await this.agent.execute({
+      prompt,
+      model: this.config.model,
+      timeout: timeoutMs,
+      verbose: this.config.verbose,
+      cwd: process.cwd(),
+      signal: this.abortController.signal,
+    });
+
+    this.abortController = null;
+    return result;
+  }
+
+  private createLogEntry(
+    result: AgentExecutionResult,
+    status: IterationLogEntry['status'],
+    marker?: string
+  ): IterationLogEntry {
+    return {
+      iteration: this.config.currentIteration + 1,
+      timestamp: new Date().toISOString(),
+      duration: result.duration,
+      exitCode: result.exitCode,
+      status,
+      completionMarker: marker,
+    };
+  }
+
+  private formatTaskDisplay(completion: CompletionCheckResult): string {
+    if (completion.taskId && completion.taskName) {
+      return `Task ${completion.taskId}: ${completion.taskName}`;
+    } else if (completion.taskId) {
+      return `Task ${completion.taskId}`;
+    }
+    return '';
+  }
+
+  private displayIterationResult(result: AgentExecutionResult, iterNum: number, completion: CompletionCheckResult): void {
+    const duration = Math.round(result.duration / 1000);
+    const taskDisplay = this.formatTaskDisplay(completion);
+
+    // Show iteration completion with task info if available
+    if (taskDisplay) {
+      logger.iteration(iterNum, this.config.maxIterations, `${taskDisplay} (${duration}s)`);
+    } else {
+      logger.iteration(iterNum, this.config.maxIterations, `completed in ${duration}s`);
+    }
+
+    // Verbose mode: show full output
+    if (this.config.verbose) {
+      console.log();
+      logger.dim('--- Agent Output ---');
+      console.log(result.stdout);
+      if (result.stderr) {
+        logger.dim('--- Agent Stderr ---');
+        console.log(result.stderr);
+      }
+      logger.dim('--- End Output ---');
+      console.log();
+    } else if (result.exitCode !== 0 && result.stderr.trim()) {
+      logger.error(`  ${result.stderr.trim().split('\n')[0]}`);
+    }
+  }
+
+  async run(): Promise<LoopResult> {
+    // Pre-flight: verify agent CLI is available
+    const isAvailable = await this.agent.isAvailable();
+    if (!isAvailable) {
+      logger.error(`"${this.agent.config.displayName}" is not available!`);
+      logger.info(`Please ensure the "${this.agent.config.command}" command is installed and available in your PATH.`);
+      throw new Error(`Agent "${this.agent.config.displayName}" is not available. Please install it and try again.`);
+    }
+
+    // Ensure git repo and .gitignore are set up before any iterations
+    const gitReady = await ensureGitRepo(process.cwd());
+    if (!gitReady) {
+      throw new Error('Failed to initialize a git repository in the current working directory. Cannot start Plan2Code Loop.');
+    }
+    ensureGitignore(process.cwd());
+
+    const loopModeLabel = (this.config.loopMode || 'task') === 'phase' ? 'One phase per loop' : 'One task per loop';
+    logger.header('Starting Plan2Code Loop');
+    logger.info(`Agent: ${this.agent.config.displayName}`);
+    logger.info(`Model: ${this.config.model}`);
+    logger.info(`Spec: ${this.config.specPath}`);
+    logger.info(`Loop mode: ${loopModeLabel}`);
+    logger.info(`Max iterations: ${this.config.maxIterations}`);
+    console.log();
+
+    while (this.config.currentIteration < this.config.maxIterations) {
+      if (this.interrupted) {
+        return {
+          completed: false,
+          iterations: this.config.currentIteration,
+          exitReason: 'interrupted',
+          tasksCompleted: this.tasksCompleted,
+          prereqsCompleted: this.prereqsCompleted,
+        };
+      }
+
+      const iterNum = this.config.currentIteration + 1;
+      this.onIteration?.(iterNum, this.config.maxIterations);
+
+      console.log();
+      logger.info(`Iteration ${iterNum}/${this.config.maxIterations}`);
+
+      // Build prompt - simple, just spec path and iteration info
+      const prompt = await this.buildPrompt();
+
+      const spinner = logger.spinner('Waiting for AI Agent response (please be patient)');
+      const startTime = Date.now();
+
+      // Update spinner with elapsed time every second
+      const elapsedInterval = setInterval(() => {
+        const elapsed = Math.round((Date.now() - startTime) / 1000);
+        spinner.text = `Waiting for AI Agent response (please be patient) ... (${elapsed}s)`;
+      }, 1000);
+
+      try {
+        const result = await this.executeIteration(prompt);
+        clearInterval(elapsedInterval);
+        spinner.stop();
+
+        // Check if cancelled
+        if (result.cancelled || this.interrupted) {
+          logger.info('Agent process cancelled');
+
+          const entry: IterationLogEntry = {
+            iteration: iterNum,
+            timestamp: new Date().toISOString(),
+            duration: result.duration,
+            exitCode: -1,
+            status: 'interrupted',
+          };
+          await this.stateManager.appendIterationLog(entry);
+
+          return {
+            completed: false,
+            iterations: this.config.currentIteration,
+            exitReason: 'interrupted',
+            tasksCompleted: this.tasksCompleted,
+            prereqsCompleted: this.prereqsCompleted,
+          };
+        }
+
+        // Branch completion handling based on loop mode
+        const isPhaseMode = (this.config.loopMode || 'task') === 'phase';
+
+        if (isPhaseMode) {
+          // Phase mode: parse ALL completion markers from output
+          const allCompletions = checkForAllCompletions(result.stdout + result.stderr);
+
+          // Determine status
+          let status: IterationLogEntry['status'] = 'running';
+          if (allCompletions.tasks.length > 0 || allCompletions.loopComplete || allCompletions.phaseComplete) {
+            const hasBlocked = allCompletions.tasks.some(t => t.marker === 'TASK_BLOCKED');
+            const hasCompleted = allCompletions.tasks.some(t => t.marker === 'TASK_COMPLETE' || t.marker === 'PREREQ_COMPLETE' || t.marker === 'PREREQ_ASSUMED');
+            status = hasCompleted || allCompletions.phaseComplete || allCompletions.loopComplete ? 'completed' : hasBlocked ? 'blocked' : 'running';
+          } else if (result.timedOut) {
+            status = 'timeout';
+          } else if (result.exitCode !== 0) {
+            status = 'error';
+          }
+
+          // Log iteration with count of tasks
+          const markerSummary = allCompletions.tasks.map(t => `${t.marker}: ${t.taskId}`).join(', ');
+          const logEntry = this.createLogEntry(result, status, markerSummary || undefined);
+          await this.stateManager.appendIterationLog(logEntry);
+
+          // Display each completed task
+          const duration = Math.round(result.duration / 1000);
+          for (const task of allCompletions.tasks) {
+            if (task.marker === 'TASK_COMPLETE') {
+              this.tasksCompleted++;
+              const taskDisplay = this.formatTaskDisplay(task);
+              logger.success(taskDisplay ? `Completed: ${taskDisplay}` : 'Task completed!');
+            } else if (task.marker === 'PREREQ_COMPLETE') {
+              this.prereqsCompleted++;
+              const prereqDisplay = task.taskId && task.taskName
+                ? `Prereq ${task.taskId}: ${task.taskName}`
+                : task.taskId ? `Prereq ${task.taskId}` : 'Prerequisite';
+              logger.success(`Verified: ${prereqDisplay}`);
+            } else if (task.marker === 'PREREQ_ASSUMED') {
+              this.prereqsCompleted++;
+              const prereqDisplay = task.taskId && task.taskName
+                ? `Prereq ${task.taskId}: ${task.taskName}`
+                : task.taskId ? `Prereq ${task.taskId}` : 'Prerequisite';
+              logger.success(`Assumed: ${prereqDisplay}`);
+            } else if (task.marker === 'TASK_BLOCKED') {
+              const blockInfo = task.taskId
+                ? `Task ${task.taskId} blocked: ${task.reason || 'Unknown reason'}`
+                : `Task blocked: ${task.reason || 'Unknown reason'}`;
+              logger.warning(blockInfo);
+            }
+          }
+
+          // Show phase-level summary
+          if (allCompletions.tasks.length > 0) {
+            const completedCount = allCompletions.tasks.filter(t => t.marker === 'TASK_COMPLETE').length;
+            const prereqCount = allCompletions.tasks.filter(t => t.marker === 'PREREQ_COMPLETE' || t.marker === 'PREREQ_ASSUMED').length;
+            const blockedCount = allCompletions.tasks.filter(t => t.marker === 'TASK_BLOCKED').length;
+            const parts: string[] = [];
+            if (completedCount > 0) parts.push(`${completedCount} task(s) completed`);
+            if (prereqCount > 0) parts.push(`${prereqCount} prereq(s) verified`);
+            if (blockedCount > 0) parts.push(`${blockedCount} blocked`);
+            logger.iteration(iterNum, this.config.maxIterations,
+              `Phase done: ${parts.join(', ')} (${duration}s)`);
+          } else {
+            logger.iteration(iterNum, this.config.maxIterations, `completed in ${duration}s`);
+          }
+
+          // Verbose output
+          if (this.config.verbose) {
+            console.log();
+            logger.dim('--- Agent Output ---');
+            console.log(result.stdout);
+            if (result.stderr) {
+              logger.dim('--- Agent Stderr ---');
+              console.log(result.stderr);
+            }
+            logger.dim('--- End Output ---');
+            console.log();
+          } else if (result.exitCode !== 0 && result.stderr.trim()) {
+            logger.error(`  ${result.stderr.trim().split('\n')[0]}`);
+          }
+
+          // Handle LOOP_COMPLETE
+          if (allCompletions.loopComplete) {
+            this.onLoopComplete?.();
+            logger.success('All tasks complete!');
+            return {
+              completed: true,
+              iterations: iterNum,
+              finalMarker: 'LOOP_COMPLETE',
+              exitReason: 'all_complete',
+              tasksCompleted: this.tasksCompleted,
+              prereqsCompleted: this.prereqsCompleted,
+            };
+          }
+        } else {
+          // Task mode (default): existing single-marker logic
+          const completion = checkForCompletion(result.stdout + result.stderr);
+
+          // Determine status
+          let status: IterationLogEntry['status'] = 'running';
+          if (completion.completed) {
+            if (completion.marker === 'TASK_BLOCKED') {
+              status = 'blocked';
+            } else {
+              status = 'completed';
+            }
+          } else if (result.timedOut) {
+            status = 'timeout';
+          } else if (result.exitCode !== 0) {
+            status = 'error';
+          }
+
+          // Log iteration
+          const logEntry = this.createLogEntry(result, status, completion.marker);
+          await this.stateManager.appendIterationLog(logEntry);
+
+          // Display iteration result with task info from completion marker
+          this.displayIterationResult(result, iterNum, completion);
+
+          // Handle completion markers
+          if (completion.completed) {
+            const taskDisplay = this.formatTaskDisplay(completion);
+
+            if (completion.marker === 'TASK_COMPLETE') {
+              this.tasksCompleted++;
+              await this.onTaskComplete?.({
+                marker: completion.marker,
+                taskId: completion.taskId,
+                taskName: completion.taskName,
+              });
+              logger.success(taskDisplay ? `Completed: ${taskDisplay}` : 'Task completed!');
+            } else if (completion.marker === 'PREREQ_COMPLETE' || completion.marker === 'PREREQ_ASSUMED') {
+              this.prereqsCompleted++;
+              await this.onTaskComplete?.({
+                marker: completion.marker,
+                taskId: completion.taskId,
+                taskName: completion.taskName,
+              });
+              const prereqDisplay = completion.taskId && completion.taskName
+                ? `Prereq ${completion.taskId}: ${completion.taskName}`
+                : completion.taskId ? `Prereq ${completion.taskId}` : 'Prerequisite';
+              const verb = completion.marker === 'PREREQ_COMPLETE' ? 'Verified' : 'Assumed';
+              logger.success(`${verb}: ${prereqDisplay}`);
+            } else if (completion.marker === 'TASK_BLOCKED') {
+              const blockInfo = completion.taskId
+                ? `Task ${completion.taskId} blocked: ${completion.reason || 'Unknown reason'}`
+                : `Task blocked: ${completion.reason || 'Unknown reason'}`;
+              logger.warning(blockInfo);
+            } else if (completion.marker === 'LOOP_COMPLETE') {
+              // Commit any final changes before completing
+              this.tasksCompleted++;
+              await this.onTaskComplete?.({
+                marker: completion.marker,
+                taskId: completion.taskId,
+                taskName: completion.taskName || 'Final implementation complete',
+              });
+              this.onLoopComplete?.();
+              logger.success('All tasks complete!');
+              return {
+                completed: true,
+                iterations: iterNum,
+                finalMarker: 'LOOP_COMPLETE',
+                exitReason: 'all_complete',
+                tasksCompleted: this.tasksCompleted,
+                prereqsCompleted: this.prereqsCompleted,
+              };
+            }
+          }
+        }
+
+        // Increment iteration and update spec hash (so resume doesn't see false changes)
+        await this.stateManager.incrementIteration();
+        await this.stateManager.updateSpecHash(this.config.specPath);
+        this.config.currentIteration++;
+
+        // Handle timeout
+        if (result.timedOut) {
+          logger.warning(`Iteration ${iterNum} timed out, continuing...`);
+        }
+
+        // Handle error (but continue - LLM might recover)
+        if (result.exitCode !== 0 && !result.timedOut) {
+          // In phase mode, check if any tasks completed despite error exit code
+          const hasCompletions = isPhaseMode
+            ? checkForAllCompletions(result.stdout + result.stderr).tasks.length > 0
+            : checkForCompletion(result.stdout + result.stderr).completed;
+          if (!hasCompletions) {
+            logger.warning(`Iteration ${iterNum} exited with code ${result.exitCode}, continuing...`);
+          }
+        }
+
+      } catch (error) {
+        clearInterval(elapsedInterval);
+        spinner.stop();
+        logger.error(`Iteration ${iterNum} failed: ${error}`);
+
+        // Log the error
+        const entry: IterationLogEntry = {
+          iteration: iterNum,
+          timestamp: new Date().toISOString(),
+          duration: 0,
+          exitCode: -1,
+          status: 'error',
+        };
+        await this.stateManager.appendIterationLog(entry);
+
+        return {
+          completed: false,
+          iterations: this.config.currentIteration,
+          exitReason: 'error',
+          tasksCompleted: this.tasksCompleted,
+          prereqsCompleted: this.prereqsCompleted,
+          error: error instanceof Error ? error : new Error(String(error)),
+        };
+      }
+    }
+
+    // Max iterations reached
+    logger.warning('Max iterations reached');
+    return {
+      completed: false,
+      iterations: this.config.currentIteration,
+      exitReason: 'max_iterations',
+      tasksCompleted: this.tasksCompleted,
+      prereqsCompleted: this.prereqsCompleted,
+    };
+  }
+
+  interrupt(): void {
+    this.interrupted = true;
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+  }
+}

plan2code-loop/src/index.ts

@@ -0,0 +1,97 @@
+import path from 'path';
+import { StateManager } from './state/index.js';
+import { Controller, type LoopResult, type TaskCompleteInfo } from './controller.js';
+import { setupSession } from './cli.js';
+import { logger, createTaskCommit } from './utils/index.js';
+
+export async function run(): Promise<LoopResult | null> {
+  // Ensure agents are registered
+  await import('./agents/index.js');
+
+  const stateManager = new StateManager();
+
+  const result = await setupSession(stateManager);
+  if (!result) {
+    return null;
+  }
+
+  const { config, isResume } = result;
+
+  if (isResume) {
+    logger.info(`Resuming from iteration ${config.currentIteration}`);
+  }
+
+  const controller = new Controller({
+    config,
+    stateManager,
+    onIteration: (iter, max) => {
+      // Could add git checkpoint logic here if needed
+    },
+    onTaskComplete: async (info: TaskCompleteInfo) => {
+      // Create git commit for completed task
+      const taskName = info.taskName || info.taskId || 'Task completed';
+      await createTaskCommit({
+        taskName,
+        jiraTicketId: config.jiraTicketId,
+        cwd: process.cwd(),
+      });
+    },
+    onLoopComplete: () => {
+      // All tasks completed callback
+    },
+  });
+
+  // Setup interrupt handler
+  const handleInterrupt = () => {
+    logger.warning('\nInterrupt received, saving state...');
+    controller.interrupt();
+  };
+
+  process.on('SIGINT', handleInterrupt);
+  process.on('SIGTERM', handleInterrupt);
+
+  try {
+    const loopResult = await controller.run();
+
+    // Display summary
+    console.log();
+    logger.header('Session Summary');
+    logger.info(`Total iterations: ${loopResult.iterations}`);
+    logger.info(`Tasks completed: ${loopResult.tasksCompleted}`);
+    if (loopResult.prereqsCompleted > 0) {
+      logger.info(`Prerequisites verified: ${loopResult.prereqsCompleted}`);
+    }
+    logger.info(`Exit reason: ${loopResult.exitReason}`);
+    if (loopResult.finalMarker) {
+      logger.info(`Completion marker: ${loopResult.finalMarker}`);
+    }
+    if (loopResult.error) {
+      logger.error(`Error: ${loopResult.error.message}`);
+    }
+
+    // Show completion celebration and finalize reminder when all phases complete
+    if (loopResult.exitReason === 'all_complete') {
+      logger.allPhasesComplete();
+    }
+
+    // Show state file locations (now per-spec)
+    console.log();
+    logger.dim(`Session files saved to ${path.relative(process.cwd(), stateManager.getStateDir())}:`);
+    logger.dim('  - config.json (session configuration)');
+    logger.dim('  - scratchpad.md (LLM-managed notes)');
+    logger.dim('  - iteration.log (history)');
+    logger.dim('Tip: run `plan2code-metrics` to capture run data for prompt improvement.');
+
+    return loopResult;
+  } finally {
+    process.off('SIGINT', handleInterrupt);
+    process.off('SIGTERM', handleInterrupt);
+  }
+}
+
+// Re-export types and classes
+export { Controller, type ControllerOptions, type LoopResult, type TaskCompleteInfo } from './controller.js';
+export { StateManager } from './state/index.js';
+export { setupSession } from './cli.js';
+export { agentRegistry, type Agent, type AgentConfig } from './agents/index.js';
+export { detectSpecDirectories, getSpecProgress } from './spec/index.js';

plan2code-loop/src/prompt/builder.ts

@@ -0,0 +1,39 @@
+import type { StateManager, LoopMode } from '../state/index.js';
+import { LOOP_PROMPT_TEMPLATE, LOOP_PROMPT_TEMPLATE_PHASE } from './templates.js';
+
+export interface PromptContext {
+  specPath: string;
+  iteration: number;
+  maxIterations: number;
+  stateManager: StateManager;
+  loopMode: LoopMode;
+  jiraTicketId?: string;
+}
+
+/**
+ * Build the prompt for the AI agent
+ * Selects template based on loop mode (task vs phase)
+ */
+export async function buildLoopPrompt(context: PromptContext): Promise<string> {
+  const { specPath, iteration, maxIterations, stateManager, loopMode, jiraTicketId } = context;
+
+  // Read scratchpad content for session continuity (LLM writes to this)
+  const scratchpadContent = await stateManager.readScratchpad();
+
+  // Project root is where plan2code-loop was invoked from
+  const projectRoot = process.cwd();
+
+  // Select template based on loop mode
+  const template = loopMode === 'phase' ? LOOP_PROMPT_TEMPLATE_PHASE : LOOP_PROMPT_TEMPLATE;
+
+  // Template substitution
+  const prompt = template
+    .replace(/{{projectRoot}}/g, projectRoot)
+    .replace(/{{specPath}}/g, specPath)
+    .replace(/{{iteration}}/g, iteration.toString())
+    .replace(/{{maxIterations}}/g, maxIterations.toString())
+    .replace(/{{scratchpadContent}}/g, scratchpadContent || '(First iteration - no previous progress)')
+    .replace(/{{jiraTicketId}}/g, jiraTicketId || '');
+
+  return prompt;
+}

plan2code-loop/src/prompt/index.ts

@@ -0,0 +1,6 @@
+export {
+  buildLoopPrompt,
+  type PromptContext,
+} from './builder.js';
+
+export { LOOP_PROMPT_TEMPLATE, LOOP_PROMPT_TEMPLATE_PHASE } from './templates.js';

plan2code-loop/src/prompt/templates.ts

@@ -0,0 +1,186 @@
+export const LOOP_PROMPT_TEMPLATE = `# PLAN2CODE-LOOP: Autonomous Task Implementation
+
+## CRITICAL CONSTRAINT
+**IMPLEMENT EXACTLY ONE TASK PER ITERATION.**
+Do NOT implement multiple tasks. Do NOT complete an entire phase.
+Find the FIRST unchecked task, implement ONLY that task, then STOP and report.
+
+## Project Information
+- **Project Root:** \`{{projectRoot}}\`
+- **Spec Location:** \`{{specPath}}\`
+- Read \`AGENTS.md\` for project-specific guidance if available
+
+## IMPORTANT: File Locations
+- Write ALL code files relative to the **project root** (\`{{projectRoot}}\`)
+- The spec directory (\`{{specPath}}\`) is for documentation ONLY - never write code there
+- Example: Create \`{{projectRoot}}/src/index.ts\`, NOT \`{{specPath}}/src/index.ts\`
+
+## Iteration
+{{iteration}} of {{maxIterations}}
+
+## Task Discovery Process
+1. Read \`{{specPath}}/overview.md\` to see all phases
+2. Find the FIRST phase with an unchecked checkbox (\`- [ ]\` or \`- [/]\`)
+3. Read that phase's file (e.g., \`phase-1.md\`)
+4. Check the \`## Prerequisites\` section FIRST
+5. Find the FIRST unchecked prerequisite (\`- [ ]\`)
+   - If found, that is your task for this iteration
+   - Verify/complete it, then mark \`[x]\` or \`[?]\`
+6. Only if ALL prerequisites are complete (\`[x]\` or \`[?]\`), find the FIRST unchecked task
+7. That is your ONE task - implement ONLY that task
+
+## Checkbox States
+- \`[ ]\` = incomplete/pending (do the FIRST one you find)
+- \`[x]\` = complete (skip)
+- \`[?]\` = assumed complete, couldn't verify (skip)
+- \`[!]\` = blocked (skip)
+
+## Implementation Steps
+1. Read and understand the single task
+2. Implement it completely
+3. Validate it works (run tests if applicable and double-check code)
+4. Mark ONLY that task's checkbox as \`[x]\` in the phase file
+5. If that was the LAST task in the phase, also mark the phase \`[x]\` in overview.md
+6. Output your completion marker and STOP
+
+## Git Policy
+**DO NOT create git commits.** The orchestration system handles commits automatically after each task completion. Just implement the code and leave changes uncommitted.
+
+## Completion Markers (REQUIRED FORMAT)
+Output exactly ONE of these at the end, including the task ID and description:
+
+**PREREQ_COMPLETE: [prereq_id] - [description]**
+Example: \`PREREQ_COMPLETE: P1.1 - Verified Phase 1 complete\`
+
+**PREREQ_ASSUMED: [prereq_id] - [description]**
+Example: \`PREREQ_ASSUMED: P2.1 - Design approval (cannot verify)\`
+
+**TASK_COMPLETE: [task_id] - [task_description]**
+Example: \`TASK_COMPLETE: 1.1 - Initialize project structure\`
+
+**TASK_BLOCKED: [task_id] - [reason]**
+Example: \`TASK_BLOCKED: 2.3 - Missing API credentials\`
+
+**LOOP_COMPLETE**
+Use only when ALL phases in overview.md are marked complete.
+
+## Scratchpad Management
+
+After completing each task, append to \`{{specPath}}/.plan2code-loop/scratchpad.md\`:
+- Task completed and Phase item reference
+- Key decisions made and reasoning
+- Files changed
+- Any blockers or notes for next iteration
+
+Keep entries concise. Sacrifice grammar for concision. This file helps future iterations skip exploration.
+
+If key patterns or learnings were discovered, update \`./AGENTS.md\` if it exists.
+
+## Previous Session Context
+{{scratchpadContent}}
+
+---
+
+Remember: ONE TASK ONLY. Find it, implement it, mark it done, output TASK_COMPLETE with the task ID and description, then stop.
+`;
+
+export const LOOP_PROMPT_TEMPLATE_PHASE = `# PLAN2CODE-LOOP: Autonomous Phase Implementation
+
+## CRITICAL CONSTRAINT
+**IMPLEMENT ALL REMAINING TASKS IN THE CURRENT PHASE.**
+Find the first incomplete phase, then implement every remaining task in that phase before stopping.
+Complete each task fully before moving to the next task within the phase.
+## Project Information
+- **Project Root:** \`{{projectRoot}}\`
+- **Spec Location:** \`{{specPath}}\`
+- Read \`AGENTS.md\` for project-specific guidance if available
+
+## IMPORTANT: File Locations
+- Write ALL code files relative to the **project root** (\`{{projectRoot}}\`)
+- The spec directory (\`{{specPath}}\`) is for documentation ONLY - never write code there
+- Example: Create \`{{projectRoot}}/src/index.ts\`, NOT \`{{specPath}}/src/index.ts\`
+
+## Iteration
+{{iteration}} of {{maxIterations}}
+
+## Phase Discovery Process
+1. Read \`{{specPath}}/overview.md\` to see all phases
+2. Find the FIRST phase with an unchecked checkbox (\`- [ ]\` or \`- [/]\`)
+3. Read that phase's file (e.g., \`phase-1.md\`)
+4. Check the \`## Prerequisites\` section FIRST
+5. Complete ALL unchecked prerequisites (\`- [ ]\`) first, in order
+   - Verify/complete each, then mark \`[x]\` or \`[?]\`
+6. Once ALL prerequisites are complete, implement ALL unchecked tasks in order
+7. Continue until every task in the phase is marked \`[x]\`
+
+## Checkbox States
+- \`[ ]\` = incomplete/pending
+- \`[x]\` = complete (skip)
+- \`[?]\` = assumed complete, couldn't verify (skip)
+- \`[!]\` = blocked (skip, note in scratchpad)
+
+## Implementation Steps (repeat for EACH task in the phase)
+1. Read and understand the task
+2. Implement it completely
+3. Validate it works (run tests if applicable and double-check code)
+4. Mark that task's checkbox as \`[x]\` in the phase file
+5. **Create a git commit** for this task (see Git Policy below)
+6. Output a TASK_COMPLETE marker for this task
+7. Move to the next unchecked task in the same phase
+8. When ALL tasks in the phase are done, mark the phase \`[x]\` in overview.md
+
+## Git Policy
+**YOU are responsible for creating git commits after each task.** The orchestration system does NOT handle commits in phase mode.
+
+After completing each task:
+\`\`\`bash
+git add -A
+git commit -m "<commit message>"
+\`\`\`
+
+**Commit message format:**
+- With JIRA ticket: Use \`-m "Task X.Y: description" -m "{{jiraTicketId}}" -m "AI Assisted"\` (three \`-m\` flags)
+- Without JIRA ticket: \`-m "Task X.Y: description" -m "AI Assisted"\` (two \`-m\` flags)
+- ALWAYS include the "AI Assisted" footer as the final \`-m\` flag
+
+Replace X.Y with the actual task ID and description with a concise summary of what was implemented.
+
+## Completion Markers (REQUIRED FORMAT)
+Output one of these **after each task** you complete:
+
+**PREREQ_COMPLETE: [prereq_id] - [description]**
+Example: \`PREREQ_COMPLETE: P1.1 - Verified Phase 1 complete\`
+
+**PREREQ_ASSUMED: [prereq_id] - [description]**
+Example: \`PREREQ_ASSUMED: P2.1 - Design approval (cannot verify)\`
+
+**TASK_COMPLETE: [task_id] - [task_description]**
+Example: \`TASK_COMPLETE: 1.1 - Initialize project structure\`
+
+**TASK_BLOCKED: [task_id] - [reason]**
+Example: \`TASK_BLOCKED: 2.3 - Missing API credentials\`
+If a task is blocked, skip it and continue to the next task.
+
+After ALL tasks in the phase are complete (or blocked), output:
+**PHASE_COMPLETE** - if only this phase is done
+**LOOP_COMPLETE** - if ALL phases in overview.md are now marked complete
+
+## Scratchpad Management
+
+After completing each task, append to \`{{specPath}}/.plan2code-loop/scratchpad.md\`:
+- Task completed and Phase item reference
+- Key decisions made and reasoning
+- Files changed
+- Any blockers or notes for next iteration
+
+Keep entries concise. Sacrifice grammar for concision. This file helps future iterations skip exploration.
+
+If key patterns or learnings were discovered, update \`./AGENTS.md\` if it exists.
+
+## Previous Session Context
+{{scratchpadContent}}
+
+---
+
+Remember: Complete ALL tasks in the current phase. Implement each task, commit it, output TASK_COMPLETE, then continue to the next. Stop only when the phase is done.
+`;

plan2code-loop/src/spec/index.ts

@@ -0,0 +1,4 @@
+export {
+  detectSpecDirectories,
+  getSpecProgress,
+} from './utils.js';

plan2code-loop/src/spec/utils.ts

@@ -0,0 +1,70 @@
+import path from 'path';
+import fs from 'fs-extra';
+
+/**
+ * Auto-detect spec directories in the project
+ * Looks for directories containing overview.md
+ */
+export async function detectSpecDirectories(cwd: string = process.cwd()): Promise<string[]> {
+  const specsDir = path.join(cwd, 'specs');
+  const specsDirs: string[] = [];
+
+  if (await fs.pathExists(specsDir)) {
+    // Look for overview.md files in subdirectories
+    const entries = await fs.readdir(specsDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const overviewPath = path.join(specsDir, entry.name, 'overview.md');
+        if (await fs.pathExists(overviewPath)) {
+          specsDirs.push(path.join(specsDir, entry.name));
+        }
+      }
+    }
+
+    // Also check if specs/ itself contains overview.md
+    const rootOverview = path.join(specsDir, 'overview.md');
+    if (await fs.pathExists(rootOverview)) {
+      specsDirs.push(specsDir);
+    }
+  }
+
+  return specsDirs;
+}
+
+/**
+ * Simple progress stats by counting phase-*.md files
+ * Used for CLI display only - LLM handles actual task discovery
+ */
+export async function getSpecProgress(specPath: string): Promise<{
+  featureName: string;
+  totalPhases: number;
+}> {
+  const overviewPath = path.join(specPath, 'overview.md');
+
+  // Extract feature name from overview.md
+  let featureName = path.basename(specPath);
+  try {
+    const overviewContent = await fs.readFile(overviewPath, 'utf8');
+    const h1Match = overviewContent.match(/^#\s+(.+)$/m);
+    if (h1Match) {
+      featureName = h1Match[1].trim();
+    }
+  } catch {
+    // Use directory name as fallback
+  }
+
+  // Count phase-*.md files
+  let totalPhases = 0;
+  try {
+    const entries = await fs.readdir(specPath);
+    totalPhases = entries.filter(name => /^phase-\d+\.md$/i.test(name)).length;
+  } catch {
+    // Directory read failed
+  }
+
+  return {
+    featureName,
+    totalPhases,
+  };
+}

plan2code-loop/src/state/config.ts

@@ -0,0 +1,33 @@
+export type LoopMode = 'task' | 'phase';
+
+export interface SessionConfig {
+  agent: string;              // "claude-code" | "copilot-cli"
+  model: string;              // Selected model
+  maxIterations: number;      // 5-50
+  timeout: number;            // Minutes per iteration
+  verbose: boolean;
+  specPath: string;           // Path to the spec directory
+  startedAt: string;          // ISO timestamp
+  currentIteration: number;
+  jiraTicketId?: string;      // JIRA ticket ID for commit messages
+  loopMode: LoopMode;         // "task" = one task per loop, "phase" = one phase per loop
+}
+
+export interface IterationLogEntry {
+  iteration: number;
+  timestamp: string;          // ISO timestamp
+  duration: number;           // milliseconds
+  exitCode: number;
+  status: 'running' | 'completed' | 'error' | 'timeout' | 'interrupted' | 'blocked';
+  completionMarker?: string;
+}
+
+export type SessionState = 'new' | 'continue' | 'changed';
+
+export const DEFAULT_CONFIG: Partial<SessionConfig> = {
+  maxIterations: 100,
+  timeout: 30,
+  verbose: false,
+  currentIteration: 0,
+  loopMode: 'task',
+};

plan2code-loop/src/state/hash.ts

@@ -0,0 +1,9 @@
+import { createHash } from 'crypto';
+
+export function computeHash(content: string): string {
+  return createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+
+export function hashesMatch(a: string, b: string): boolean {
+  return a === b;
+}

plan2code-loop/src/state/index.ts

@@ -0,0 +1,10 @@
+export {
+  type SessionConfig,
+  type IterationLogEntry,
+  type SessionState,
+  type LoopMode,
+  DEFAULT_CONFIG,
+} from './config.js';
+
+export { StateManager } from './manager.js';
+export { computeHash, hashesMatch } from './hash.js';

plan2code-loop/src/state/manager.ts

@@ -0,0 +1,231 @@
+import path from 'path';
+import fs from 'fs-extra';
+import type { SessionConfig, IterationLogEntry, SessionState } from './config.js';
+import { DEFAULT_CONFIG } from './config.js';
+import { computeHash, hashesMatch } from './hash.js';
+
+const SCRATCHPAD_TEMPLATE = `# Scratchpad
+
+Session notes appended by LLM during implementation.
+
+---
+
+`;
+
+export class StateManager {
+  private readonly stateDir: string;
+  private readonly configPath: string;
+  private readonly scratchpadPath: string;
+  private readonly logPath: string;
+  private readonly hashPath: string;
+  private specPath: string | null = null;
+
+  constructor(cwd: string = process.cwd()) {
+    // Default to project root - will be updated when spec is selected
+    this.stateDir = path.join(cwd, '.plan2code-loop');
+    this.configPath = path.join(this.stateDir, 'config.json');
+    this.scratchpadPath = path.join(this.stateDir, 'scratchpad.md');
+    this.logPath = path.join(this.stateDir, 'iteration.log');
+    this.hashPath = path.join(this.stateDir, 'spec.hash');
+  }
+
+  /**
+   * Set the spec path and update all state paths to be inside the spec directory
+   */
+  setSpecPath(specPath: string): void {
+    this.specPath = specPath;
+    const stateDir = path.join(specPath, '.plan2code-loop');
+    // Update all paths to be relative to spec directory
+    (this as any).stateDir = stateDir;
+    (this as any).configPath = path.join(stateDir, 'config.json');
+    (this as any).scratchpadPath = path.join(stateDir, 'scratchpad.md');
+    (this as any).logPath = path.join(stateDir, 'iteration.log');
+    (this as any).hashPath = path.join(stateDir, 'spec.hash');
+  }
+
+  // Directory operations
+
+  async ensureStateDir(): Promise<boolean> {
+    const existed = await fs.pathExists(this.stateDir);
+    await fs.ensureDir(this.stateDir);
+    return existed;
+  }
+
+  getStateDir(): string {
+    return this.stateDir;
+  }
+
+  // Config operations
+
+  async readConfig(): Promise<SessionConfig | null> {
+    try {
+      const content = await fs.readFile(this.configPath, 'utf8');
+      return JSON.parse(content) as SessionConfig;
+    } catch {
+      return null;
+    }
+  }
+
+  async writeConfig(config: SessionConfig): Promise<void> {
+    await fs.writeFile(
+      this.configPath,
+      JSON.stringify(config, null, 2),
+      'utf8'
+    );
+  }
+
+  async updateConfig(updates: Partial<SessionConfig>): Promise<SessionConfig> {
+    const existing = await this.readConfig();
+    const updated = { ...DEFAULT_CONFIG, ...existing, ...updates } as SessionConfig;
+    await this.writeConfig(updated);
+    return updated;
+  }
+
+  async incrementIteration(): Promise<number> {
+    const config = await this.readConfig();
+    if (!config) throw new Error('No session config found');
+    config.currentIteration++;
+    await this.writeConfig(config);
+    return config.currentIteration;
+  }
+
+  // Session state detection
+
+  async hasExistingSession(): Promise<boolean> {
+    const [configExists, scratchpadExists] = await Promise.all([
+      fs.pathExists(this.configPath),
+      fs.pathExists(this.scratchpadPath),
+    ]);
+    return configExists || scratchpadExists;
+  }
+
+  async detectSessionState(specPath: string): Promise<SessionState> {
+    // Ensure we're using the correct spec path
+    this.setSpecPath(specPath);
+
+    const hasSession = await this.hasExistingSession();
+    if (!hasSession) {
+      return 'new';
+    }
+
+    // Check if the spec path has changed
+    const existingConfig = await this.readConfig();
+    if (existingConfig && existingConfig.specPath !== specPath) {
+      return 'changed';
+    }
+
+    // Check if spec content has changed (using hash of overview.md)
+    const specChanged = await this.hasSpecChanged(specPath);
+    return specChanged ? 'changed' : 'continue';
+  }
+
+  // Hash management for spec change detection
+
+  async computeSpecHash(specPath: string): Promise<string> {
+    const overviewPath = path.join(specPath, 'overview.md');
+    try {
+      const content = await fs.readFile(overviewPath, 'utf8');
+      return computeHash(content);
+    } catch {
+      return '';
+    }
+  }
+
+  async readStoredHash(): Promise<string | null> {
+    try {
+      return await fs.readFile(this.hashPath, 'utf8');
+    } catch {
+      return null;
+    }
+  }
+
+  async storeHash(hash: string): Promise<void> {
+    await fs.writeFile(this.hashPath, hash, 'utf8');
+  }
+
+  async hasSpecChanged(specPath: string): Promise<boolean> {
+    const stored = await this.readStoredHash();
+    if (!stored) return true;
+    const current = await this.computeSpecHash(specPath);
+    return !hashesMatch(stored, current);
+  }
+
+  async updateSpecHash(specPath: string): Promise<void> {
+    const hash = await this.computeSpecHash(specPath);
+    await this.storeHash(hash);
+  }
+
+  // Scratchpad operations
+
+  async initializeScratchpad(): Promise<void> {
+    await fs.writeFile(this.scratchpadPath, SCRATCHPAD_TEMPLATE, 'utf8');
+  }
+
+  async readScratchpad(): Promise<string> {
+    try {
+      return await fs.readFile(this.scratchpadPath, 'utf8');
+    } catch {
+      return '';
+    }
+  }
+
+  async writeScratchpad(content: string): Promise<void> {
+    await fs.writeFile(this.scratchpadPath, content, 'utf8');
+  }
+
+  // Iteration log operations
+
+  async appendIterationLog(entry: IterationLogEntry): Promise<void> {
+    const line = JSON.stringify(entry) + '\n';
+    await fs.appendFile(this.logPath, line, 'utf8');
+  }
+
+  async readIterationLog(): Promise<IterationLogEntry[]> {
+    try {
+      const content = await fs.readFile(this.logPath, 'utf8');
+      return content
+        .trim()
+        .split('\n')
+        .filter(Boolean)
+        .map((line) => JSON.parse(line) as IterationLogEntry);
+    } catch {
+      return [];
+    }
+  }
+
+  async getLastIteration(): Promise<IterationLogEntry | null> {
+    const log = await this.readIterationLog();
+    return log.length > 0 ? log[log.length - 1] : null;
+  }
+
+  // State clearing and initialization
+
+  async clearState(): Promise<void> {
+    const filesToDelete = [
+      this.scratchpadPath,
+      this.configPath,
+      this.logPath,
+      this.hashPath,
+    ];
+
+    await Promise.all(
+      filesToDelete.map((file) => fs.remove(file).catch(() => {}))
+    );
+  }
+
+  async initializeNewSession(config: SessionConfig): Promise<void> {
+    // Ensure spec path is set before initializing
+    this.setSpecPath(config.specPath);
+
+    await this.clearState();
+    await this.ensureStateDir();
+    await this.initializeScratchpad();
+    await this.writeConfig({
+      ...config,
+      startedAt: new Date().toISOString(),
+      currentIteration: 0,
+    });
+    const hash = await this.computeSpecHash(config.specPath);
+    await this.storeHash(hash);
+  }
+}

plan2code-loop/src/utils/completion.ts

@@ -0,0 +1,169 @@
+// Completion markers for plan2code-loop
+const COMPLETION_MARKERS = ['TASK_COMPLETE', 'TASK_BLOCKED', 'LOOP_COMPLETE', 'PREREQ_COMPLETE', 'PREREQ_ASSUMED'] as const;
+
+export type CompletionMarker = (typeof COMPLETION_MARKERS)[number];
+
+export interface CompletionCheckResult {
+  completed: boolean;
+  marker?: CompletionMarker;
+  taskId?: string;      // e.g., "1.1", "2.3"
+  taskName?: string;    // e.g., "Initialize project structure"
+  reason?: string;      // For TASK_BLOCKED: reason
+}
+
+export function checkForCompletion(output: string): CompletionCheckResult {
+  // Check for LOOP_COMPLETE first (highest priority)
+  if (output.includes('LOOP_COMPLETE')) {
+    return { completed: true, marker: 'LOOP_COMPLETE' };
+  }
+
+  // Check for TASK_COMPLETE with task info
+  // Format: TASK_COMPLETE: 1.1 - Task description
+  // Or: TASK_COMPLETE: 1.1: Task description
+  // Or: TASK_COMPLETE[1.1]: Task description
+  const completeMatch = output.match(/TASK_COMPLETE[:\[\s]+(\d+\.\d+)[\]:\-\s]+(.+?)(?:\n|$)/i);
+  if (completeMatch) {
+    return {
+      completed: true,
+      marker: 'TASK_COMPLETE',
+      taskId: completeMatch[1],
+      taskName: completeMatch[2].trim(),
+    };
+  }
+
+  // Simple TASK_COMPLETE without structured info - try to extract task from context
+  if (output.includes('TASK_COMPLETE')) {
+    // Try to find task info nearby
+    const taskMatch = output.match(/(?:task|completed?)\s+(\d+\.\d+)[:\s]+([^\n]{5,80})/i);
+    return {
+      completed: true,
+      marker: 'TASK_COMPLETE',
+      taskId: taskMatch?.[1],
+      taskName: taskMatch?.[2]?.trim(),
+    };
+  }
+
+  // Check for PREREQ_COMPLETE with prereq info
+  // Format: PREREQ_COMPLETE: P1.1 - Verified Phase 1 complete
+  const prereqMatch = output.match(/PREREQ_COMPLETE[:\[\s]+([^\]:\-\s]+)[\]:\-\s]+(.+?)(?:\n|$)/i);
+  if (prereqMatch) {
+    return {
+      completed: true,
+      marker: 'PREREQ_COMPLETE',
+      taskId: prereqMatch[1],
+      taskName: prereqMatch[2].trim(),
+    };
+  }
+
+  // Check for PREREQ_ASSUMED with prereq info
+  // Format: PREREQ_ASSUMED: P2.1 - Design approval (cannot verify)
+  const assumedMatch = output.match(/PREREQ_ASSUMED[:\[\s]+([^\]:\-\s]+)[\]:\-\s]+(.+?)(?:\n|$)/i);
+  if (assumedMatch) {
+    return {
+      completed: true,
+      marker: 'PREREQ_ASSUMED',
+      taskId: assumedMatch[1],
+      taskName: assumedMatch[2].trim(),
+    };
+  }
+
+  // Check for TASK_BLOCKED with task info and reason
+  // Format: TASK_BLOCKED: 1.1 - Reason why blocked
+  const blockedWithTaskMatch = output.match(/TASK_BLOCKED[:\[\s]+(\d+\.\d+)[\]:\-\s]+(.+?)(?:\n|$)/i);
+  if (blockedWithTaskMatch) {
+    return {
+      completed: true,
+      marker: 'TASK_BLOCKED',
+      taskId: blockedWithTaskMatch[1],
+      reason: blockedWithTaskMatch[2].trim(),
+    };
+  }
+
+  // TASK_BLOCKED with just reason (no task ID)
+  const blockedMatch = output.match(/TASK_BLOCKED:\s*(.+?)(?:\n|$)/);
+  if (blockedMatch) {
+    return {
+      completed: true,
+      marker: 'TASK_BLOCKED',
+      reason: blockedMatch[1].trim()
+    };
+  }
+
+  // Simple TASK_BLOCKED without any info
+  if (output.includes('TASK_BLOCKED')) {
+    return { completed: true, marker: 'TASK_BLOCKED', reason: 'No reason provided' };
+  }
+
+  return { completed: false };
+}
+
+/**
+ * Extract ALL completion markers from output (for phase mode).
+ * Returns an array of all TASK_COMPLETE/TASK_BLOCKED markers found,
+ * plus whether LOOP_COMPLETE or PHASE_COMPLETE was present.
+ */
+export function checkForAllCompletions(output: string): {
+  tasks: CompletionCheckResult[];
+  loopComplete: boolean;
+  phaseComplete: boolean;
+} {
+  const tasks: CompletionCheckResult[] = [];
+  let loopComplete = false;
+  let phaseComplete = false;
+
+  if (output.includes('LOOP_COMPLETE')) {
+    loopComplete = true;
+  }
+
+  if (output.includes('PHASE_COMPLETE')) {
+    phaseComplete = true;
+  }
+
+  // Find all TASK_COMPLETE markers with task info
+  // Format: TASK_COMPLETE: 1.1 - Task description
+  const completeRegex = /TASK_COMPLETE[:\[\s]+(\d+\.\d+)[\]:\-\s]+(.+?)(?:\n|$)/gi;
+  let match: RegExpExecArray | null;
+  while ((match = completeRegex.exec(output)) !== null) {
+    tasks.push({
+      completed: true,
+      marker: 'TASK_COMPLETE',
+      taskId: match[1],
+      taskName: match[2].trim(),
+    });
+  }
+
+  // Find all TASK_BLOCKED markers with task info
+  const blockedRegex = /TASK_BLOCKED[:\[\s]+(\d+\.\d+)[\]:\-\s]+(.+?)(?:\n|$)/gi;
+  while ((match = blockedRegex.exec(output)) !== null) {
+    tasks.push({
+      completed: true,
+      marker: 'TASK_BLOCKED',
+      taskId: match[1],
+      reason: match[2].trim(),
+    });
+  }
+
+  // Find PREREQ_COMPLETE markers
+  const prereqRegex = /PREREQ_COMPLETE[:\[\s]+([^\]:\-\s]+)[\]:\-\s]+(.+?)(?:\n|$)/gi;
+  while ((match = prereqRegex.exec(output)) !== null) {
+    tasks.push({
+      completed: true,
+      marker: 'PREREQ_COMPLETE',
+      taskId: match[1],
+      taskName: match[2].trim(),
+    });
+  }
+
+  // Find PREREQ_ASSUMED markers
+  const assumedRegex = /PREREQ_ASSUMED[:\[\s]+([^\]:\-\s]+)[\]:\-\s]+(.+?)(?:\n|$)/gi;
+  while ((match = assumedRegex.exec(output)) !== null) {
+    tasks.push({
+      completed: true,
+      marker: 'PREREQ_ASSUMED',
+      taskId: match[1],
+      taskName: match[2].trim(),
+    });
+  }
+
+  return { tasks, loopComplete, phaseComplete };
+}

plan2code-loop/src/utils/git.ts

@@ -0,0 +1,136 @@
+import { execa } from 'execa';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { logger } from './logger.js';
+
+export interface GitCommitOptions {
+  taskName: string;
+  jiraTicketId?: string;
+  cwd?: string;
+}
+
+/**
+ * Check if directory is a git repository
+ */
+export async function isGitRepo(cwd: string): Promise<boolean> {
+  const result = await execa('git', ['rev-parse', '--git-dir'], { cwd, reject: false });
+  return result.exitCode === 0;
+}
+
+/**
+ * Initialize a git repository if one doesn't exist
+ */
+export async function ensureGitRepo(cwd: string): Promise<boolean> {
+  if (await isGitRepo(cwd)) {
+    return true;
+  }
+
+  logger.info('Initializing git repository...');
+  const result = await execa('git', ['init'], { cwd, reject: false });
+
+  if (result.exitCode !== 0) {
+    logger.error(`Failed to initialize git repo: ${result.stderr}`);
+    return false;
+  }
+
+  logger.success('Git repository initialized');
+  return true;
+}
+
+/**
+ * Required entries for the .gitignore file
+ */
+const REQUIRED_GITIGNORE_ENTRIES = ['specs/', 'specs--completed/', '.plan2code-loop', '.plan2code-metrics', 'nul', 'node_modules/'];
+
+/**
+ * Ensure .gitignore exists with required entries
+ */
+export function ensureGitignore(cwd: string): void {
+  const gitignorePath = join(cwd, '.gitignore');
+  let content = '';
+
+  if (existsSync(gitignorePath)) {
+    content = readFileSync(gitignorePath, 'utf-8');
+  }
+
+  const lines = content.split('\n').map(line => line.trim());
+  const missingEntries = REQUIRED_GITIGNORE_ENTRIES.filter(entry => !lines.includes(entry));
+
+  if (missingEntries.length > 0) {
+    const needsNewline = content.length > 0 && !content.endsWith('\n');
+    const newContent = content + (needsNewline ? '\n' : '') + missingEntries.join('\n') + '\n';
+    writeFileSync(gitignorePath, newContent);
+    logger.dim(`Added to .gitignore: ${missingEntries.join(', ')}`);
+  }
+}
+
+/**
+ * Create a local git commit for a completed task
+ */
+export async function createTaskCommit(options: GitCommitOptions): Promise<boolean> {
+  const { taskName, jiraTicketId, cwd = process.cwd() } = options;
+
+  logger.dim(`Git commit check in: ${cwd}`);
+
+  try {
+    // Ensure we have a git repo
+    if (!await ensureGitRepo(cwd)) {
+      return false;
+    }
+
+    // Ensure .gitignore exists with required entries
+    ensureGitignore(cwd);
+
+    // Check if there are any changes to commit
+    const statusResult = await execa('git', ['status', '--porcelain'], { cwd, reject: false });
+
+    // Debug: show what git status returned
+    if (statusResult.stdout?.trim()) {
+      logger.dim(`Git status found changes:\n${statusResult.stdout.slice(0, 500)}`);
+    }
+
+    if (statusResult.exitCode !== 0) {
+      logger.error(`Git status failed: ${statusResult.stderr}`);
+      return false;
+    }
+
+    if (!statusResult.stdout?.trim()) {
+      logger.dim('No changes to commit');
+      return false;
+    }
+
+    // Stage all changes
+    const addResult = await execa('git', ['add', '-A'], { cwd, reject: false });
+    if (addResult.exitCode !== 0) {
+      logger.error(`Git add failed: ${addResult.stderr}`);
+      return false;
+    }
+
+    // Build commit message
+    let commitMessage = taskName;
+    if (jiraTicketId) {
+      commitMessage = `${taskName}\n\n${jiraTicketId}\n\nAI Assisted`;
+    } else {
+      commitMessage = `${taskName}\n\nAI Assisted`;
+    }
+
+    // Create the commit
+    const commitResult = await execa('git', ['commit', '-m', commitMessage], { cwd, reject: false });
+
+    if (commitResult.exitCode !== 0) {
+      // Check if it's just "nothing to commit" vs actual error
+      if (commitResult.stdout?.includes('nothing to commit') || commitResult.stderr?.includes('nothing to commit')) {
+        logger.dim('No changes to commit');
+        return false;
+      }
+      logger.error(`Git commit failed: ${commitResult.stderr || commitResult.stdout}`);
+      return false;
+    }
+
+    logger.success(`Created commit: ${taskName}${jiraTicketId ? ` (${jiraTicketId})` : ''}`);
+    return true;
+  } catch (error) {
+    logger.error(`Failed to create commit: ${error instanceof Error ? error.message : String(error)}`);
+    return false;
+  }
+}

plan2code-loop/src/utils/index.ts

@@ -0,0 +1,19 @@
+export { logger, MASCOT, type Logger } from './logger.js';
+export {
+  checkForCompletion,
+  checkForAllCompletions,
+  type CompletionMarker,
+  type CompletionCheckResult
+} from './completion.js';
+export {
+  executeCommand,
+  type ExecuteOptions,
+  type ExecuteResult
+} from './process.js';
+export {
+  createTaskCommit,
+  isGitRepo,
+  ensureGitRepo,
+  ensureGitignore,
+  type GitCommitOptions
+} from './git.js';

plan2code-loop/src/utils/logger.ts

@@ -0,0 +1,126 @@
+import chalk from 'chalk';
+import ora, { type Ora } from 'ora';
+
+// mascot - our friendly robot assistant
+export const MASCOT = {
+  // Full mascot for headers
+  full: [
+    '   ╭───╮   ',
+    '   │ ● │   ',
+    '   │ ◡ │   ',
+    '   ╰───╯   ',
+  ],
+  // Mini mascot for inline use
+  mini: '(◉‿◉)',
+  // Waving mascot for greetings
+  wave: [
+    '   ╭───╮   ',
+    '   │ ● │   ',
+    '   │ ◡ │   ',
+    '   ╰───╯   ',
+  ],
+  // Celebration mascot for completion
+  celebrate: [
+    '   ╭───╮   ',
+    '   │ ★ │   ',
+    '   │ ◡ │   ',
+    '   ╰───╯   ',
+  ],
+};
+
+export const logger = {
+  info: (message: string) => console.log(chalk.blue('i'), message),
+  success: (message: string) => console.log(chalk.green('+'), message),
+  warning: (message: string) => console.log(chalk.yellow('!'), message),
+  error: (message: string) => console.log(chalk.red('x'), message),
+
+  dim: (message: string) => console.log(chalk.dim(message)),
+  bold: (message: string) => console.log(chalk.bold(message)),
+
+  header: (message: string) => {
+    console.log();
+    console.log(chalk.cyan.bold(message));
+    console.log(chalk.cyan('-'.repeat(message.length)));
+  },
+
+  task: (phase: number, taskId: string, description: string) => {
+    console.log(
+      chalk.cyan(`[Phase ${phase}]`),
+      chalk.yellow(`Task ${taskId}:`),
+      chalk.white(description)
+    );
+  },
+
+  iteration: (num: number, max: number, status: string) => {
+    console.log(
+      chalk.cyan(`[${num}/${max}]`),
+      chalk.white(status)
+    );
+  },
+
+  specContent: (content: string) => {
+    console.log(chalk.dim('-'.repeat(50)));
+    console.log(chalk.white(content));
+    console.log(chalk.dim('-'.repeat(50)));
+  },
+
+  spinner: (text: string): Ora => ora({ text, color: 'cyan' }).start(),
+
+  // Display mascot with optional message
+  mascot: (variant: keyof typeof MASCOT = 'full', message?: string) => {
+    console.log();
+    const mascot = MASCOT[variant];
+    if (Array.isArray(mascot)) {
+      const mascotLines = [...mascot];
+      if (message) {
+        // Add message next to mascot (at the "mouth" line)
+        mascotLines[4] = mascotLines[4] + '   ' + chalk.cyan(message);
+      }
+      mascotLines.forEach((line) => console.log(chalk.yellow(line)));
+    } else {
+      // Mini variant
+      console.log(chalk.yellow(mascot), message ? chalk.cyan(message) : '');
+    }
+    console.log();
+  },
+
+  // Welcome banner with mascot
+  welcome: () => {
+    console.log();
+    console.log(chalk.cyan.bold('═'.repeat(50)));
+    MASCOT.wave.forEach((line, i) => {
+      if (i === 4) {
+        console.log(chalk.yellow(line) + '   ' + chalk.cyan.bold("Hi!"));
+      } else if (i === 5) {
+        console.log(chalk.yellow(line) + '   ' + chalk.dim('I\'m Your Plan2Code assistant'));
+      } else {
+        console.log(chalk.yellow(line));
+      }
+    });
+    console.log(chalk.cyan.bold('═'.repeat(50)));
+    console.log();
+  },
+
+  // Completion celebration with reminder
+  allPhasesComplete: () => {
+    console.log();
+    console.log(chalk.green.bold('═'.repeat(50)));
+    MASCOT.celebrate.forEach((line, i) => {
+      if (i === 4) {
+        console.log(chalk.yellow(line) + '   ' + chalk.green.bold('All phases complete!'));
+      } else if (i === 5) {
+        console.log(chalk.yellow(line) + '   ' + chalk.cyan('Great work!'));
+      } else {
+        console.log(chalk.yellow(line));
+      }
+    });
+    console.log(chalk.green.bold('═'.repeat(50)));
+    console.log();
+    console.log(chalk.cyan.bold('Next Step:'));
+    console.log(chalk.white('  Return to your AI Agent and run the'), chalk.yellow.bold('/plan2code-4--finalize'), chalk.white('step.'));
+    console.log(chalk.dim('  This will ensure quality, completeness, and proper documentation.'));
+    console.log();
+  },
+};
+
+export type Logger = typeof logger;

plan2code-loop/src/utils/process.ts

@@ -0,0 +1,81 @@
+import { execa, type Options as ExecaOptions } from 'execa';
+
+const MAX_OUTPUT_SIZE = 10 * 1024 * 1024; // 10MB
+
+function truncateOutput(output: string, maxSize: number): string {
+  if (output.length > maxSize) {
+    return output.slice(0, maxSize) + '\n...[truncated]';
+  }
+  return output;
+}
+
+export interface ExecuteOptions {
+  command: string;
+  args: string[];
+  cwd: string;
+  timeout: number;        // milliseconds
+  env?: Record<string, string>;
+  signal?: AbortSignal;   // For cancellation
+  stdin?: string;         // Input to pass via stdin as string
+  stdinFile?: string;     // Path to file to pipe as stdin
+}
+
+export interface ExecuteResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  timedOut: boolean;
+  cancelled: boolean;
+  duration: number;       // milliseconds
+}
+
+export async function executeCommand(
+  options: ExecuteOptions
+): Promise<ExecuteResult> {
+  const startTime = Date.now();
+
+  try {
+    const execaOptions: ExecaOptions = {
+      cwd: options.cwd,
+      timeout: options.timeout,
+      env: { ...process.env, ...options.env },
+      reject: false,
+      all: true,
+    };
+
+    // Add cancellation signal if provided
+    if (options.signal) {
+      (execaOptions as any).cancelSignal = options.signal;
+    }
+
+    // Add stdin input if provided (string or file)
+    if (options.stdin) {
+      (execaOptions as any).input = options.stdin;
+    } else if (options.stdinFile) {
+      (execaOptions as any).inputFile = options.stdinFile;
+    }
+
+    const result = await execa(options.command, options.args, execaOptions);
+
+    return {
+      stdout: truncateOutput(result.stdout || '', MAX_OUTPUT_SIZE),
+      stderr: truncateOutput(result.stderr || '', MAX_OUTPUT_SIZE),
+      exitCode: result.exitCode ?? 1,
+      timedOut: result.timedOut ?? false,
+      cancelled: result.isCanceled ?? false,
+      duration: Date.now() - startTime,
+    };
+  } catch (error: any) {
+    // Check if this was a cancellation
+    const isCancelled = error?.isCanceled || options.signal?.aborted;
+
+    return {
+      stdout: error?.stdout || '',
+      stderr: error?.stderr || (error instanceof Error ? error.message : String(error)),
+      exitCode: isCancelled ? -1 : 1,
+      timedOut: false,
+      cancelled: isCancelled,
+      duration: Date.now() - startTime,
+    };
+  }
+}

plan2code-loop/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

plan2code-loop/tsup.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: {
+    'bin/plan2code-loop': 'src/bin/plan2code-loop.ts',
+    index: 'src/index.ts',
+  },
+  format: ['esm'],
+  dts: true,
+  clean: true,
+  sourcemap: true,
+  banner: {
+    js: '#!/usr/bin/env node',
+  },
+});

plan2code-metrics/README.md

@@ -0,0 +1,289 @@
+# plan2code-metrics
+
+Recursive self-improvement toolchain for plan2code contributors. Collects metrics from completed project specs, aggregates them across runs and prompt generations, then uses AI to diagnose weak steps and propose targeted edits to the workflow prompts.
+
+## Quick Reference
+
+```bash
+# Install (one-time, from the plan2code root)
+node install.js            # → "I" (Install All) includes metrics
+                           # → or "M" (Metrics only) under the CUSTOM sub-menu
+
+# After finishing any project spec (steps 1-4):
+cd your-project
+plan2code-metrics          # → "Collect metrics" → pick your spec dir → done (5 sec)
+
+# When you're curious or have 3+ runs:
+plan2code-metrics          # → "View metrics status" to see the dashboard
+                           # → "Run analysis" for AI diagnosis of weak spots
+                           # → "Generate improvement proposal" for prompt edits
+                           # → "Review and apply" to patch src/plan2code-*.md
+```
+
+**One habit:** collect after every finished spec. Everything else is on-demand.
+
+### How Many Runs Do I Need?
+
+| Runs | What You Get |
+|------|-------------|
+| **1** | Raw data and basic dashboard. Start here. |
+| **3+** | AI analysis unlocks (warns below 3 that results may be unreliable). Pattern detection starts working. |
+| **5-10+** | Averages stabilize. Generation-over-generation comparisons become meaningful. |
+
+More is always better — each run adds a data point. You're looking for trends, not individual scores.
+
+### The Feedback Loop
+
+```
+Use plan2code on a project (steps 1-4)
+     |
+     v
+Collect metrics from the finished spec       <-- do this every time
+     |
+     v
+Aggregate across runs (automatic)
+     |
+     v
+Analyze weak spots (AI-powered, 3+ runs)
+     |
+     v
+Generate prompt improvements
+     |
+     v
+Apply edits to src/plan2code-*.md
+     |
+     v
+Prompts have new SHA hashes = new "generation"
+     |
+     v
+Use improved prompts on next project
+     |
+     v
+Collect again, compare generations            <-- the loop closes
+```
+
+After applying edits, the prompt file SHA hashes change. The next collected run falls into a **new cohort** (generation). The dashboard then shows generation-over-generation deltas — "Did confidence go up? Did blockers decrease?" — so you can measure whether your edits actually helped.
+
+---
+
+## Installation
+
+Requires Node.js >= 18.
+
+### Via the plan2code installer (recommended)
+
+From the plan2code repo root:
+
+```bash
+node install.js
+```
+
+Choose **I** (Install All) to install prompts, loop CLI, and metrics together. Or choose **C** (Custom) then **M** (Metrics) to install just the metrics CLI.
+
+The installer handles `npm install`, `npm run build`, and global linking automatically. After install, `plan2code-metrics` is available from any directory.
+
+### Manual install
+
+If you prefer to install manually or are developing on the metrics package:
+
+```bash
+cd plan2code-metrics
+npm install
+npm run build
+npm link
+```
+
+To run without linking:
+
+```bash
+npm start
+# or
+node dist/bin/plan2code-metrics.js
+```
+
+## Usage
+
+Run `plan2code-metrics` from inside (or near) a plan2code repository. The CLI is fully interactive — no flags, all inputs collected via prompts.
+
+```
+plan2code-metrics
+```
+
+### Main Menu
+
+| Option | Description |
+|--------|-------------|
+| **Collect metrics** | Parse a completed project spec and extract step-by-step metrics into a run JSON |
+| **Import run data** | Copy a run JSON from another project into the local metrics store |
+| **View metrics status** | Show aggregated metrics with health indicators and generation deltas |
+| **Run analysis** | AI-powered diagnosis of weak steps (requires Claude Code or Copilot CLI) |
+| **Generate improvement proposal** | AI generates surgical prompt edits based on a diagnosis |
+| **Review and apply** | Interactive diff review to accept/reject individual edits |
+
+### Each Time You Finish a Spec
+
+After completing Step 4 (finalize) on any project:
+
+```bash
+cd your-project
+plan2code-metrics
+```
+
+Pick **"Collect metrics"** and point it at your spec directory (`specs/<feature>/` or `specs--completed/<feature>/`). It reads your artifacts, extracts ~30 metrics, and writes a run JSON. Takes about 5 seconds.
+
+The data stays local to that project in `.plan2code-metrics/runs/`. To aggregate across multiple projects, use **"Import"** to copy run files into one central location.
+
+### Cross-Project Aggregation
+
+If you use plan2code across several repos, you can consolidate all run data in one place:
+
+```bash
+# From your central repo (e.g., the plan2code repo itself):
+plan2code-metrics
+# → "Import run data"
+# → Paste path to: /path/to/other-project/.plan2code-metrics/runs/run-xxx.json
+```
+
+Imported runs are copied locally and included in all future aggregations, analyses, and comparisons.
+
+## What It Measures
+
+Each collection scrapes your spec files and extracts:
+
+### Step 1 (Plan) — from `PLAN-DRAFT-*.md` and `PLAN-CONVERSATION-*.md`
+
+- **Confidence score** — overall planning confidence percentage
+- **Confidence breakdown** — requirements, feasibility, integration, risk sub-scores
+- **Clarification rounds** — how many rounds of Q&A occurred
+- **Verification gaps found** — missing requirements caught during verification
+- **Functional/non-functional requirement counts** — FR- and NFR- headings
+- **Risk count** — risk table entries
+- **Phase count** — number of implementation phases planned
+
+### Step 2 (Document) — from `overview.md` and `phase-*.md`
+
+- **Total tasks** — checkbox count across all phases
+- **Tasks per phase** — distribution of work
+- **Phase count** — number of phase files
+- **Parallel groups** — parallel execution groups identified
+- **Requirement coverage** — coverage percentage if present
+- **Verification items** — verification checklist items added
+
+### Step 3 (Implement) — from `.plan2code-loop/` data (loop mode only)
+
+- **Task completion rate** — completed / total tasks
+- **Blocker count** — tasks marked TASK_BLOCKED
+- **Blocker categories** — normalized reasons for blocks
+- **Total iterations** — loop iteration count
+- **Avg iteration duration** — mean time per iteration
+- **Exit code distribution** — process exit codes
+- **Completion marker success rate** — valid markers / total iterations
+
+### Step 4 (Finalize) — from `overview.md` and directory structure
+
+- **Completion rate at audit** — tasks done at finalization time
+- **Verification failures** — tasks marked with `[!]`
+- **Documentation updates needed** — TODO/FIXME/update markers
+- **Archival success** — whether spec was moved to `specs--completed/`
+
+### Health Targets
+
+The dashboard compares key metrics against targets:
+
+| Metric | Target | Direction |
+|--------|--------|-----------|
+| avg_confidence | 90 | >= |
+| avg_clarification_rounds | 2.0 | <= |
+| avg_verification_gaps_found | 2.0 | <= |
+| avg_parallel_groups | 0.5 | >= |
+| avg_task_completion_rate | 0.95 | >= |
+| avg_blocker_count | 1.5 | <= |
+| avg_completion_marker_success_rate | 0.95 | >= |
+| avg_verification_failures_found | 1.0 | <= |
+| archival_success_rate | 0.99 | >= |
+
+Green checkmark = meeting target. Red X = below target (with the target shown).
+
+## How It Works
+
+### 1. Collect
+
+Reads completed project artifacts from `specs/` or `specs--completed/` and extracts metrics for each workflow step. Output: `.plan2code-metrics/runs/run-<timestamp>.json`
+
+### 2. Aggregate
+
+Merges all run files into `aggregated.json`, grouped by **prompt generation** — a SHA fingerprint of the 8 workflow prompt files. Two runs that used identical prompt files belong to the same cohort.
+
+### 3. Analyze
+
+Sends aggregated metrics to an AI model with an analyst prompt. The AI produces a diagnosis identifying the weakest workflow steps and root causes. No edits are proposed at this stage.
+
+Output: `.plan2code-metrics/proposals/<timestamp>-diagnosis.md`
+
+### 4. Improve
+
+Sends the diagnosis plus current prompt file contents to an AI model. The AI proposes surgical `old_text -> new_text` edits, each validated against:
+
+- The `old_text` actually exists in the target file
+- The edited file stays under the 11,000 character limit
+
+Output: `.plan2code-metrics/proposals/prop-<timestamp>.json`
+
+### 5. Apply
+
+Interactive diff review for each proposed edit. Accept, reject, or skip individual changes. Applied edits are patched directly into `src/plan2code-*.md`.
+
+## Data Directory
+
+All metrics data lives in `.plan2code-metrics/` (add to `.gitignore` if desired):
+
+```
+.plan2code-metrics/
+├── runs/                  # Individual run JSONs
+│   ├── run-20260215-120000-a1b2.json
+│   └── run-20260220-090000-c3d4.json
+├── aggregated.json        # Merged cohort data
+└── proposals/             # Diagnoses and improvement proposals
+    ├── 20260220-diagnosis.md
+    └── prop-20260220.json
+```
+
+## AI Backends
+
+The analysis and improvement steps require an AI agent. Two backends are supported:
+
+| Backend | Command | Notes |
+|---------|---------|-------|
+| **Claude Code** | `claude` | Uses `--print` mode. Recommended. |
+| **GitHub Copilot CLI** | `copilot` | Uses stdin piping with `--allow-all-tools -s`. |
+
+Model selection is interactive — choose from available models when prompted.
+
+## Architecture
+
+```
+src/
+├── bin/plan2code-metrics.ts   # Entry point
+├── cli.ts                     # Interactive menu (main loop)
+├── types.ts                   # RunMetrics, PromptProposal, CohortMetrics, etc.
+├── collector.ts               # Reads project artifacts → run JSON
+├── aggregator.ts              # Merges runs → aggregated.json (cohort grouping)
+├── analyzer.ts                # AI diagnosis via LLM invocation
+├── improver.ts                # AI improvement proposal + validation
+├── applier.ts                 # Interactive diff review + file patching
+├── invoke-llm.ts              # Unified LLM invocation (Claude Code / Copilot CLI)
+├── index.ts                   # Public API exports
+└── prompts/
+    ├── analyze.md             # AI prompt template for diagnosis
+    └── improve.md             # AI prompt template for improvement proposals
+```
+
+## Development
+
+```bash
+npm run dev      # Watch mode (rebuilds on change)
+npm run build    # Production build
+npm test         # Run unit tests
+npm run test:watch  # Watch mode tests
+npm start        # Run the CLI
+```

plan2code-metrics/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "plan2code-metrics",
+  "version": "1.0.0",
+  "description": "Plan2Code Metrics - Recursive self-improvement toolchain for plan2code contributors",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "plan2code-metrics": "./dist/bin/plan2code-metrics.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "metrics",
+    "plan2code",
+    "contributor-tooling"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "start": "node dist/bin/plan2code-metrics.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.1.0",
+    "chalk": "^5.6.2",
+    "execa": "^9.6.1",
+    "fs-extra": "^11.3.3",
+    "ora": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.0.3",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.1.1"
+  }
+}

plan2code-metrics/src/aggregator.test.ts

@@ -0,0 +1,154 @@
+import { describe, it, expect } from 'vitest';
+import { avg, rate, buildCohortKey, backfillPromptVersions } from './aggregator.js';
+import type { PromptVersions } from './types.js';
+
+// ── avg() ─────────────────────────────────────────────────────────────────────
+
+describe('avg', () => {
+  it('returns null for empty array', () => {
+    expect(avg([])).toBeNull();
+  });
+
+  it('returns null for all-null/undefined values', () => {
+    expect(avg([null, undefined, null])).toBeNull();
+  });
+
+  it('computes correct average for valid numbers', () => {
+    expect(avg([10, 20, 30])).toBe(20);
+  });
+
+  it('filters out null/undefined/NaN from mixed arrays', () => {
+    expect(avg([10, null, 20, undefined, NaN, 30])).toBe(20);
+  });
+});
+
+// ── rate() ────────────────────────────────────────────────────────────────────
+
+describe('rate', () => {
+  it('returns null for empty array', () => {
+    expect(rate([])).toBeNull();
+  });
+
+  it('returns null for all-null values', () => {
+    expect(rate([null, null])).toBeNull();
+  });
+
+  it('returns 1.0 for all-true', () => {
+    expect(rate([true, true, true])).toBe(1.0);
+  });
+
+  it('returns 0.0 for all-false', () => {
+    expect(rate([false, false, false])).toBe(0.0);
+  });
+
+  it('computes correct rate for mixed true/false', () => {
+    expect(rate([true, false, true, false])).toBe(0.5);
+  });
+
+  it('filters out null/undefined from mixed arrays', () => {
+    expect(rate([true, null, false, undefined])).toBe(0.5);
+  });
+});
+
+// ── backfillPromptVersions() ──────────────────────────────────────────────────
+
+const FULL_VERSIONS: PromptVersions = {
+  plan: 'sha256:aaa',
+  revise_plan: 'sha256:bbb',
+  document: 'sha256:ccc',
+  implement: 'sha256:ddd',
+  finalize: 'sha256:eee',
+  init: 'sha256:fff',
+  init_update: 'sha256:ggg',
+  quick_task: 'sha256:hhh',
+};
+
+describe('backfillPromptVersions', () => {
+  it('returns all 8 fields with sentinels when given empty-ish object', () => {
+    const result = backfillPromptVersions({} as PromptVersions);
+    expect(Object.keys(result)).toHaveLength(8);
+    for (const val of Object.values(result)) {
+      expect(val).toBe('sha256:missing');
+    }
+  });
+
+  it('preserves existing values, fills missing with sha256:missing', () => {
+    const partial = { plan: 'sha256:aaa', implement: 'sha256:ddd' } as PromptVersions;
+    const result = backfillPromptVersions(partial);
+    expect(result.plan).toBe('sha256:aaa');
+    expect(result.implement).toBe('sha256:ddd');
+    expect(result.revise_plan).toBe('sha256:missing');
+    expect(result.document).toBe('sha256:missing');
+    expect(result.finalize).toBe('sha256:missing');
+    expect(result.init).toBe('sha256:missing');
+    expect(result.init_update).toBe('sha256:missing');
+    expect(result.quick_task).toBe('sha256:missing');
+  });
+
+  it('returns unchanged object when all 8 fields present', () => {
+    const result = backfillPromptVersions(FULL_VERSIONS);
+    expect(result).toEqual(FULL_VERSIONS);
+  });
+});
+
+// ── buildCohortKey() ──────────────────────────────────────────────────────────
+
+describe('buildCohortKey', () => {
+  it('returns 12-char hex string', () => {
+    const key = buildCohortKey(FULL_VERSIONS);
+    expect(key).toMatch(/^[0-9a-f]{12}$/);
+  });
+
+  it('is deterministic (same input → same output)', () => {
+    const key1 = buildCohortKey(FULL_VERSIONS);
+    const key2 = buildCohortKey(FULL_VERSIONS);
+    expect(key1).toBe(key2);
+  });
+
+  it('old 4-field run with backfill sentinels produces same key as raw 4-field object', () => {
+    // Simulate an old run that only had 4 fields
+    const oldRun = {
+      plan: 'sha256:aaa',
+      implement: 'sha256:ddd',
+      document: 'sha256:ccc',
+      finalize: 'sha256:eee',
+    } as PromptVersions;
+
+    // After backfill, the missing fields get 'sha256:missing'
+    const backfilled = backfillPromptVersions(oldRun);
+
+    // buildCohortKey filters out 'sha256:missing', so both should match
+    const keyDirect = buildCohortKey(oldRun);
+    const keyBackfilled = buildCohortKey(backfilled);
+    expect(keyDirect).toBe(keyBackfilled);
+  });
+
+  it('different prompt versions → different keys', () => {
+    const altered = { ...FULL_VERSIONS, plan: 'sha256:zzz' };
+    expect(buildCohortKey(FULL_VERSIONS)).not.toBe(buildCohortKey(altered));
+  });
+
+  it('key is independent of field insertion order', () => {
+    const ordered: PromptVersions = {
+      plan: 'sha256:aaa',
+      revise_plan: 'sha256:bbb',
+      document: 'sha256:ccc',
+      implement: 'sha256:ddd',
+      finalize: 'sha256:eee',
+      init: 'sha256:fff',
+      init_update: 'sha256:ggg',
+      quick_task: 'sha256:hhh',
+    };
+    const reversed: PromptVersions = {
+      quick_task: 'sha256:hhh',
+      init_update: 'sha256:ggg',
+      init: 'sha256:fff',
+      finalize: 'sha256:eee',
+      implement: 'sha256:ddd',
+      document: 'sha256:ccc',
+      revise_plan: 'sha256:bbb',
+      plan: 'sha256:aaa',
+    };
+    expect(buildCohortKey(ordered)).toBe(buildCohortKey(reversed));
+  });
+});

plan2code-metrics/src/aggregator.ts

@@ -0,0 +1,227 @@
+/**
+ * aggregator.ts
+ * Merges all run JSON files into aggregated.json, grouped by prompt generation (SHA fingerprint).
+ */
+
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import type { RunMetrics, AggregatedMetrics, CohortMetrics, PromptVersions } from './types.js';
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+export function avg(values: (number | null | undefined)[]): number | null {
+  const valid = values.filter((v): v is number => v != null && !isNaN(v));
+  if (valid.length === 0) return null;
+  return valid.reduce((a, b) => a + b, 0) / valid.length;
+}
+
+export function rate(values: (boolean | null | undefined)[]): number | null {
+  const valid = values.filter((v): v is boolean => v != null);
+  if (valid.length === 0) return null;
+  return valid.filter(v => v).length / valid.length;
+}
+
+/**
+ * Build a stable cohort key from the sorted prompt_versions object.
+ * Two runs with identical prompt files get the same cohort key.
+ */
+export function buildCohortKey(promptVersions: PromptVersions): string {
+  // Filter out missing sentinels so old runs (4 fields) keep their original key
+  const entries = Object.entries(promptVersions)
+    .filter(([, v]) => v !== 'sha256:missing')
+    .sort(([a], [b]) => a.localeCompare(b));
+  const str = JSON.stringify(Object.fromEntries(entries));
+  return crypto.createHash('sha256').update(str).digest('hex').slice(0, 12);
+}
+
+/**
+ * Backfill missing PromptVersions fields for old run files (pre-v1.1).
+ */
+export function backfillPromptVersions(pv: PromptVersions): PromptVersions {
+  return {
+    plan:        pv.plan        ?? 'sha256:missing',
+    revise_plan: pv.revise_plan ?? 'sha256:missing',
+    document:    pv.document    ?? 'sha256:missing',
+    implement:   pv.implement   ?? 'sha256:missing',
+    finalize:    pv.finalize    ?? 'sha256:missing',
+    init:        pv.init        ?? 'sha256:missing',
+    init_update: pv.init_update ?? 'sha256:missing',
+    quick_task:  pv.quick_task  ?? 'sha256:missing',
+  };
+}
+
+// ── Load run files ────────────────────────────────────────────────────────────
+
+export function loadRunFiles(runsDir: string): RunMetrics[] {
+  if (!fs.existsSync(runsDir)) return [];
+
+  const files = fs.readdirSync(runsDir)
+    .filter(f => f.endsWith('.json') && f.startsWith('run-'))
+    .sort();
+
+  const runs: RunMetrics[] = [];
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(path.join(runsDir, file), 'utf8');
+      const data = JSON.parse(content) as RunMetrics;
+      data.prompt_versions = backfillPromptVersions(data.prompt_versions);
+      runs.push(data);
+    } catch (err) {
+      console.warn(`Warning: could not parse ${file}: ${err}`);
+    }
+  }
+  return runs;
+}
+
+// ── Build cohort metrics ──────────────────────────────────────────────────────
+
+function buildCohort(runs: RunMetrics[], cohortKey: string): CohortMetrics {
+  const runIds = runs.map(r => r.run_id);
+  const timestamps = runs
+    .flatMap(r => [r.project.started_at, r.project.completed_at])
+    .filter((t): t is string => t != null)
+    .sort();
+
+  // Step 1 averages
+  const avgConfidence = avg(runs.map(r => r.step1_plan.final_confidence));
+  const avgClarification = avg(runs.map(r => r.step1_plan.clarification_rounds));
+  const avgVerifGaps = avg(runs.map(r => r.step1_plan.verification_gaps_found));
+  const avgFRCount = avg(runs.map(r => r.step1_plan.functional_requirements_count));
+  const avgNFRCount = avg(runs.map(r => r.step1_plan.non_functional_requirements_count));
+  const avgRiskCount = avg(runs.map(r => r.step1_plan.risk_count));
+  const avgPhaseStep1 = avg(runs.map(r => r.step1_plan.phase_count));
+
+  // Step 2 averages
+  const avgTotalTasks = avg(runs.map(r => r.step2_document.total_tasks));
+  const avgPhaseStep2 = avg(runs.map(r => r.step2_document.phase_count));
+  const avgParallelGroups = avg(runs.map(r => r.step2_document.parallel_groups_identified));
+  const avgReqCoverage = avg(runs.map(r => r.step2_document.requirement_coverage_percent));
+  const avgVerifItems = avg(runs.map(r => r.step2_document.verification_items_added));
+
+  // Step 3 (loop only)
+  const loopRuns = runs.filter(r => r.step3_implement.used_loop_mode);
+  const avgCompletionRate = avg(loopRuns.map(r => r.step3_implement.task_completion_rate));
+  const avgBlockerCount = avg(loopRuns.map(r => r.step3_implement.blocker_count));
+  const avgTotalIter = avg(loopRuns.map(r => r.step3_implement.total_iterations));
+  const avgIterDuration = avg(loopRuns.map(r => r.step3_implement.avg_iteration_duration_ms));
+  const avgMarkerSuccess = avg(loopRuns.map(r => r.step3_implement.completion_marker_success_rate));
+
+  // Step 4 averages
+  const avgCompletionAtAudit = avg(runs.map(r => r.step4_finalize.completion_rate_at_audit));
+  const avgVerifFailures = avg(runs.map(r => r.step4_finalize.verification_failures_found));
+  const avgDocUpdates = avg(runs.map(r => r.step4_finalize.documentation_updates_needed));
+  const archivalRate = rate(runs.map(r => r.step4_finalize.archival_succeeded));
+
+  // User feedback
+  const feedbackRuns = runs.filter(r => r.user_feedback != null);
+  const avgUserRating = avg(feedbackRuns.map(r => r.user_feedback!.overall_rating));
+  const feedbackCount = feedbackRuns.length;
+
+  return {
+    cohort_key: cohortKey,
+    prompt_versions: runs[0].prompt_versions,
+    run_count: runs.length,
+    run_ids: runIds,
+    first_seen: timestamps[0] ?? runs[0].run_id,
+    last_seen: timestamps[timestamps.length - 1] ?? runs[runs.length - 1].run_id,
+
+    avg_confidence: avgConfidence,
+    avg_clarification_rounds: avgClarification,
+    avg_verification_gaps_found: avgVerifGaps,
+    avg_functional_requirements_count: avgFRCount,
+    avg_non_functional_requirements_count: avgNFRCount,
+    avg_risk_count: avgRiskCount,
+    avg_phase_count_step1: avgPhaseStep1,
+
+    avg_total_tasks: avgTotalTasks,
+    avg_phase_count_step2: avgPhaseStep2,
+    avg_parallel_groups: avgParallelGroups,
+    avg_requirement_coverage_percent: avgReqCoverage,
+    avg_verification_items_added: avgVerifItems,
+
+    loop_run_count: loopRuns.length,
+    avg_task_completion_rate: avgCompletionRate,
+    avg_blocker_count: avgBlockerCount,
+    avg_total_iterations: avgTotalIter,
+    avg_iteration_duration_ms: avgIterDuration,
+    avg_completion_marker_success_rate: avgMarkerSuccess,
+
+    avg_completion_rate_at_audit: avgCompletionAtAudit,
+    avg_verification_failures_found: avgVerifFailures,
+    avg_documentation_updates_needed: avgDocUpdates,
+    archival_success_rate: archivalRate,
+
+    avg_user_rating: avgUserRating,
+    feedback_count: feedbackCount,
+  };
+}
+
+// ── Main aggregator ───────────────────────────────────────────────────────────
+
+export function aggregate(runsDir: string, outputPath: string): AggregatedMetrics {
+  const runs = loadRunFiles(runsDir);
+
+  // Group by cohort key
+  const cohortMap = new Map<string, RunMetrics[]>();
+  for (const run of runs) {
+    const key = buildCohortKey(run.prompt_versions);
+    if (!cohortMap.has(key)) cohortMap.set(key, []);
+    cohortMap.get(key)!.push(run);
+  }
+
+  // Sort cohorts by first seen
+  const cohorts: CohortMetrics[] = [];
+  for (const [key, cohortRuns] of cohortMap) {
+    cohorts.push(buildCohort(cohortRuns, key));
+  }
+  cohorts.sort((a, b) => a.first_seen.localeCompare(b.first_seen));
+
+  // Determine current cohort (most recent)
+  const currentCohortKey = cohorts.length > 0
+    ? cohorts[cohorts.length - 1].cohort_key
+    : null;
+
+  const aggregated: AggregatedMetrics = {
+    schema_version: '1.0',
+    last_updated: new Date().toISOString(),
+    total_runs: runs.length,
+    cohorts,
+    current_cohort_key: currentCohortKey,
+  };
+
+  // Write to output path
+  const dir = path.dirname(outputPath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(outputPath, JSON.stringify(aggregated, null, 2), 'utf8');
+
+  return aggregated;
+}
+
+export function loadAggregated(outputPath: string): AggregatedMetrics | null {
+  try {
+    const content = fs.readFileSync(outputPath, 'utf8');
+    return JSON.parse(content) as AggregatedMetrics;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Import a single run JSON from another project into the local runs dir.
+ * Returns true if imported, false if already present.
+ */
+export function importRun(runJsonPath: string, runsDir: string): boolean {
+  const content = fs.readFileSync(runJsonPath, 'utf8');
+  const run = JSON.parse(content) as RunMetrics;
+  run.prompt_versions = backfillPromptVersions(run.prompt_versions);
+  const destPath = path.join(runsDir, `${run.run_id}.json`);
+
+  if (fs.existsSync(destPath)) {
+    return false; // Already imported
+  }
+
+  fs.mkdirSync(runsDir, { recursive: true });
+  fs.writeFileSync(destPath, JSON.stringify(run, null, 2), 'utf8');
+  return true;
+}

plan2code-metrics/src/analyzer.ts

@@ -0,0 +1,128 @@
+/**
+ * analyzer.ts
+ * Reads aggregated.json + prompt file contents, builds analysis prompt, invokes AI.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import type { AggregatedMetrics } from './types.js';
+import { invokeLLM, type AgentType } from './invoke-llm.js';
+
+const ANALYZE_PROMPT_PATH = new URL('../src/prompts/analyze.md', import.meta.url).pathname
+  .replace(/^\/([A-Za-z]:)/, '$1'); // Fix Windows path
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function readPromptFiles(plan2codeRoot: string): Record<string, string> {
+  const srcDir = path.join(plan2codeRoot, 'src');
+  const promptFiles = [
+    'plan2code-1--plan.md',
+    'plan2code-1b--revise-plan.md',
+    'plan2code-2--document.md',
+    'plan2code-3--implement.md',
+    'plan2code-4--finalize.md',
+    'plan2code---init.md',
+    'plan2code---init-update.md',
+    'plan2code---quick-task.md',
+  ];
+
+  const contents: Record<string, string> = {};
+  for (const file of promptFiles) {
+    try {
+      contents[file] = fs.readFileSync(path.join(srcDir, file), 'utf8');
+    } catch {
+      contents[file] = '(file not found)';
+    }
+  }
+  return contents;
+}
+
+function interpolate(template: string, vars: Record<string, string>): string {
+  let result = template;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replaceAll(`{{${key}}}`, value);
+  }
+  return result;
+}
+
+function generateDiagnosisId(): string {
+  const now = new Date();
+  const ts = now.toISOString().replace(/[-:T.Z]/g, '').slice(0, 14);
+  return `diag-${ts}`;
+}
+
+// ── Main analyzer ─────────────────────────────────────────────────────────────
+
+export interface AnalyzerOptions {
+  aggregatedPath: string;    // Path to aggregated.json
+  plan2codeRoot: string;     // Path to plan2code repo root
+  proposalsDir: string;      // Where to save diagnosis output
+  model?: string;            // AI model to use (default: claude-opus-4-6)
+  agent?: AgentType;         // Agent to use (default: claude-code)
+}
+
+export async function runAnalysis(opts: AnalyzerOptions): Promise<string> {
+  const { aggregatedPath, plan2codeRoot, proposalsDir, model = 'claude-opus-4-6', agent = 'claude-code' } = opts;
+
+  // Load aggregated metrics
+  let aggregated: AggregatedMetrics | null = null;
+  try {
+    aggregated = JSON.parse(fs.readFileSync(aggregatedPath, 'utf8')) as AggregatedMetrics;
+  } catch {
+    throw new Error(`Could not read aggregated metrics at ${aggregatedPath}. Run "Collect metrics" and "Import run data" first.`);
+  }
+
+  if (aggregated.total_runs === 0) {
+    throw new Error('No runs in aggregated metrics. Collect and import some runs first.');
+  }
+
+  // Read prompt files
+  const promptContents = readPromptFiles(plan2codeRoot);
+
+  // Format for interpolation
+  const promptContentsStr = Object.entries(promptContents)
+    .map(([file, content]) => `## ${file}\n\n${content}`)
+    .join('\n\n---\n\n');
+
+  const aggregatedStr = JSON.stringify(aggregated, null, 2);
+
+  // Load analyze prompt template
+  let analyzeTemplate: string;
+  try {
+    analyzeTemplate = fs.readFileSync(ANALYZE_PROMPT_PATH, 'utf8');
+  } catch {
+    // Fallback: look relative to cwd
+    const altPath = path.join(process.cwd(), 'src', 'prompts', 'analyze.md');
+    analyzeTemplate = fs.readFileSync(altPath, 'utf8');
+  }
+
+  const fullPrompt = interpolate(analyzeTemplate, {
+    aggregatedMetrics: aggregatedStr,
+    promptContents: promptContentsStr,
+  });
+
+  // Invoke Claude
+  console.log(`\nInvoking AI analysis (model: ${model})...`);
+  console.log('This may take a minute...\n');
+
+  let diagnosisContent: string;
+  try {
+    diagnosisContent = await invokeLLM({
+      prompt: fullPrompt,
+      model,
+      agent,
+      timeout: 300_000,
+    });
+  } catch (err) {
+    throw new Error(`AI invocation failed: ${err instanceof Error ? err.message : String(err)}\n\nMake sure the ${agent} CLI is installed and authenticated.`);
+  }
+
+  // Save diagnosis
+  const diagId = generateDiagnosisId();
+  fs.mkdirSync(proposalsDir, { recursive: true });
+  const diagPath = path.join(proposalsDir, `${diagId}-diagnosis.md`);
+  fs.writeFileSync(diagPath, diagnosisContent, 'utf8');
+
+  console.log(`Diagnosis saved to: ${diagPath}`);
+  return diagPath;
+}

plan2code-metrics/src/applier.ts

@@ -0,0 +1,201 @@
+/**
+ * applier.ts
+ * Interactive review of a PromptProposal: display colored diff per edit,
+ * user approves/rejects each edit, apply approved edits to src files.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import type { PromptEdit, PromptProposal } from './types.js';
+import { validateEdit } from './improver.js';
+
+const CHAR_LIMIT = 11_000;
+
+// ── Diff display ──────────────────────────────────────────────────────────────
+
+function displayEditDiff(edit: PromptEdit, index: number, total: number): void {
+  console.log();
+  console.log(chalk.bold(`─── Edit ${index + 1} of ${total} ───────────────────────────────────`));
+  console.log(chalk.cyan(`File:     ${edit.file}`));
+  console.log(chalk.gray(`Rationale: ${edit.rationale}`));
+  console.log(chalk.gray(`Expected impact: ${edit.expected_metric_impact}`));
+  console.log(chalk.gray(`Char impact: ${edit.char_count_before} → ${edit.char_count_after} (${edit.char_count_delta >= 0 ? '+' : ''}${edit.char_count_delta})`));
+
+  // Show char count status
+  if (edit.char_count_after > CHAR_LIMIT) {
+    console.log(chalk.red(`⚠ WARNING: Would exceed ${CHAR_LIMIT} char limit!`));
+  } else {
+    const headroom = CHAR_LIMIT - edit.char_count_after;
+    console.log(chalk.green(`✓ Char count OK (${headroom} chars headroom after edit)`));
+  }
+
+  console.log();
+  console.log(chalk.bold('── REMOVED (old_text) ──'));
+
+  // Show old text with line-level context
+  const oldLines = edit.old_text.split('\n');
+  for (const line of oldLines) {
+    console.log(chalk.red('- ') + chalk.red(line));
+  }
+
+  console.log();
+  console.log(chalk.bold('── ADDED (new_text) ──'));
+
+  const newLines = edit.new_text.split('\n');
+  for (const line of newLines) {
+    console.log(chalk.green('+ ') + chalk.green(line));
+  }
+
+  console.log();
+}
+
+// ── Apply edit to file ────────────────────────────────────────────────────────
+
+function applyEdit(edit: PromptEdit, plan2codeRoot: string): boolean {
+  // Reject path traversal attempts
+  if (edit.file.includes('..') || path.isAbsolute(edit.file)) {
+    console.error(chalk.red(`✗ Rejected: "${edit.file}" contains path traversal or absolute path`));
+    return false;
+  }
+
+  const filePath = path.join(plan2codeRoot, 'src', edit.file);
+  try {
+    let content = fs.readFileSync(filePath, 'utf8');
+    if (!content.includes(edit.old_text)) {
+      console.error(chalk.red(`✗ Cannot apply: old_text not found in ${edit.file} (may have been modified by a previous edit)`));
+      return false;
+    }
+    content = content.replace(edit.old_text, edit.new_text);
+
+    // Post-apply char count check
+    if (content.length > CHAR_LIMIT) {
+      console.error(chalk.red(`✗ Cannot apply: would exceed ${CHAR_LIMIT} char limit (${content.length} chars)`));
+      return false;
+    }
+
+    fs.writeFileSync(filePath, content, 'utf8');
+    console.log(chalk.green(`✓ Applied edit to ${edit.file} (now ${content.length} chars)`));
+    return true;
+  } catch (err) {
+    console.error(chalk.red(`✗ Failed to apply edit: ${err instanceof Error ? err.message : String(err)}`));
+    return false;
+  }
+}
+
+// ── Main applier ──────────────────────────────────────────────────────────────
+
+export interface ApplierOptions {
+  proposalPath: string;
+  plan2codeRoot: string;
+  proposalsDir: string;
+}
+
+export interface ApplierResult {
+  approved: number;
+  rejected: number;
+  applied: number;
+  failed: number;
+}
+
+export async function reviewAndApply(opts: ApplierOptions): Promise<ApplierResult> {
+  const { proposalPath, plan2codeRoot, proposalsDir } = opts;
+
+  // Load proposal
+  let proposal: PromptProposal;
+  try {
+    proposal = JSON.parse(fs.readFileSync(proposalPath, 'utf8')) as PromptProposal;
+  } catch {
+    throw new Error(`Could not read proposal at ${proposalPath}`);
+  }
+
+  if (proposal.proposals.length === 0) {
+    console.log(chalk.yellow('No edits in this proposal.'));
+    return { approved: 0, rejected: 0, applied: 0, failed: 0 };
+  }
+
+  console.log();
+  console.log(chalk.bold.cyan('=== Plan2Code Prompt Improvement Review ==='));
+  console.log(chalk.gray(`Proposal: ${proposal.proposal_id}`));
+  console.log(chalk.gray(`Created:  ${proposal.created_at}`));
+  console.log(chalk.gray(`Based on: ${proposal.based_on_runs.length} run(s)`));
+  console.log(chalk.gray(`Edits:    ${proposal.proposals.length}`));
+
+  // Re-validate all edits against current file state
+  const promptContents: Record<string, string> = {};
+  const srcDir = path.join(plan2codeRoot, 'src');
+  for (const edit of proposal.proposals) {
+    if (!promptContents[edit.file]) {
+      try {
+        promptContents[edit.file] = fs.readFileSync(path.join(srcDir, edit.file), 'utf8');
+      } catch {
+        promptContents[edit.file] = '';
+      }
+    }
+  }
+
+  let approved = 0;
+  let rejected = 0;
+  let applied = 0;
+  let failed = 0;
+
+  for (let i = 0; i < proposal.proposals.length; i++) {
+    const edit = proposal.proposals[i];
+
+    // Re-validate
+    const validation = validateEdit(edit, promptContents);
+    if (!validation.valid) {
+      console.log();
+      console.log(chalk.red(`✗ Edit ${i + 1} is no longer valid (files may have changed):`));
+      for (const err of validation.errors) {
+        console.log(chalk.red(`  - ${err}`));
+      }
+      rejected++;
+      continue;
+    }
+
+    displayEditDiff(edit, i, proposal.proposals.length);
+
+    const approve = await confirm({
+      message: `Apply this edit to ${edit.file}?`,
+      default: true,
+    });
+
+    if (!approve) {
+      console.log(chalk.gray('Skipped.'));
+      rejected++;
+      continue;
+    }
+
+    approved++;
+    const success = applyEdit(edit, plan2codeRoot);
+    if (success) {
+      applied++;
+      // Update in-memory content to reflect the edit
+      promptContents[edit.file] = promptContents[edit.file].replace(edit.old_text, edit.new_text);
+    } else {
+      failed++;
+    }
+  }
+
+  // Update proposal status
+  proposal.status = applied > 0 ? 'applied' : 'rejected';
+  fs.writeFileSync(proposalPath, JSON.stringify(proposal, null, 2), 'utf8');
+
+  // Summary
+  console.log();
+  console.log(chalk.bold('─── Review Complete ──────────────────────────────────'));
+  console.log(`Approved: ${chalk.green(String(approved))}  Rejected: ${chalk.red(String(rejected))}  Applied: ${chalk.green(String(applied))}  Failed: ${chalk.red(String(failed))}`);
+
+  if (applied > 0) {
+    console.log();
+    console.log(chalk.bold.cyan('Next steps — create a PR with your changes:'));
+    console.log(chalk.gray('  git add src/'));
+    console.log(chalk.gray(`  git commit -m "metrics: apply prompt improvements (${proposal.proposal_id})"`));
+    console.log(chalk.gray('  git push -u origin HEAD'));
+    console.log(chalk.gray('  gh pr create --title "metrics: apply gen N improvements"'));
+  }
+
+  return { approved, rejected, applied, failed };
+}

plan2code-metrics/src/bin/plan2code-metrics.ts

@@ -0,0 +1,17 @@
+import { runCLI } from '../cli.js';
+
+async function main() {
+  try {
+    await runCLI();
+    process.exit(0);
+  } catch (err) {
+    if (err instanceof Error && err.message.includes('User force closed')) {
+      // Ctrl+C — exit cleanly
+      process.exit(0);
+    }
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+
+main();

plan2code-metrics/src/cli.ts

@@ -0,0 +1,645 @@
+/**
+ * cli.ts
+ * 100% interactive menu-driven CLI for plan2code-metrics.
+ * No flags — all inputs collected via @inquirer/prompts.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { select, input, confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import ora from 'ora';
+import { collectRun } from './collector.js';
+import { aggregate, loadAggregated, importRun, loadRunFiles } from './aggregator.js';
+import { runAnalysis } from './analyzer.js';
+import { generateImprovement } from './improver.js';
+import { reviewAndApply } from './applier.js';
+import type { AggregatedMetrics, CohortMetrics } from './types.js';
+import { METRIC_TARGETS } from './types.js';
+import { AGENTS, type AgentType } from './invoke-llm.js';
+
+// ── Defaults ──────────────────────────────────────────────────────────────────
+
+const DEFAULT_METRICS_DIR = '.plan2code-metrics';
+const DEFAULT_RUNS_SUBDIR = 'runs';
+const DEFAULT_AGGREGATED_FILE = 'aggregated.json';
+const DEFAULT_PROPOSALS_SUBDIR = 'proposals';
+
+function getMetricsDirs(baseDir = process.cwd()) {
+  const metricsDir = path.join(baseDir, DEFAULT_METRICS_DIR);
+  return {
+    metricsDir,
+    runsDir: path.join(metricsDir, DEFAULT_RUNS_SUBDIR),
+    aggregatedPath: path.join(metricsDir, DEFAULT_AGGREGATED_FILE),
+    proposalsDir: path.join(metricsDir, DEFAULT_PROPOSALS_SUBDIR),
+  };
+}
+
+// Detect plan2code root (either this directory or parent directories)
+function detectPlan2CodeRoot(): string | null {
+  let dir = process.cwd();
+  for (let i = 0; i < 5; i++) {
+    const srcDir = path.join(dir, 'src');
+    if (
+      fs.existsSync(path.join(srcDir, 'plan2code-1--plan.md')) &&
+      fs.existsSync(path.join(srcDir, 'plan2code-2--document.md'))
+    ) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+// Detect plan2code version
+function detectPlan2CodeVersion(plan2codeRoot: string): string {
+  try {
+    const versionPath = path.join(plan2codeRoot, 'version.json');
+    const content = JSON.parse(fs.readFileSync(versionPath, 'utf8'));
+    return content.version ?? '0.0.0';
+  } catch {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(plan2codeRoot, 'package.json'), 'utf8'));
+      return pkg.version ?? '0.0.0';
+    } catch {
+      return '0.0.0';
+    }
+  }
+}
+
+// ── Metric health helpers ─────────────────────────────────────────────────────
+
+function metricStatus(key: string, value: number | null): string {
+  if (value == null) return chalk.gray('N/A');
+  const target = METRIC_TARGETS[key as keyof typeof METRIC_TARGETS];
+  if (!target) return chalk.white(String(Math.round(value * 100) / 100));
+
+  const ok = target.direction === 'gte' ? value >= target.target : value <= target.target;
+  const formatted = Number.isInteger(value) ? String(value) : value.toFixed(2);
+  return ok ? chalk.green(`✓ ${formatted}`) : chalk.red(`✗ ${formatted} (target: ${target.direction === 'gte' ? '≥' : '≤'}${target.target})`);
+}
+
+// ── Agent + model selection ───────────────────────────────────────────────────
+
+async function selectAgentAndModel(): Promise<{ agent: AgentType; model: string }> {
+  const agentChoice = await select({
+    message: 'Which AI agent?',
+    choices: Object.values(AGENTS).map(a => ({ name: a.displayName, value: a.name })),
+  });
+
+  const agentDef = AGENTS[agentChoice];
+  const model = await select({
+    message: 'AI model:',
+    choices: agentDef.models.map(m => ({ name: m.label, value: m.value })),
+  });
+
+  return { agent: agentChoice, model };
+}
+
+// ── Flow: Collect metrics ─────────────────────────────────────────────────────
+
+async function flowCollect(): Promise<void> {
+  console.log();
+  console.log(chalk.bold.cyan('── Collect Metrics ──'));
+
+  const sourceChoice = await select({
+    message: 'Where is the completed project spec?',
+    choices: [
+      { name: 'Active spec directory (specs/<feature-name>/)', value: 'active' },
+      { name: 'Archived spec (specs--completed/<feature-name>/)', value: 'archived' },
+      { name: 'Custom path', value: 'custom' },
+    ],
+  });
+
+  let specDir: string;
+  let projectName: string;
+
+  if (sourceChoice === 'active' || sourceChoice === 'archived') {
+    const baseSubdir = sourceChoice === 'active' ? 'specs' : 'specs--completed';
+    const baseDir = path.join(process.cwd(), baseSubdir);
+
+    if (!fs.existsSync(baseDir)) {
+      console.log(chalk.red(`No ${baseSubdir}/ directory found in ${process.cwd()}`));
+      return;
+    }
+
+    const entries = fs.readdirSync(baseDir)
+      .filter(f => fs.statSync(path.join(baseDir, f)).isDirectory());
+
+    if (entries.length === 0) {
+      console.log(chalk.red(`No spec directories found in ${baseSubdir}/`));
+      return;
+    }
+
+    const chosen = await select({
+      message: 'Select spec directory:',
+      choices: entries.map(e => ({ name: e, value: e })),
+    });
+
+    specDir = path.join(baseDir, chosen);
+    projectName = chosen;
+  } else {
+    specDir = await input({
+      message: 'Enter full path to spec directory:',
+      validate: (v) => fs.existsSync(v) ? true : 'Directory not found',
+    });
+    projectName = await input({
+      message: 'Project name (for metrics label):',
+      default: path.basename(specDir),
+    });
+  }
+
+  // Detect plan2code root
+  const plan2codeRoot = detectPlan2CodeRoot() ?? process.cwd();
+  const plan2codeVersion = detectPlan2CodeVersion(plan2codeRoot);
+
+  const { runsDir, aggregatedPath } = getMetricsDirs();
+
+  const spinner = ora('Collecting metrics from project artifacts...').start();
+  try {
+    const metrics = await collectRun({
+      specDir,
+      projectName,
+      plan2codeRoot,
+      plan2codeVersion,
+      outputDir: runsDir,
+    });
+
+    spinner.succeed(`Metrics collected: ${metrics.run_id}`);
+    console.log(chalk.gray(`  Saved to: ${runsDir}/${metrics.run_id}.json`));
+
+    // Re-aggregate
+    aggregate(runsDir, aggregatedPath);
+    console.log(chalk.gray('  Aggregated metrics updated.'));
+
+    // Show summary
+    console.log();
+    console.log(chalk.bold('Collected:'));
+    console.log(`  Step 1 (Plan):       ${metrics.step1_plan.present ? chalk.green('✓') : chalk.gray('—')}`);
+    console.log(`  Step 2 (Document):   ${metrics.step2_document.present ? chalk.green('✓') : chalk.gray('—')}`);
+    console.log(`  Step 3 (Implement):  ${metrics.step3_implement.present ? (metrics.step3_implement.used_loop_mode ? chalk.green('✓ (loop)') : chalk.yellow('✓ (manual)')) : chalk.gray('—')}`);
+    console.log(`  Step 4 (Finalize):   ${metrics.step4_finalize.present ? chalk.green('✓') : chalk.gray('—')}`);
+    console.log(`  User Feedback:       ${metrics.user_feedback ? chalk.green(`✓ (${metrics.user_feedback.overall_rating}/10)`) : chalk.gray('—')}`);
+
+    // Offer to collect feedback interactively if not present
+    if (!metrics.user_feedback) {
+      console.log();
+      const wantFeedback = await confirm({
+        message: 'No user feedback found in overview.md. Would you like to provide feedback now?',
+        default: false,
+      });
+
+      if (wantFeedback) {
+        const rating = await input({
+          message: 'Overall rating (1-10):',
+          validate: (v) => {
+            const n = parseInt(v, 10);
+            return (n >= 1 && n <= 10) ? true : 'Must be a number between 1 and 10';
+          },
+        });
+        const reason = await input({ message: 'Rating reason:' });
+        const wentWell = await input({ message: 'What went well?' });
+        const wentPoorly = await input({ message: 'What went poorly?' });
+
+        // Write the feedback table into overview.md
+        const overviewPath = path.join(specDir, 'overview.md');
+        let overviewContent = '';
+        try {
+          overviewContent = fs.readFileSync(overviewPath, 'utf8');
+        } catch { /* empty */ }
+
+        // Escape pipe characters in user text to prevent table parsing issues
+        const esc = (s: string) => s.replace(/\|/g, '\\|');
+
+        const feedbackTable = [
+          '',
+          '## User Feedback',
+          '| Field | Value |',
+          '|-------|-------|',
+          `| Rating | ${rating} |`,
+          `| Reason | ${esc(reason)} |`,
+          `| Went Well | ${esc(wentWell)} |`,
+          `| Went Poorly | ${esc(wentPoorly)} |`,
+          '',
+        ].join('\n');
+
+        fs.writeFileSync(overviewPath, overviewContent + feedbackTable, 'utf8');
+        console.log(chalk.green('✓ Feedback written to overview.md'));
+
+        // Delete the original run (without feedback) before re-collecting
+        const originalRunPath = path.join(runsDir, `${metrics.run_id}.json`);
+        try { fs.unlinkSync(originalRunPath); } catch { /* ignore */ }
+
+        // Re-collect and re-aggregate
+        const reSpinner = ora('Re-collecting metrics with feedback...').start();
+        const updatedMetrics = await collectRun({
+          specDir,
+          projectName,
+          plan2codeRoot,
+          plan2codeVersion,
+          outputDir: runsDir,
+        });
+        aggregate(runsDir, aggregatedPath);
+        reSpinner.succeed(`Updated: ${updatedMetrics.run_id} (rating: ${updatedMetrics.user_feedback?.overall_rating}/10)`);
+      }
+    }
+  } catch (err) {
+    spinner.fail(`Collection failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+
+// ── Flow: Import run data ─────────────────────────────────────────────────────
+
+async function flowImport(): Promise<void> {
+  console.log();
+  console.log(chalk.bold.cyan('── Import Run Data ──'));
+  console.log(chalk.gray('Copy a run JSON from another project into this repo for aggregation.'));
+  console.log();
+
+  const sourcePath = await input({
+    message: 'Path to run JSON file (e.g., /path/to/project/.plan2code-metrics/runs/run-xxx.json):',
+    validate: (v) => {
+      if (!fs.existsSync(v)) return 'File not found';
+      if (!v.endsWith('.json')) return 'Must be a .json file';
+      return true;
+    },
+  });
+
+  const { runsDir, aggregatedPath } = getMetricsDirs();
+
+  try {
+    const imported = importRun(sourcePath, runsDir);
+    if (!imported) {
+      console.log(chalk.yellow('Run already imported (same run_id exists).'));
+    } else {
+      console.log(chalk.green(`✓ Imported ${path.basename(sourcePath)}`));
+    }
+
+    const spinner = ora('Re-aggregating...').start();
+    const aggregated = aggregate(runsDir, aggregatedPath);
+    spinner.succeed(`Aggregated metrics updated (${aggregated.total_runs} total runs)`);
+  } catch (err) {
+    console.error(chalk.red(`Import failed: ${err instanceof Error ? err.message : String(err)}`));
+  }
+}
+
+// ── Flow: View metrics status ─────────────────────────────────────────────────
+
+async function flowViewStatus(): Promise<void> {
+  console.log();
+  console.log(chalk.bold.cyan('── Metrics Status & History ──'));
+
+  const { runsDir, aggregatedPath } = getMetricsDirs();
+  const aggregated = loadAggregated(aggregatedPath);
+
+  if (!aggregated || aggregated.total_runs === 0) {
+    console.log(chalk.yellow('No metrics collected yet. Use "Collect metrics" to get started.'));
+    return;
+  }
+
+  console.log();
+  console.log(chalk.bold(`Total runs: ${aggregated.total_runs}  |  Generations: ${aggregated.cohorts.length}`));
+  console.log(chalk.gray(`Last updated: ${aggregated.last_updated}`));
+
+  for (let i = 0; i < aggregated.cohorts.length; i++) {
+    const cohort = aggregated.cohorts[i];
+    const isCurrent = cohort.cohort_key === aggregated.current_cohort_key;
+    const label = isCurrent ? chalk.bold.green('[CURRENT]') : '';
+
+    console.log();
+    console.log(chalk.bold(`Generation ${i + 1} (sha:${cohort.cohort_key}) — ${cohort.run_count} run(s) ${label}`));
+    console.log(chalk.gray(`  Period: ${cohort.first_seen?.slice(0, 10)} → ${cohort.last_seen?.slice(0, 10)}`));
+
+    // Step 1 metrics
+    if (cohort.avg_confidence != null || cohort.avg_clarification_rounds != null) {
+      console.log(chalk.bold('  Step 1 (Plan):'));
+      if (cohort.avg_confidence != null)
+        console.log(`    avg_confidence:           ${metricStatus('avg_confidence', cohort.avg_confidence)}`);
+      if (cohort.avg_clarification_rounds != null)
+        console.log(`    avg_clarification_rounds: ${metricStatus('avg_clarification_rounds', cohort.avg_clarification_rounds)}`);
+      if (cohort.avg_verification_gaps_found != null)
+        console.log(`    avg_verification_gaps:    ${metricStatus('avg_verification_gaps_found', cohort.avg_verification_gaps_found)}`);
+    }
+
+    // Step 2 metrics
+    if (cohort.avg_total_tasks != null || cohort.avg_parallel_groups != null) {
+      console.log(chalk.bold('  Step 2 (Document):'));
+      if (cohort.avg_total_tasks != null)
+        console.log(`    avg_total_tasks:          ${chalk.white(cohort.avg_total_tasks.toFixed(1))}`);
+      if (cohort.avg_parallel_groups != null)
+        console.log(`    avg_parallel_groups:      ${metricStatus('avg_parallel_groups', cohort.avg_parallel_groups)}`);
+      if (cohort.avg_verification_items_added != null)
+        console.log(`    avg_verification_items:   ${metricStatus('avg_verification_items_added', cohort.avg_verification_items_added)}`);
+    }
+
+    // Step 3 metrics (loop only)
+    if (cohort.loop_run_count > 0) {
+      console.log(chalk.bold(`  Step 3 (Implement) — ${cohort.loop_run_count} loop run(s):`));
+      if (cohort.avg_task_completion_rate != null)
+        console.log(`    avg_task_completion_rate: ${metricStatus('avg_task_completion_rate', cohort.avg_task_completion_rate)}`);
+      if (cohort.avg_blocker_count != null)
+        console.log(`    avg_blocker_count:        ${metricStatus('avg_blocker_count', cohort.avg_blocker_count)}`);
+      if (cohort.avg_completion_marker_success_rate != null)
+        console.log(`    avg_marker_success_rate:  ${metricStatus('avg_completion_marker_success_rate', cohort.avg_completion_marker_success_rate)}`);
+    }
+
+    // Step 4 metrics
+    if (cohort.avg_completion_rate_at_audit != null || cohort.archival_success_rate != null) {
+      console.log(chalk.bold('  Step 4 (Finalize):'));
+      if (cohort.avg_completion_rate_at_audit != null)
+        console.log(`    avg_completion_at_audit:  ${chalk.white(cohort.avg_completion_rate_at_audit.toFixed(2))}`);
+      if (cohort.avg_verification_failures_found != null)
+        console.log(`    avg_verif_failures:       ${metricStatus('avg_verification_failures_found', cohort.avg_verification_failures_found)}`);
+      if (cohort.archival_success_rate != null)
+        console.log(`    archival_success_rate:    ${metricStatus('archival_success_rate', cohort.archival_success_rate)}`);
+    }
+
+    // User feedback
+    if (cohort.feedback_count > 0) {
+      console.log(chalk.bold('  User Feedback:'));
+      console.log(`    avg_user_rating:          ${metricStatus('avg_user_rating', cohort.avg_user_rating)}`);
+      console.log(`    feedback_count:           ${chalk.white(String(cohort.feedback_count))}`);
+    }
+
+    // Compare with previous generation
+    if (i > 0) {
+      const prev = aggregated.cohorts[i - 1];
+      const deltas: string[] = [];
+      if (cohort.avg_confidence != null && prev.avg_confidence != null) {
+        const d = cohort.avg_confidence - prev.avg_confidence;
+        deltas.push(`confidence ${d >= 0 ? chalk.green(`▲${d.toFixed(1)}`) : chalk.red(`▼${Math.abs(d).toFixed(1)}`)}`);
+      }
+      if (cohort.avg_task_completion_rate != null && prev.avg_task_completion_rate != null) {
+        const d = cohort.avg_task_completion_rate - prev.avg_task_completion_rate;
+        deltas.push(`completion ${d >= 0 ? chalk.green(`▲${(d * 100).toFixed(1)}%`) : chalk.red(`▼${(Math.abs(d) * 100).toFixed(1)}%`)}`);
+      }
+      if (deltas.length > 0) {
+        console.log(chalk.gray(`  vs Gen ${i}: ${deltas.join('  ')}`));
+      }
+    }
+  }
+
+  // Run list
+  const runs = loadRunFiles(runsDir);
+  if (runs.length > 0) {
+    console.log();
+    console.log(chalk.bold(`Run files (${runs.length}):`));
+    for (const run of runs.slice(-10)) {
+      console.log(chalk.gray(`  ${run.run_id}  ${run.project.name}  v${run.plan2code_version}`));
+    }
+    if (runs.length > 10) {
+      console.log(chalk.gray(`  ... and ${runs.length - 10} more`));
+    }
+  }
+}
+
+// ── Flow: Run analysis ────────────────────────────────────────────────────────
+
+async function flowRunAnalysis(): Promise<string | null> {
+  console.log();
+  console.log(chalk.bold.cyan('── Run Analysis (Diagnose Weak Steps) ──'));
+
+  const { aggregatedPath, proposalsDir } = getMetricsDirs();
+  const plan2codeRoot = detectPlan2CodeRoot() ?? process.cwd();
+
+  const aggregated = loadAggregated(aggregatedPath);
+  if (!aggregated || aggregated.total_runs === 0) {
+    console.log(chalk.yellow('No aggregated metrics found. Collect and import runs first.'));
+    return null;
+  }
+
+  if (aggregated.total_runs < 3) {
+    const proceed = await confirm({
+      message: `Only ${aggregated.total_runs} run(s) available (≥3 recommended for reliable analysis). Proceed anyway?`,
+      default: false,
+    });
+    if (!proceed) return null;
+  }
+
+  const { agent, model } = await selectAgentAndModel();
+
+  try {
+    const diagPath = await runAnalysis({
+      aggregatedPath,
+      plan2codeRoot,
+      proposalsDir,
+      model,
+      agent,
+    });
+
+    console.log();
+    console.log(chalk.green('✓ Analysis complete'));
+    console.log(chalk.gray(`Diagnosis: ${diagPath}`));
+
+    const viewNow = await confirm({
+      message: 'Open diagnosis in console?',
+      default: true,
+    });
+
+    if (viewNow) {
+      const content = fs.readFileSync(diagPath, 'utf8');
+      console.log();
+      console.log(chalk.dim('─'.repeat(60)));
+      console.log(content);
+      console.log(chalk.dim('─'.repeat(60)));
+    }
+
+    return diagPath;
+  } catch (err) {
+    console.error(chalk.red(`Analysis failed: ${err instanceof Error ? err.message : String(err)}`));
+    return null;
+  }
+}
+
+// ── Flow: Generate improvement proposal ──────────────────────────────────────
+
+async function flowGenerateProposal(): Promise<void> {
+  console.log();
+  console.log(chalk.bold.cyan('── Generate Improvement Proposal ──'));
+
+  const { aggregatedPath, proposalsDir, runsDir } = getMetricsDirs();
+  const plan2codeRoot = detectPlan2CodeRoot() ?? process.cwd();
+
+  // Find diagnosis files
+  let diagFiles: string[] = [];
+  if (fs.existsSync(proposalsDir)) {
+    diagFiles = fs.readdirSync(proposalsDir)
+      .filter(f => f.endsWith('-diagnosis.md'))
+      .sort()
+      .reverse(); // most recent first
+  }
+
+  let diagnosisPath: string;
+
+  if (diagFiles.length === 0) {
+    console.log(chalk.yellow('No diagnosis files found. Running analysis first...'));
+    const diagPath = await flowRunAnalysis();
+    if (!diagPath) return;
+    diagnosisPath = diagPath;
+  } else {
+    const choice = await select({
+      message: 'Select diagnosis to base proposal on:',
+      choices: [
+        ...diagFiles.map(f => ({ name: f, value: path.join(proposalsDir, f) })),
+        { name: '(run new analysis first)', value: '__new__' },
+      ],
+    });
+
+    if (choice === '__new__') {
+      const diagPath = await flowRunAnalysis();
+      if (!diagPath) return;
+      diagnosisPath = diagPath;
+    } else {
+      diagnosisPath = choice;
+    }
+  }
+
+  const { agent, model } = await selectAgentAndModel();
+
+  try {
+    const result = await generateImprovement({
+      diagnosisPath,
+      plan2codeRoot,
+      proposalsDir,
+      runsDir,
+      model,
+      agent,
+    });
+
+    console.log();
+    console.log(chalk.green(`✓ Proposal generated: ${result.proposal.proposal_id}`));
+    console.log(chalk.gray(`  Valid edits:   ${result.validEditCount}`));
+    console.log(chalk.gray(`  Invalid edits: ${result.invalidEditCount} (rejected)`));
+    console.log(chalk.gray(`  Saved to: ${result.proposalPath}`));
+
+    if (result.validEditCount > 0) {
+      const reviewNow = await confirm({
+        message: 'Review and apply edits now?',
+        default: true,
+      });
+
+      if (reviewNow) {
+        await reviewAndApply({
+          proposalPath: result.proposalPath,
+          plan2codeRoot,
+          proposalsDir,
+        });
+      }
+    }
+  } catch (err) {
+    console.error(chalk.red(`Proposal generation failed: ${err instanceof Error ? err.message : String(err)}`));
+  }
+}
+
+// ── Flow: Review and apply proposal ──────────────────────────────────────────
+
+async function flowReviewAndApply(): Promise<void> {
+  console.log();
+  console.log(chalk.bold.cyan('── Review and Apply a Proposal ──'));
+
+  const { proposalsDir } = getMetricsDirs();
+  const plan2codeRoot = detectPlan2CodeRoot() ?? process.cwd();
+
+  if (!fs.existsSync(proposalsDir)) {
+    console.log(chalk.yellow('No proposals directory found. Generate a proposal first.'));
+    return;
+  }
+
+  const proposalFiles = fs.readdirSync(proposalsDir)
+    .filter(f => /^prop-\d+\.json$/.test(f))
+    .sort()
+    .reverse(); // most recent first
+
+  if (proposalFiles.length === 0) {
+    console.log(chalk.yellow('No proposal files found. Generate a proposal first.'));
+    return;
+  }
+
+  const chosen = await select({
+    message: 'Select proposal to review:',
+    choices: proposalFiles.map(f => {
+      try {
+        const p = JSON.parse(fs.readFileSync(path.join(proposalsDir, f), 'utf8'));
+        const label = `${f}  [${p.status}]  ${p.proposals?.length ?? 0} edits`;
+        return { name: label, value: path.join(proposalsDir, f) };
+      } catch {
+        return { name: f, value: path.join(proposalsDir, f) };
+      }
+    }),
+  });
+
+  await reviewAndApply({
+    proposalPath: chosen,
+    plan2codeRoot,
+    proposalsDir,
+  });
+}
+
+// ── Main menu ─────────────────────────────────────────────────────────────────
+
+export async function runCLI(): Promise<void> {
+  console.log();
+  console.log(chalk.bold.white('plan2code-metrics'));
+  console.log(chalk.gray('Recursive self-improvement toolchain for plan2code contributors'));
+  console.log();
+
+  // Check if we're in (or near) a plan2code repo
+  const plan2codeRoot = detectPlan2CodeRoot();
+  if (!plan2codeRoot) {
+    console.log(chalk.yellow('⚠ Could not detect plan2code repository (src/plan2code-*.md not found nearby).'));
+    console.log(chalk.gray('  Prompt version hashing and analysis will be limited.'));
+    console.log();
+  } else {
+    const version = detectPlan2CodeVersion(plan2codeRoot);
+    console.log(chalk.gray(`plan2code root: ${plan2codeRoot}  (v${version})`));
+    console.log();
+  }
+
+  let continueLoop = true;
+  while (continueLoop) {
+    const action = await select({
+      message: 'What would you like to do?',
+      choices: [
+        { name: 'Collect metrics for a completed project', value: 'collect' },
+        { name: 'Import run data from another project', value: 'import' },
+        { name: 'View metrics status and history', value: 'view' },
+        { name: 'Run analysis (diagnose weak steps)', value: 'analyze' },
+        { name: 'Generate improvement proposal', value: 'propose' },
+        { name: 'Review and apply a proposal', value: 'apply' },
+        { name: 'Exit', value: 'exit' },
+      ],
+    });
+
+    switch (action) {
+      case 'collect':
+        await flowCollect();
+        break;
+      case 'import':
+        await flowImport();
+        break;
+      case 'view':
+        await flowViewStatus();
+        break;
+      case 'analyze':
+        await flowRunAnalysis();
+        break;
+      case 'propose':
+        await flowGenerateProposal();
+        break;
+      case 'apply':
+        await flowReviewAndApply();
+        break;
+      case 'exit':
+        continueLoop = false;
+        break;
+    }
+
+    if (continueLoop && action !== 'exit') {
+      console.log();
+    }
+  }
+
+  console.log(chalk.gray('Goodbye.'));
+}

plan2code-metrics/src/collector.ts

@@ -0,0 +1,520 @@
+/**
+ * collector.ts
+ * Reads finished project artifacts and writes a RunMetrics JSON file.
+ * Zero dependency on plan2code-loop internals — reads files directly.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import type {
+  RunMetrics,
+  PromptVersions,
+  Step1PlanMetrics,
+  Step2DocumentMetrics,
+  Step3ImplementMetrics,
+  Step4FinalizeMetrics,
+  UserFeedback,
+} from './types.js';
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function sha256File(filePath: string): string {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return 'sha256:' + crypto.createHash('sha256').update(content).digest('hex');
+  } catch {
+    return 'sha256:missing';
+  }
+}
+
+function readFileSafe(filePath: string): string | null {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+function generateRunId(): string {
+  const now = new Date();
+  const ts = now.toISOString().replace(/[-:T]/g, '').slice(0, 14);
+  const rand = crypto.randomBytes(2).toString('hex');
+  return `run-${ts.slice(0, 8)}-${ts.slice(8, 14)}-${rand}`;
+}
+
+// ── Prompt version hashing ────────────────────────────────────────────────────
+
+export function collectPromptVersions(plan2codeRoot: string): PromptVersions {
+  const srcDir = path.join(plan2codeRoot, 'src');
+  return {
+    plan:        sha256File(path.join(srcDir, 'plan2code-1--plan.md')),
+    revise_plan: sha256File(path.join(srcDir, 'plan2code-1b--revise-plan.md')),
+    document:    sha256File(path.join(srcDir, 'plan2code-2--document.md')),
+    implement:   sha256File(path.join(srcDir, 'plan2code-3--implement.md')),
+    finalize:    sha256File(path.join(srcDir, 'plan2code-4--finalize.md')),
+    init:        sha256File(path.join(srcDir, 'plan2code---init.md')),
+    init_update: sha256File(path.join(srcDir, 'plan2code---init-update.md')),
+    quick_task:  sha256File(path.join(srcDir, 'plan2code---quick-task.md')),
+  };
+}
+
+// ── Step 1: Plan ──────────────────────────────────────────────────────────────
+
+export function collectStep1(specDir: string): Step1PlanMetrics {
+  // Find PLAN-DRAFT-*.md files
+  let draftFiles: string[] = [];
+  let convFiles: string[] = [];
+  try {
+    const files = fs.readdirSync(specDir);
+    draftFiles = files
+      .filter(f => f.startsWith('PLAN-DRAFT-') && f.endsWith('.md'))
+      .map(f => path.join(specDir, f));
+    convFiles = files
+      .filter(f => f.startsWith('PLAN-CONVERSATION-') && f.endsWith('.md'))
+      .map(f => path.join(specDir, f));
+  } catch {
+    return { present: false, final_confidence: null, confidence_breakdown: null,
+      clarification_rounds: null, tech_stack_revision_rounds: null,
+      verification_gaps_found: null, functional_requirements_count: null,
+      non_functional_requirements_count: null, risk_count: null, phase_count: null };
+  }
+
+  if (draftFiles.length === 0) {
+    return { present: false, final_confidence: null, confidence_breakdown: null,
+      clarification_rounds: null, tech_stack_revision_rounds: null,
+      verification_gaps_found: null, functional_requirements_count: null,
+      non_functional_requirements_count: null, risk_count: null, phase_count: null };
+  }
+
+  // Use the latest draft file
+  draftFiles.sort();
+  const latestDraft = readFileSafe(draftFiles[draftFiles.length - 1]) ?? '';
+
+  // Parse "Confidence: XX%" — look for overall or total confidence
+  let finalConfidence: number | null = null;
+  const confMatch = latestDraft.match(/(?:Overall|Final|Total)?\s*[Cc]onfidence[:\s]+(\d{1,3})%/);
+  if (confMatch) {
+    finalConfidence = parseInt(confMatch[1], 10);
+  } else {
+    // Try table format: | Confidence | 92 |
+    const tableMatch = latestDraft.match(/[|]\s*[Cc]onfidence\s*[|]\s*(\d{1,3})/);
+    if (tableMatch) finalConfidence = parseInt(tableMatch[1], 10);
+  }
+
+  // Confidence breakdown (requirements, feasibility, integration, risk)
+  let confidenceBreakdown: Step1PlanMetrics['confidence_breakdown'] = null;
+  const reqMatch = latestDraft.match(/[Rr]equirements?[:\s|]+(\d{1,2})/);
+  const feasMatch = latestDraft.match(/[Ff]easibility[:\s|]+(\d{1,2})/);
+  const intMatch = latestDraft.match(/[Ii]ntegration[:\s|]+(\d{1,2})/);
+  const riskMatch = latestDraft.match(/[Rr]isk[:\s|]+(\d{1,2})/);
+  if (reqMatch || feasMatch || intMatch || riskMatch) {
+    confidenceBreakdown = {
+      requirements: reqMatch ? parseInt(reqMatch[1], 10) : null,
+      feasibility:  feasMatch ? parseInt(feasMatch[1], 10) : null,
+      integration:  intMatch ? parseInt(intMatch[1], 10) : null,
+      risk:         riskMatch ? parseInt(riskMatch[1], 10) : null,
+    };
+  }
+
+  // Count ### FR- / ### NFR- headings
+  const frCount = (latestDraft.match(/###\s+FR-/g) ?? []).length;
+  const nfrCount = (latestDraft.match(/###\s+NFR-/g) ?? []).length;
+
+  // Count risk table rows (lines starting with | that contain risk-level keywords)
+  const riskRows = latestDraft.match(/^\s*[|][^|]*(?:High|Medium|Low|Critical)[^|]*[|]/gm) ?? [];
+  const riskCount = riskRows.length || null;
+
+  // Count ## Phase headings
+  const phaseCount = (latestDraft.match(/^##\s+Phase\s+\d/gm) ?? []).length || null;
+
+  // Clarification rounds from conversation file
+  let clarificationRounds: number | null = null;
+  let techStackRevisions: number | null = null;
+  let verificationGaps: number | null = null;
+
+  if (convFiles.length > 0) {
+    convFiles.sort();
+    const latestConv = readFileSafe(convFiles[convFiles.length - 1]) ?? '';
+    // Count heading repetitions as clarification rounds (## Clarification or ## Round)
+    const clarRounds = (latestConv.match(/^##\s+(?:Clarification|Round)\s+\d/gm) ?? []).length;
+    clarificationRounds = clarRounds || null;
+    // Tech stack revision rounds
+    const techRounds = (latestConv.match(/^##\s+(?:Tech\s+Stack|Technology)\s+Revision/gmi) ?? []).length;
+    techStackRevisions = techRounds || null;
+    // Verification gaps found
+    const gapMatches = latestConv.match(/(?:verification\s+gap|gap\s+found|missing\s+requirement)/gi) ?? [];
+    verificationGaps = gapMatches.length || null;
+  }
+
+  return {
+    present: true,
+    final_confidence: finalConfidence,
+    confidence_breakdown: confidenceBreakdown,
+    clarification_rounds: clarificationRounds,
+    tech_stack_revision_rounds: techStackRevisions,
+    verification_gaps_found: verificationGaps,
+    functional_requirements_count: frCount || null,
+    non_functional_requirements_count: nfrCount || null,
+    risk_count: riskCount,
+    phase_count: phaseCount,
+  };
+}
+
+// ── Step 2: Document ──────────────────────────────────────────────────────────
+
+export function collectStep2(specDir: string): Step2DocumentMetrics {
+  const overviewPath = path.join(specDir, 'overview.md');
+  const overview = readFileSafe(overviewPath);
+
+  if (!overview) {
+    return { present: false, total_tasks: null, tasks_per_phase: null,
+      phase_count: null, parallel_groups_identified: null,
+      requirement_coverage_percent: null, verification_items_added: null };
+  }
+
+  // Count all checkbox tasks: - [ ], - [x], - [!], - [/]
+  const allTasks = (overview.match(/^\s*-\s+\[[ x!/?]\]/gm) ?? []).length;
+
+  // Detect Parallel Execution Groups table
+  const parallelGroups = (overview.match(/Parallel\s+Execution\s+Group/gi) ?? []).length;
+
+  // Count phase files
+  let phaseCount = 0;
+  let tasksPerPhase: number[] = [];
+  try {
+    const files = fs.readdirSync(specDir);
+    const phaseFiles = files
+      .filter(f => /^phase-\d+\.md$/i.test(f))
+      .sort();
+    phaseCount = phaseFiles.length;
+    for (const pf of phaseFiles) {
+      const content = readFileSafe(path.join(specDir, pf)) ?? '';
+      const count = (content.match(/^\s*-\s+\[[ x!/?]\]/gm) ?? []).length;
+      tasksPerPhase.push(count);
+    }
+  } catch {
+    // leave empty
+  }
+
+  // Requirement coverage: look for coverage percentage in overview
+  let reqCoverage: number | null = null;
+  const covMatch = overview.match(/[Cc]overage[:\s]+(\d{1,3})%/);
+  if (covMatch) reqCoverage = parseInt(covMatch[1], 10);
+
+  // Verification items added (look for verification checklist items)
+  const verifItems = (overview.match(/(?:verify|verification|test|check):\s*\[[ x]\]/gi) ?? []).length;
+
+  return {
+    present: true,
+    total_tasks: allTasks || null,
+    tasks_per_phase: tasksPerPhase.length > 0 ? tasksPerPhase : null,
+    phase_count: phaseCount || null,
+    parallel_groups_identified: parallelGroups || 0,
+    requirement_coverage_percent: reqCoverage,
+    verification_items_added: verifItems || null,
+  };
+}
+
+// ── Step 3: Implement (loop data) ─────────────────────────────────────────────
+
+export function collectStep3(specDir: string): Step3ImplementMetrics {
+  const loopDir = path.join(specDir, '.plan2code-loop');
+  const iterLogPath = path.join(loopDir, 'iteration.log');
+  const configPath = path.join(loopDir, 'config.json');
+
+  if (!fs.existsSync(loopDir)) {
+    return { present: true, used_loop_mode: false, loop_mode: null,
+      task_completion_rate: null, tasks_completed: null, tasks_total: null,
+      blocker_count: null, blocker_categories: null, total_iterations: null,
+      avg_iteration_duration_ms: null, exit_code_distribution: null,
+      completion_marker_success_rate: null };
+  }
+
+  // Parse config.json for loop mode
+  let loopMode: 'task' | 'phase' | null = null;
+  const configContent = readFileSafe(configPath);
+  if (configContent) {
+    try {
+      const config = JSON.parse(configContent);
+      loopMode = config.loopMode ?? null;
+    } catch {
+      // ignore
+    }
+  }
+
+  // Parse NDJSON iteration.log
+  const iterLogContent = readFileSafe(iterLogPath);
+  if (!iterLogContent) {
+    return { present: true, used_loop_mode: true, loop_mode: loopMode,
+      task_completion_rate: null, tasks_completed: null, tasks_total: null,
+      blocker_count: null, blocker_categories: null, total_iterations: null,
+      avg_iteration_duration_ms: null, exit_code_distribution: null,
+      completion_marker_success_rate: null };
+  }
+
+  interface IterEntry {
+    iteration: number;
+    timestamp: string;
+    duration: number;
+    exitCode: number;
+    status: string;
+    completionMarker?: string;
+  }
+
+  const entries: IterEntry[] = [];
+  for (const line of iterLogContent.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      entries.push(JSON.parse(trimmed));
+    } catch {
+      // skip malformed lines
+    }
+  }
+
+  const totalIterations = entries.length;
+  if (totalIterations === 0) {
+    return { present: true, used_loop_mode: true, loop_mode: loopMode,
+      task_completion_rate: null, tasks_completed: null, tasks_total: null,
+      blocker_count: null, blocker_categories: null, total_iterations: 0,
+      avg_iteration_duration_ms: null, exit_code_distribution: null,
+      completion_marker_success_rate: null };
+  }
+
+  // Exit code distribution
+  const exitCodes: Record<string, number> = {};
+  for (const e of entries) {
+    const key = String(e.exitCode ?? 'other');
+    exitCodes[key] = (exitCodes[key] ?? 0) + 1;
+  }
+
+  // Average duration
+  const durations = entries.map(e => e.duration).filter(d => d != null && d > 0);
+  const avgDuration = durations.length > 0
+    ? Math.round(durations.reduce((a, b) => a + b, 0) / durations.length)
+    : null;
+
+  // Completion markers
+  const markerEntries = entries.filter(e => e.completionMarker && e.completionMarker.trim() !== '');
+  const taskCompleteEntries = markerEntries.filter(e =>
+    e.completionMarker?.startsWith('TASK_COMPLETE')
+  );
+  const blockedEntries = markerEntries.filter(e =>
+    e.completionMarker?.startsWith('TASK_BLOCKED')
+  );
+
+  // Completion marker success rate: entries where a valid marker was detected vs total
+  const validMarkerCount = markerEntries.length;
+  const markerSuccessRate = totalIterations > 0
+    ? validMarkerCount / totalIterations
+    : null;
+
+  // Task counts from markers (used for completion_marker_success_rate)
+  const blockerCount = blockedEntries.length;
+
+  // Blocker categories (parse from "TASK_BLOCKED: X.Y - reason")
+  const blockerCategories: string[] = [];
+  for (const e of blockedEntries) {
+    const match = e.completionMarker?.match(/TASK_BLOCKED:\s*[\d.]+\s*-\s*(.+)/);
+    if (match) {
+      // Normalize to snake_case category
+      const reason = match[1].toLowerCase().replace(/\s+/g, '_').replace(/[^a-z0-9_]/g, '');
+      if (!blockerCategories.includes(reason)) {
+        blockerCategories.push(reason);
+      }
+    }
+  }
+
+  // Count tasks from overview.md checkboxes (consistent numerator and denominator)
+  const overviewPath = path.join(specDir, 'overview.md');
+  const overview = readFileSafe(overviewPath);
+  let tasksTotal: number | null = null;
+  let tasksCompleted: number | null = null;
+  if (overview) {
+    tasksTotal = (overview.match(/^\s*-\s+\[[ x!/?]\]/gm) ?? []).length || null;
+    tasksCompleted = (overview.match(/^\s*-\s+\[x\]/gm) ?? []).length || null;
+  }
+
+  const taskCompletionRate = tasksTotal && tasksTotal > 0 && tasksCompleted != null
+    ? tasksCompleted / tasksTotal
+    : null;
+
+  return {
+    present: true,
+    used_loop_mode: true,
+    loop_mode: loopMode,
+    task_completion_rate: taskCompletionRate,
+    tasks_completed: tasksCompleted || null,
+    tasks_total: tasksTotal,
+    blocker_count: blockerCount,
+    blocker_categories: blockerCategories.length > 0 ? blockerCategories : null,
+    total_iterations: totalIterations,
+    avg_iteration_duration_ms: avgDuration,
+    exit_code_distribution: exitCodes,
+    completion_marker_success_rate: markerSuccessRate,
+  };
+}
+
+// ── Step 4: Finalize ──────────────────────────────────────────────────────────
+
+export function collectStep4(specDir: string): Step4FinalizeMetrics {
+  // Check if spec was archived (specs--completed exists at parent level)
+  const specDirName = path.basename(specDir);
+  const parentDir = path.dirname(specDir);
+  const completedPath = path.join(parentDir, '..', 'specs--completed', specDirName);
+  const archivalSucceeded = fs.existsSync(completedPath);
+
+  // Read overview for completion metrics
+  const overviewPath = path.join(specDir, 'overview.md');
+
+  // If archived, try from archived location
+  const effectiveOverviewPath = archivalSucceeded
+    ? path.join(completedPath, 'overview.md')
+    : overviewPath;
+
+  const overview = readFileSafe(effectiveOverviewPath) ?? readFileSafe(overviewPath);
+  if (!overview) {
+    return { present: false, completion_rate_at_audit: null,
+      verification_failures_found: null, documentation_updates_needed: null,
+      archival_succeeded: archivalSucceeded };
+  }
+
+  // Completion rate: completed tasks / total tasks
+  const totalTasks = (overview.match(/^\s*-\s+\[[ x!/?]\]/gm) ?? []).length;
+  const completedTasks = (overview.match(/^\s*-\s+\[x\]/gm) ?? []).length;
+  const completionRate = totalTasks > 0 ? completedTasks / totalTasks : null;
+
+  // Verification failures: look for [!] tasks or "verification failed" text
+  const blockedTasks = (overview.match(/^\s*-\s+\[!\]/gm) ?? []).length;
+
+  // Documentation updates needed (look for TODO or "update" markers)
+  const docUpdates = (overview.match(/(?:TODO|FIXME|update\s+(?:README|CHANGELOG|docs))/gi) ?? []).length;
+
+  return {
+    present: true,
+    completion_rate_at_audit: completionRate,
+    verification_failures_found: blockedTasks || 0,
+    documentation_updates_needed: docUpdates || null,
+    archival_succeeded: archivalSucceeded,
+  };
+}
+
+// ── User Feedback ─────────────────────────────────────────────────────────
+
+export function collectUserFeedback(specDir: string): UserFeedback | null {
+  // Try both active and archived locations for overview.md
+  const overviewPath = path.join(specDir, 'overview.md');
+  const specDirName = path.basename(specDir);
+  const parentDir = path.dirname(specDir);
+  const completedPath = path.join(parentDir, '..', 'specs--completed', specDirName, 'overview.md');
+
+  const overview = readFileSafe(overviewPath) ?? readFileSafe(completedPath);
+  if (!overview) return null;
+
+  // Look for ## User Feedback section with a markdown table
+  const feedbackMatch = overview.match(
+    /## User Feedback\s*\n\s*\|[^\n]*\|\s*\n\s*\|[-| ]+\|\s*\n([\s\S]*?)(?=\n##\s|\n*$)/
+  );
+  if (!feedbackMatch) return null;
+
+  const tableBody = feedbackMatch[1];
+
+  // Parse table rows: | Field | Value |
+  // Use regex to split only on unescaped pipes, preserving whitespace in values
+  const rows = tableBody.split('\n').filter(l => l.trim().startsWith('|'));
+  const fields: Record<string, string> = {};
+  for (const row of rows) {
+    // Split on unescaped pipes (not preceded by backslash)
+    const cells = row.split(/(?<!\\)\|/).map(c => c.trim()).filter(c => c.length > 0);
+    if (cells.length >= 2) {
+      const value = cells.slice(1).join('|').replace(/\\\|/g, '|');
+      fields[cells[0].toLowerCase()] = value;
+    }
+  }
+
+  const rating = parseInt(fields['rating'] ?? '', 10);
+  if (isNaN(rating) || rating < 1 || rating > 10) return null;
+
+  return {
+    overall_rating: rating,
+    rating_reason: fields['reason'] ?? '',
+    what_went_well: fields['went well'] ?? '',
+    what_went_poorly: fields['went poorly'] ?? '',
+  };
+}
+
+// ── Main collector ────────────────────────────────────────────────────────────
+
+export interface CollectorOptions {
+  specDir: string;           // Path to the spec directory (specs/<feature-name>)
+  projectName: string;       // Human-readable project name
+  plan2codeRoot: string;     // Path to the plan2code repo (for prompt hashing)
+  plan2codeVersion: string;  // e.g. "1.7.0"
+  outputDir: string;         // Where to write <run-id>.json
+}
+
+export async function collectRun(opts: CollectorOptions): Promise<RunMetrics> {
+  const {
+    specDir,
+    projectName,
+    plan2codeRoot,
+    plan2codeVersion,
+    outputDir,
+  } = opts;
+
+  const runId = generateRunId();
+
+  // Get started_at / completed_at from spec directory mtime / iteration.log
+  let startedAt: string | null = null;
+  let completedAt: string | null = null;
+  try {
+    const stat = fs.statSync(specDir);
+    startedAt = stat.birthtime.toISOString();
+    completedAt = stat.mtime.toISOString();
+  } catch {
+    // leave null
+  }
+
+  // Try to get started_at from earliest iteration log entry
+  const loopDir = path.join(specDir, '.plan2code-loop');
+  const iterLogPath = path.join(loopDir, 'iteration.log');
+  const iterLogContent = readFileSafe(iterLogPath);
+  if (iterLogContent) {
+    const lines = iterLogContent.split('\n').filter(l => l.trim());
+    if (lines.length > 0) {
+      try {
+        const first = JSON.parse(lines[0]);
+        if (first.timestamp) startedAt = first.timestamp;
+      } catch { /* ignore */ }
+      try {
+        const last = JSON.parse(lines[lines.length - 1]);
+        if (last.timestamp) completedAt = last.timestamp;
+      } catch { /* ignore */ }
+    }
+  }
+
+  const metrics: RunMetrics = {
+    schema_version: '1.0',
+    run_id: runId,
+    plan2code_version: plan2codeVersion,
+    prompt_versions: collectPromptVersions(plan2codeRoot),
+    project: {
+      name: projectName,
+      started_at: startedAt,
+      completed_at: completedAt,
+    },
+    step1_plan: collectStep1(specDir),
+    step2_document: collectStep2(specDir),
+    step3_implement: collectStep3(specDir),
+    step4_finalize: collectStep4(specDir),
+    user_feedback: collectUserFeedback(specDir),
+  };
+
+  // Write to output dir
+  fs.mkdirSync(outputDir, { recursive: true });
+  const outPath = path.join(outputDir, `${runId}.json`);
+  fs.writeFileSync(outPath, JSON.stringify(metrics, null, 2), 'utf8');
+
+  return metrics;
+}

plan2code-metrics/src/improver.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect } from 'vitest';
+import { validateEdit, parseProposalFromResponse } from './improver.js';
+import type { PromptEdit } from './types.js';
+
+// ── Shared fixtures ───────────────────────────────────────────────────────────
+
+const PROMPT_CONTENTS: Record<string, string> = {
+  'plan2code-1--plan.md': 'This is the plan prompt content. It has some text here.',
+  'plan2code-2--document.md': 'Document prompt with repeated text. repeated text. Done.',
+  'plan2code-3--implement.md': 'Implement prompt content.',
+};
+
+function makeEdit(overrides: Partial<PromptEdit> = {}): PromptEdit {
+  return {
+    file: 'plan2code-1--plan.md',
+    rationale: 'test rationale',
+    expected_metric_impact: 'test impact',
+    char_count_before: PROMPT_CONTENTS['plan2code-1--plan.md'].length,
+    char_count_after: PROMPT_CONTENTS['plan2code-1--plan.md'].length,
+    char_count_delta: 0,
+    old_text: 'some text',
+    new_text: 'better text',
+    ...overrides,
+  };
+}
+
+// ── validateEdit() ────────────────────────────────────────────────────────────
+
+describe('validateEdit', () => {
+  it('valid edit passes with no errors', () => {
+    const result = validateEdit(makeEdit(), PROMPT_CONTENTS);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('rejects path traversal (../ in file path)', () => {
+    const result = validateEdit(makeEdit({ file: '../etc/passwd' }), PROMPT_CONTENTS);
+    expect(result.valid).toBe(false);
+    expect(result.errors[0]).toMatch(/path traversal/i);
+  });
+
+  it('rejects absolute paths', () => {
+    const result = validateEdit(makeEdit({ file: '/etc/passwd' }), PROMPT_CONTENTS);
+    expect(result.valid).toBe(false);
+    expect(result.errors[0]).toMatch(/path traversal|absolute/i);
+  });
+
+  it('errors when file not found in promptContents', () => {
+    const result = validateEdit(makeEdit({ file: 'nonexistent.md' }), PROMPT_CONTENTS);
+    expect(result.valid).toBe(false);
+    expect(result.errors[0]).toMatch(/not found/i);
+  });
+
+  it('errors when old_text not found in file content', () => {
+    const result = validateEdit(makeEdit({ old_text: 'hallucinated text' }), PROMPT_CONTENTS);
+    expect(result.valid).toBe(false);
+    expect(result.errors[0]).toMatch(/not found verbatim/i);
+  });
+
+  it('warns when old_text appears multiple times', () => {
+    const edit = makeEdit({
+      file: 'plan2code-2--document.md',
+      old_text: 'repeated text',
+      char_count_before: PROMPT_CONTENTS['plan2code-2--document.md'].length,
+      char_count_after: PROMPT_CONTENTS['plan2code-2--document.md'].length,
+    });
+    const result = validateEdit(edit, PROMPT_CONTENTS);
+    expect(result.valid).toBe(true);
+    expect(result.warnings.some(w => /appears.*times/i.test(w))).toBe(true);
+  });
+
+  it('errors when edit would exceed 11,000 char limit', () => {
+    const bigText = 'x'.repeat(12_000);
+    const edit = makeEdit({ new_text: bigText });
+    const result = validateEdit(edit, PROMPT_CONTENTS);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => /exceed.*11.?000/i.test(e))).toBe(true);
+  });
+
+  it('warns when reported char counts diverge from actual (>10 chars off)', () => {
+    const edit = makeEdit({
+      char_count_before: 999,
+      char_count_after: 999,
+    });
+    const result = validateEdit(edit, PROMPT_CONTENTS);
+    expect(result.valid).toBe(true);
+    expect(result.warnings.some(w => /char_count_before.*differs/i.test(w))).toBe(true);
+  });
+});
+
+// ── parseProposalFromResponse() ───────────────────────────────────────────────
+
+describe('parseProposalFromResponse', () => {
+  const sampleEdit = {
+    file: 'test.md',
+    rationale: 'r',
+    expected_metric_impact: 'e',
+    char_count_before: 100,
+    char_count_after: 110,
+    char_count_delta: 10,
+    old_text: 'old',
+    new_text: 'new',
+  };
+
+  it('parses JSON from markdown code block (```json ... ```)', () => {
+    const response = `Here is my proposal:\n\n\`\`\`json\n${JSON.stringify([sampleEdit])}\n\`\`\`\n\nDone.`;
+    const result = parseProposalFromResponse(response);
+    expect(result).toHaveLength(1);
+    expect(result![0].file).toBe('test.md');
+  });
+
+  it('parses JSON from bare code block (``` ... ```)', () => {
+    const response = `Proposal:\n\n\`\`\`\n${JSON.stringify([sampleEdit])}\n\`\`\``;
+    const result = parseProposalFromResponse(response);
+    expect(result).toHaveLength(1);
+    expect(result![0].old_text).toBe('old');
+  });
+
+  it('parses bare JSON array with old_text field', () => {
+    const response = `Some preamble\n${JSON.stringify([sampleEdit])}\nSome postamble`;
+    const result = parseProposalFromResponse(response);
+    expect(result).toHaveLength(1);
+  });
+
+  it('returns null for non-JSON response', () => {
+    const result = parseProposalFromResponse('No changes needed at this time.');
+    expect(result).toBeNull();
+  });
+
+  it('returns null for malformed JSON', () => {
+    const result = parseProposalFromResponse('```json\n{broken json]\n```');
+    expect(result).toBeNull();
+  });
+
+  it('returns null for empty response', () => {
+    const result = parseProposalFromResponse('');
+    expect(result).toBeNull();
+  });
+});

plan2code-metrics/src/improver.ts

@@ -0,0 +1,288 @@
+/**
+ * improver.ts
+ * Reads diagnosis + prompt files, invokes AI, parses PromptEdit[] from response.
+ * Validates: old_text verbatim match, char count limits.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import type { PromptEdit, PromptProposal } from './types.js';
+import { invokeLLM, type AgentType } from './invoke-llm.js';
+
+const CHAR_LIMIT = 11_000;
+const IMPROVE_PROMPT_PATH = new URL('../src/prompts/improve.md', import.meta.url).pathname
+  .replace(/^\/([A-Za-z]:)/, '$1'); // Fix Windows path
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function interpolate(template: string, vars: Record<string, string>): string {
+  let result = template;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replaceAll(`{{${key}}}`, value);
+  }
+  return result;
+}
+
+function generateProposalId(): string {
+  const now = new Date();
+  const ts = now.toISOString().replace(/[-:T.Z]/g, '').slice(0, 14);
+  return `prop-${ts}`;
+}
+
+function readPromptFiles(plan2codeRoot: string): Record<string, string> {
+  const srcDir = path.join(plan2codeRoot, 'src');
+  const promptFiles = [
+    'plan2code-1--plan.md',
+    'plan2code-1b--revise-plan.md',
+    'plan2code-2--document.md',
+    'plan2code-3--implement.md',
+    'plan2code-4--finalize.md',
+    'plan2code---init.md',
+    'plan2code---init-update.md',
+    'plan2code---quick-task.md',
+  ];
+
+  const contents: Record<string, string> = {};
+  for (const file of promptFiles) {
+    try {
+      contents[file] = fs.readFileSync(path.join(srcDir, file), 'utf8');
+    } catch {
+      contents[file] = '';
+    }
+  }
+  return contents;
+}
+
+// ── Edit validation ───────────────────────────────────────────────────────────
+
+export interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+}
+
+export function validateEdit(
+  edit: PromptEdit,
+  promptContents: Record<string, string>,
+): ValidationResult {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  // Reject path traversal attempts
+  if (edit.file.includes('..') || path.isAbsolute(edit.file)) {
+    errors.push(`Rejected: "${edit.file}" contains path traversal or absolute path.`);
+    return { valid: false, errors, warnings };
+  }
+
+  // Check target file exists
+  const fileContent = promptContents[edit.file];
+  if (fileContent === undefined) {
+    errors.push(`Target file "${edit.file}" not found. Valid files: ${Object.keys(promptContents).join(', ')}`);
+    return { valid: false, errors, warnings };
+  }
+
+  // Check old_text exists verbatim in the file
+  if (!fileContent.includes(edit.old_text)) {
+    errors.push(`old_text not found verbatim in "${edit.file}". The AI may have hallucinated text.`);
+  } else {
+    // Warn if old_text appears more than once (ambiguous match)
+    const occurrences = fileContent.split(edit.old_text).length - 1;
+    if (occurrences > 1) {
+      warnings.push(`old_text appears ${occurrences} times in "${edit.file}". Only the first occurrence will be replaced.`);
+    }
+  }
+
+  // Check char count after edit
+  const afterContent = fileContent.replace(edit.old_text, edit.new_text);
+  if (afterContent.length > CHAR_LIMIT) {
+    errors.push(`Edit would cause "${edit.file}" to exceed ${CHAR_LIMIT} char limit (would be ${afterContent.length} chars).`);
+  }
+
+  // Verify reported char counts match reality
+  const actualBefore = fileContent.length;
+  const actualAfter = afterContent.length;
+  if (Math.abs(edit.char_count_before - actualBefore) > 10) {
+    warnings.push(`Reported char_count_before (${edit.char_count_before}) differs from actual (${actualBefore}).`);
+  }
+  if (Math.abs(edit.char_count_after - actualAfter) > 10) {
+    warnings.push(`Reported char_count_after (${edit.char_count_after}) differs from actual (${actualAfter}).`);
+  }
+
+  return { valid: errors.length === 0, errors, warnings };
+}
+
+// ── AI response parsing ───────────────────────────────────────────────────────
+
+export function parseProposalFromResponse(response: string): PromptEdit[] | null {
+  // Look for JSON code block containing PromptEdit[]
+  const jsonBlockMatch = response.match(/```(?:json)?\s*(\[[\s\S]*?\])\s*```/);
+  if (!jsonBlockMatch) {
+    // Try bare JSON array
+    const bareMatch = response.match(/(\[[\s\S]*"old_text"[\s\S]*\])/);
+    if (!bareMatch) return null;
+    try {
+      return JSON.parse(bareMatch[1]) as PromptEdit[];
+    } catch {
+      return null;
+    }
+  }
+
+  try {
+    return JSON.parse(jsonBlockMatch[1]) as PromptEdit[];
+  } catch {
+    return null;
+  }
+}
+
+// ── Main improver ─────────────────────────────────────────────────────────────
+
+export interface ImproverOptions {
+  diagnosisPath: string;     // Path to diagnosis markdown file
+  plan2codeRoot: string;     // Path to plan2code repo root
+  proposalsDir: string;      // Where to save proposal JSON
+  runsDir: string;           // For tracking which runs this is based on
+  model?: string;
+  agent?: AgentType;         // Agent to use (default: claude-code)
+}
+
+export interface ImproverResult {
+  proposalPath: string;
+  proposal: PromptProposal;
+  validationResults: Array<{ edit: PromptEdit; result: ValidationResult }>;
+  validEditCount: number;
+  invalidEditCount: number;
+}
+
+export async function generateImprovement(opts: ImproverOptions): Promise<ImproverResult> {
+  const { diagnosisPath, plan2codeRoot, proposalsDir, runsDir, model = 'claude-opus-4-6', agent = 'claude-code' } = opts;
+
+  // Load diagnosis
+  let diagnosisContent: string;
+  try {
+    diagnosisContent = fs.readFileSync(diagnosisPath, 'utf8');
+  } catch {
+    throw new Error(`Could not read diagnosis file at ${diagnosisPath}`);
+  }
+
+  // Read prompt files
+  const promptContents = readPromptFiles(plan2codeRoot);
+  const srcDir = path.join(plan2codeRoot, 'src');
+
+  // Build char counts for each file
+  const charCounts = Object.entries(promptContents)
+    .map(([file, content]) => `| ${file} | ${content.length} | ${CHAR_LIMIT} | ${CHAR_LIMIT - content.length} headroom |`)
+    .join('\n');
+
+  const promptContentsStr = Object.entries(promptContents)
+    .map(([file, content]) => `## ${file} (${content.length} chars)\n\n${content}`)
+    .join('\n\n---\n\n');
+
+  // Load improve prompt template
+  let improveTemplate: string;
+  try {
+    improveTemplate = fs.readFileSync(IMPROVE_PROMPT_PATH, 'utf8');
+  } catch {
+    const altPath = path.join(process.cwd(), 'src', 'prompts', 'improve.md');
+    improveTemplate = fs.readFileSync(altPath, 'utf8');
+  }
+
+  const fullPrompt = interpolate(improveTemplate, {
+    diagnosisContent,
+    promptContents: promptContentsStr,
+    charCounts: `| File | Current Chars | Limit | Headroom |\n|------|--------------|-------|----------|\n${charCounts}`,
+  });
+
+  // Invoke Claude
+  console.log(`\nInvoking AI improvement proposal (model: ${model})...`);
+  console.log('This may take a minute...\n');
+
+  let aiResponse: string;
+  try {
+    aiResponse = await invokeLLM({
+      prompt: fullPrompt,
+      model,
+      agent,
+      timeout: 300_000,
+    });
+  } catch (err) {
+    throw new Error(`AI invocation failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+
+  // Parse edits
+  const rawEdits = parseProposalFromResponse(aiResponse);
+  if (!rawEdits || rawEdits.length === 0) {
+    throw new Error('Could not parse PromptEdit[] from AI response. The AI may not have produced a valid JSON block.');
+  }
+
+  // Enforce max edits per cycle
+  const MAX_EDITS = 5;
+  if (rawEdits.length > MAX_EDITS) {
+    console.warn(`\n⚠ AI generated ${rawEdits.length} edits (max is ${MAX_EDITS}). Truncating to first ${MAX_EDITS}.`);
+    rawEdits.length = MAX_EDITS;
+  }
+
+  // Validate each edit
+  const validationResults: ImproverResult['validationResults'] = [];
+  const validEdits: PromptEdit[] = [];
+
+  for (const edit of rawEdits) {
+    const result = validateEdit(edit, promptContents);
+    validationResults.push({ edit, result });
+
+    if (result.valid) {
+      // Compute accurate char counts
+      const fileContent = promptContents[edit.file] ?? '';
+      const afterContent = fileContent.replace(edit.old_text, edit.new_text);
+      edit.char_count_before = fileContent.length;
+      edit.char_count_after = afterContent.length;
+      edit.char_count_delta = afterContent.length - fileContent.length;
+      validEdits.push(edit);
+    } else {
+      console.warn(`\n⚠ Edit rejected for "${edit.file}":`);
+      for (const err of result.errors) {
+        console.warn(`  - ${err}`);
+      }
+    }
+
+    for (const warn of result.warnings) {
+      console.warn(`  Warning: ${warn}`);
+    }
+  }
+
+  // Get run IDs that contributed to this analysis
+  const runIds: string[] = [];
+  try {
+    const files = fs.readdirSync(runsDir)
+      .filter(f => f.startsWith('run-') && f.endsWith('.json'));
+    runIds.push(...files.map(f => f.replace('.json', '')));
+  } catch { /* no runs dir */ }
+
+  // Build proposal
+  const proposalId = generateProposalId();
+  const proposal: PromptProposal = {
+    proposal_id: proposalId,
+    created_at: new Date().toISOString(),
+    based_on_runs: runIds,
+    analyst_model: model,
+    proposals: validEdits,
+    status: 'pending',
+    diagnosis_file: path.basename(diagnosisPath),
+  };
+
+  // Save proposal JSON
+  fs.mkdirSync(proposalsDir, { recursive: true });
+  const proposalPath = path.join(proposalsDir, `${proposalId}.json`);
+  fs.writeFileSync(proposalPath, JSON.stringify(proposal, null, 2), 'utf8');
+
+  // Also save raw AI response alongside
+  const rawPath = path.join(proposalsDir, `${proposalId}-raw.md`);
+  fs.writeFileSync(rawPath, aiResponse, 'utf8');
+
+  return {
+    proposalPath,
+    proposal,
+    validationResults,
+    validEditCount: validEdits.length,
+    invalidEditCount: rawEdits.length - validEdits.length,
+  };
+}

plan2code-metrics/src/index.ts

@@ -0,0 +1,19 @@
+// Public API for plan2code-metrics
+export { collectRun, collectPromptVersions } from './collector.js';
+export { aggregate, loadAggregated, loadRunFiles, importRun } from './aggregator.js';
+export { runAnalysis } from './analyzer.js';
+export { generateImprovement, validateEdit, parseProposalFromResponse } from './improver.js';
+export { reviewAndApply } from './applier.js';
+export { invokeLLM, AGENTS } from './invoke-llm.js';
+export type { AgentType, InvokeLLMOptions } from './invoke-llm.js';
+export { runCLI } from './cli.js';
+export { METRIC_TARGETS } from './types.js';
+export type {
+  RunMetrics,
+  UserFeedback,
+  PromptVersions,
+  PromptEdit,
+  PromptProposal,
+  AggregatedMetrics,
+  CohortMetrics,
+} from './types.js';

plan2code-metrics/src/invoke-llm.ts

@@ -0,0 +1,98 @@
+/**
+ * invoke-llm.ts
+ * Unified LLM invocation for plan2code-metrics.
+ * Supports Claude Code (temp file → stdin) and Copilot CLI (stdin string).
+ * Mirrors the agent pattern from plan2code-loop.
+ */
+
+import { execa } from 'execa';
+import { writeFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+// ── Agent definitions ────────────────────────────────────────────────────────
+
+export type AgentType = 'claude-code' | 'copilot-cli';
+
+export interface AgentDef {
+  name: AgentType;
+  displayName: string;
+  command: string;
+  models: Array<{ value: string; label: string }>;
+}
+
+export const AGENTS: Record<AgentType, AgentDef> = {
+  'claude-code': {
+    name: 'claude-code',
+    displayName: 'Claude Code',
+    command: 'claude',
+    models: [
+      { value: 'claude-opus-4-6', label: 'Claude Opus 4.6 (Recommended)' },
+      { value: 'claude-sonnet-4-6', label: 'Claude Sonnet 4.6 (faster)' },
+    ],
+  },
+  'copilot-cli': {
+    name: 'copilot-cli',
+    displayName: 'GitHub Copilot CLI',
+    command: 'copilot',
+    models: [
+      { value: 'claude-sonnet-4', label: 'Claude Sonnet 4 (Default)' },
+      { value: 'claude-sonnet-4.5', label: 'Claude Sonnet 4.5' },
+      { value: 'claude-opus-4.5', label: 'Claude Opus 4.5' },
+      { value: 'gpt-5', label: 'GPT-5' },
+      { value: 'gpt-5-mini', label: 'GPT-5 Mini' },
+      { value: 'gemini-3-pro-preview', label: 'Gemini 3 Pro' },
+    ],
+  },
+};
+
+// ── Invocation ───────────────────────────────────────────────────────────────
+
+export interface InvokeLLMOptions {
+  prompt: string;
+  model: string;
+  agent: AgentType;
+  timeout?: number;
+}
+
+export async function invokeLLM(opts: InvokeLLMOptions): Promise<string> {
+  const { prompt, model, agent, timeout = 300_000 } = opts;
+  const def = AGENTS[agent];
+
+  if (agent === 'claude-code') {
+    // Write prompt to temp file — more reliable than stdin on Windows
+    const tempFile = join(tmpdir(), `plan2code-metrics-prompt-${Date.now()}.txt`);
+    writeFileSync(tempFile, prompt, 'utf-8');
+
+    try {
+      const args: string[] = [
+        '--print',
+        '--dangerously-skip-permissions',
+      ];
+      if (model) {
+        args.push('--model', model);
+      }
+
+      const result = await execa(def.command, args, {
+        inputFile: tempFile,
+        timeout,
+      });
+      return result.stdout;
+    } finally {
+      try { unlinkSync(tempFile); } catch { /* ignore cleanup errors */ }
+    }
+  } else {
+    // Copilot CLI: pipe prompt via stdin string
+    const args: string[] = [];
+    if (model) {
+      args.push('--model', model);
+    }
+    args.push('--allow-all-tools', '-s');
+
+    const result = await execa(def.command, args, {
+      input: prompt,
+      timeout,
+    });
+    return result.stdout;
+  }
+}

plan2code-metrics/src/prompts/analyze.md

@@ -0,0 +1,101 @@
+# PLAN2CODE METRICS ANALYSIS REQUEST
+
+You are a senior AI systems analyst specializing in prompt engineering quality assessment. Your role is to diagnose weaknesses in the plan2code workflow prompts by examining aggregated run metrics.
+
+**IMPORTANT:** Do NOT propose specific edits in this response. Diagnosis only. The improvement step is separate.
+
+---
+
+## Aggregated Run Metrics
+
+The following JSON contains metrics aggregated from real plan2code project runs, grouped by prompt "generation" (a cohort is identified by the SHA fingerprint of the src/plan2code-*.md prompt files at collection time):
+
+```json
+{{aggregatedMetrics}}
+```
+
+---
+
+## Current Prompt File Contents
+
+The following are the current contents of the plan2code workflow prompt files being evaluated:
+
+{{promptContents}}
+
+---
+
+## Metric Targets Reference
+
+| Metric | Target | Direction |
+|--------|--------|-----------|
+| avg_confidence (Step 1) | ≥ 90 | higher is better |
+| avg_clarification_rounds (Step 1) | ≤ 2.0 | lower is better |
+| avg_verification_gaps_found (Step 1) | ≤ 2.0 | lower is better |
+| avg_parallel_groups (Step 2) | ≥ 0.5 | higher is better |
+| avg_verification_items_added (Step 2) | ≤ 1.5 | lower is better |
+| avg_task_completion_rate (Step 3) | ≥ 0.95 | higher is better |
+| avg_blocker_count (Step 3) | ≤ 1.5 | lower is better |
+| avg_completion_marker_success_rate (Step 3) | ≥ 0.95 | higher is better |
+| avg_verification_failures_found (Step 4) | ≤ 1.0 | lower is better |
+| archival_success_rate (Step 4) | ≥ 0.99 | higher is better |
+| avg_user_rating (Feedback) | ≥ 7.0 | higher is better (1-10 scale, null if no feedback) |
+
+---
+
+## Analysis Instructions
+
+1. Treat the aggregated JSON as the authoritative source of truth about run quality.
+2. Compare each metric against its target. Calculate delta (actual − target).
+3. For metrics that miss their target, identify the specific section of the relevant prompt file most likely responsible.
+4. Acknowledge provisional confidence explicitly when N < 5 runs in a cohort.
+5. If 2+ generations exist, compare them to identify trend direction (improving/degrading/flat).
+6. Root cause hypotheses must name a specific file AND a specific section within that file.
+7. Do not invent metrics not present in the JSON. If a metric is null, note it as "insufficient data."
+
+---
+
+## Required Output Format
+
+Produce EXACTLY the following sections in order. Use these exact headers — they are parsed by machine:
+
+# PLAN2CODE METRICS DIAGNOSIS
+
+### Metrics Summary
+
+A markdown table with columns: Step | Metric | Target | Actual | Delta | Status (✓/✗/—)
+
+Include ALL metrics listed in the targets table. Use "—" for null values.
+
+### Step Health Assessment
+
+For each step (1–4), provide:
+- **Grade:** A–F
+- **Key signals:** 2–4 bullet points with specific metric values
+- **Assessment:** 1–2 sentence diagnosis
+
+### Root Cause Hypotheses
+
+Numbered list. For each underperforming metric:
+1. **Metric:** [metric name] | **Value:** [actual] | **Target:** [target]
+   - **File:** [plan2code-X--name.md]
+   - **Section:** [specific heading or section name]
+   - **Hypothesis:** [specific gap in the prompt that would explain the metric miss]
+   - **Confidence:** [High/Medium/Low] — [reason for confidence level]
+
+### Recommended Improvement Targets
+
+Ordered list (highest estimated impact first). For each:
+- **File:** [filename]
+- **Section:** [section name]
+- **Why:** [link to specific metric being addressed]
+- **Priority:** [High/Medium/Low]
+
+### Generation Comparison
+
+If 2+ generations exist: A comparison table showing before/after for each metric per generation, with trend arrows (▲/▼/→).
+
+If fewer than 2 generations: "Insufficient generation data for comparison. Current generation: [cohort_key], [N] runs."
+
+---
+
+End of analysis request.

plan2code-metrics/src/prompts/improve.md

@@ -0,0 +1,93 @@
+# PLAN2CODE PROMPT IMPROVEMENT REQUEST
+
+You are a senior AI prompt engineer. Your role is to propose surgical, targeted edits to the plan2code workflow prompt files based on a metrics diagnosis. You make precise, minimal changes — NOT rewrites.
+
+---
+
+## Metrics Diagnosis
+
+The following diagnosis was produced by the analysis step:
+
+{{diagnosisContent}}
+
+---
+
+## Current Prompt File Contents (with char counts)
+
+{{promptContents}}
+
+---
+
+## Character Count Status
+
+{{charCounts}}
+
+---
+
+## Hard Constraints — ALL must be satisfied:
+
+1. **Char limit:** Each target file MUST stay under 11,000 characters after your edit is applied. This is enforced by code — edits that violate it will be automatically rejected.
+2. **Maximum 5 edits per cycle.** Focus on the highest-impact changes only.
+3. **Each edit must cite a specific metric** in its `expected_metric_impact` field (e.g., "avg_completion_marker_success_rate", "avg_blocker_count").
+4. **`old_text` must be verbatim** from the file. Copy-paste exactly — include surrounding whitespace/newlines as they appear. Edits with mismatched old_text will be automatically rejected.
+5. **Do NOT modify Role sections** (lines starting with "You are" at the top of each file) or step headings (lines starting with `#`).
+6. **Each edit must be independently applicable** — no edit should depend on another edit being applied first.
+7. **Prefer additive guidance over deletions.** Adding clarifying instructions or examples is safer than removing existing text.
+8. **Do not change the overall structure** or flow of any prompt file.
+
+---
+
+## Edit Strategy Guidelines
+
+- Target the specific sections identified in "Recommended Improvement Targets" from the diagnosis.
+- For high `avg_clarification_rounds`: Add more upfront specification examples or decision criteria to Step 1.
+- For low `avg_completion_marker_success_rate`: Clarify or simplify the completion marker format in Step 3.
+- For high `avg_blocker_count`: Add blocker-recovery guidance or prerequisite check instructions.
+- For low `avg_confidence`: Strengthen the confidence calculation instructions with clearer rubrics.
+- For low `avg_parallel_groups`: Add explicit guidance for identifying parallel tasks in Step 2.
+- For low `avg_user_rating`: Review user feedback themes (what_went_well, what_went_poorly) for systemic issues.
+- Keep each `new_text` as short as possible while still addressing the root cause.
+
+---
+
+## Required Output Format
+
+Produce EXACTLY the following sections. The JSON block is parsed by machine — it must be syntactically valid.
+
+# PLAN2CODE PROMPT IMPROVEMENT PROPOSAL
+
+### Improvement Rationale
+
+2–3 paragraphs explaining:
+1. Which metrics are being addressed and why they matter
+2. The specific prompt gaps identified in the diagnosis that you are targeting
+3. Why the proposed edits are expected to improve those metrics
+
+### Proposed Edits
+
+```json
+[
+  {
+    "file": "plan2code-X--name.md",
+    "rationale": "One sentence explaining what this edit fixes",
+    "expected_metric_impact": "avg_metric_name: expected direction and magnitude",
+    "char_count_before": 0,
+    "char_count_after": 0,
+    "char_count_delta": 0,
+    "old_text": "exact verbatim text from the file to replace",
+    "new_text": "replacement text"
+  }
+]
+```
+
+Set `char_count_before`, `char_count_after`, and `char_count_delta` to your best estimate (the system will verify and correct these automatically).
+
+### Character Count Verification
+
+A table with columns: File | Before | Projected After | Delta | Limit | Status (✓/✗)
+
+Verify that NO file exceeds 11,000 characters after your proposed edits.
+
+---
+
+End of improvement request.

plan2code-metrics/src/types.ts

@@ -0,0 +1,175 @@
+// All TypeScript interfaces for plan2code-metrics
+
+export interface PromptVersions {
+  plan: string;           // sha256:... plan2code-1--plan.md
+  revise_plan: string;    // plan2code-1b--revise-plan.md
+  document: string;       // plan2code-2--document.md
+  implement: string;      // plan2code-3--implement.md
+  finalize: string;       // plan2code-4--finalize.md
+  init: string;           // plan2code---init.md
+  init_update: string;    // plan2code---init-update.md
+  quick_task: string;     // plan2code---quick-task.md
+}
+
+export interface Step1PlanMetrics {
+  present: boolean;
+  final_confidence: number | null;
+  confidence_breakdown: {
+    requirements: number | null;
+    feasibility: number | null;
+    integration: number | null;
+    risk: number | null;
+  } | null;
+  clarification_rounds: number | null;
+  tech_stack_revision_rounds: number | null;
+  verification_gaps_found: number | null;
+  functional_requirements_count: number | null;
+  non_functional_requirements_count: number | null;
+  risk_count: number | null;
+  phase_count: number | null;
+}
+
+export interface Step2DocumentMetrics {
+  present: boolean;
+  total_tasks: number | null;
+  tasks_per_phase: number[] | null;
+  phase_count: number | null;
+  parallel_groups_identified: number | null;
+  requirement_coverage_percent: number | null;
+  verification_items_added: number | null;
+}
+
+export interface Step3ImplementMetrics {
+  present: boolean;
+  used_loop_mode: boolean;
+  loop_mode: 'task' | 'phase' | null;
+  task_completion_rate: number | null;
+  tasks_completed: number | null;
+  tasks_total: number | null;
+  blocker_count: number | null;
+  blocker_categories: string[] | null;
+  total_iterations: number | null;
+  avg_iteration_duration_ms: number | null;
+  exit_code_distribution: Record<string, number> | null;
+  completion_marker_success_rate: number | null;
+}
+
+export interface Step4FinalizeMetrics {
+  present: boolean;
+  completion_rate_at_audit: number | null;
+  verification_failures_found: number | null;
+  documentation_updates_needed: number | null;
+  archival_succeeded: boolean | null;
+}
+
+export interface UserFeedback {
+  overall_rating: number;   // 1-10
+  rating_reason: string;
+  what_went_well: string;
+  what_went_poorly: string;
+}
+
+export interface RunMetrics {
+  schema_version: '1.0';
+  run_id: string;
+  plan2code_version: string;
+  prompt_versions: PromptVersions;
+  project: {
+    name: string;
+    started_at: string | null;
+    completed_at: string | null;
+  };
+  step1_plan: Step1PlanMetrics;
+  step2_document: Step2DocumentMetrics;
+  step3_implement: Step3ImplementMetrics;
+  step4_finalize: Step4FinalizeMetrics;
+  user_feedback: UserFeedback | null;
+}
+
+export interface PromptEdit {
+  file: string;
+  rationale: string;
+  expected_metric_impact: string;
+  char_count_before: number;
+  char_count_after: number;
+  char_count_delta: number;
+  old_text: string;
+  new_text: string;
+}
+
+export interface PromptProposal {
+  proposal_id: string;
+  created_at: string;
+  based_on_runs: string[];
+  analyst_model: string;
+  proposals: PromptEdit[];
+  status: 'pending' | 'applied' | 'rejected';
+  diagnosis_file: string | null;
+}
+
+// Aggregated metrics schema
+export interface CohortMetrics {
+  cohort_key: string;          // hash of sorted prompt_versions
+  prompt_versions: PromptVersions;
+  run_count: number;
+  run_ids: string[];
+  first_seen: string;
+  last_seen: string;
+
+  // Step 1 averages
+  avg_confidence: number | null;
+  avg_clarification_rounds: number | null;
+  avg_verification_gaps_found: number | null;
+  avg_functional_requirements_count: number | null;
+  avg_non_functional_requirements_count: number | null;
+  avg_risk_count: number | null;
+  avg_phase_count_step1: number | null;
+
+  // Step 2 averages
+  avg_total_tasks: number | null;
+  avg_phase_count_step2: number | null;
+  avg_parallel_groups: number | null;
+  avg_requirement_coverage_percent: number | null;
+  avg_verification_items_added: number | null;
+
+  // Step 3 averages (loop only)
+  loop_run_count: number;
+  avg_task_completion_rate: number | null;
+  avg_blocker_count: number | null;
+  avg_total_iterations: number | null;
+  avg_iteration_duration_ms: number | null;
+  avg_completion_marker_success_rate: number | null;
+
+  // Step 4 averages
+  avg_completion_rate_at_audit: number | null;
+  avg_verification_failures_found: number | null;
+  avg_documentation_updates_needed: number | null;
+  archival_success_rate: number | null;
+
+  // User feedback
+  avg_user_rating: number | null;
+  feedback_count: number;
+}
+
+export interface AggregatedMetrics {
+  schema_version: '1.0';
+  last_updated: string;
+  total_runs: number;
+  cohorts: CohortMetrics[];
+  current_cohort_key: string | null;
+}
+
+// Metric targets for health assessment
+export const METRIC_TARGETS = {
+  avg_confidence: { target: 90, direction: 'gte' as const },
+  avg_clarification_rounds: { target: 2.0, direction: 'lte' as const },
+  avg_verification_gaps_found: { target: 2.0, direction: 'lte' as const },
+  avg_parallel_groups: { target: 0.5, direction: 'gte' as const },
+  avg_verification_items_added: { target: 1.5, direction: 'lte' as const },
+  avg_task_completion_rate: { target: 0.95, direction: 'gte' as const },
+  avg_blocker_count: { target: 1.5, direction: 'lte' as const },
+  avg_completion_marker_success_rate: { target: 0.95, direction: 'gte' as const },
+  avg_verification_failures_found: { target: 1.0, direction: 'lte' as const },
+  archival_success_rate: { target: 0.99, direction: 'gte' as const },
+  avg_user_rating: { target: 7.0, direction: 'gte' as const },
+} as const;

plan2code-metrics/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

plan2code-metrics/tsup.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: {
+    'bin/plan2code-metrics': 'src/bin/plan2code-metrics.ts',
+    index: 'src/index.ts',
+  },
+  format: ['esm'],
+  dts: true,
+  clean: true,
+  sourcemap: true,
+  banner: {
+    js: '#!/usr/bin/env node',
+  },
+});

plan2code-metrics/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['src/**/*.test.ts'],
+  },
+});

scripts/validate-char-count.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const CHAR_LIMIT = 11000;
+const srcDir = path.join(__dirname, '..', 'src');
+
+const files = fs.readdirSync(srcDir)
+  .filter(f => f.startsWith('plan2code-') && f.endsWith('.md'))
+  .sort();
+
+const failures = [];
+
+for (const file of files) {
+  const filePath = path.join(srcDir, file);
+  const content = fs.readFileSync(filePath, 'utf8');
+  const charCount = content.length;
+  if (charCount > CHAR_LIMIT) {
+    failures.push({ file: path.join('src', file), charCount });
+  }
+}
+
+if (failures.length > 0) {
+  console.error('Character limit exceeded:');
+  console.error('');
+  for (const { file, charCount } of failures) {
+    console.error(`  ${file}: ${charCount} / ${CHAR_LIMIT} (+${charCount - CHAR_LIMIT} over)`);
+  }
+  console.error('');
+  console.error(`${failures.length} file(s) over the ${CHAR_LIMIT} character limit.`);
+  process.exit(1);
+}
+
+console.log(`All ${files.length} files under ${CHAR_LIMIT} characters \u2713`);
+process.exit(0);

src/plan2code---init-update.md

@@ -2,45 +2,44 @@
 
 Start all UPDATE AGENTS MODE responses with '🛞'
 
-This prompt guides AI coding agents through an interactive Q&A flow to update an existing `AGENTS.md` file with new learnings, commands, and project knowledge.
+```
+⋅
+    ╭───╮
+    │ ● │
+    │ ◡ │   Time to level up AGENTS.md!
+    ╰───╯
+```
+
+Interactive Q&A flow to update an existing `AGENTS.md` with new learnings and project knowledge.
 
 ---
 
 ## Step 1: Pre-flight Check
 
-First, check if `AGENTS.md` exists in the project root.
+Check if `AGENTS.md` exists in project root.
 
-**If AGENTS.md does NOT exist:**
+**If missing:** "No AGENTS.md found. Create one from scratch? I can analyze the codebase and generate an initial file." Stop and wait. If yes, use `plan2code---init.md` workflow.
-> "No AGENTS.md found in this project. Would you like to create one from scratch instead? I can analyze the codebase and generate an initial AGENTS.md file."
 
-Then stop and wait for user response. If they want to create one, use the `plan2code---init.md` workflow instead.
+**If exists:** Read and summarize:
+- Main sections (bullets)
+- Current line count
 
-**If AGENTS.md EXISTS:**
+Proceed to Step 2.
-Read the file and provide a brief summary:
-> "I found your AGENTS.md file. Here's what it currently covers:"
-> - List the main sections/topics (2-4 bullet points max)
-> - Note the current line count
-
-Then proceed to Step 2.
 
 ---
 
 ## Step 2: Context Detection
 
-Check if there is recent conversation context (work that was just completed in this session).
+Check for recent conversation context.
 
-**If recent work context exists:**
+**If recent work exists:** "I noticed we just worked on [description]. Worth documenting:"
-> "I noticed we just worked on [brief description of recent work]. I spotted a few things that might be worth documenting:"
+- [Insight #1]
-> - [Specific insight #1 - e.g., "The test runner requires the `--no-cache` flag for integration tests"]
+- [Insight #2]
-> - [Specific insight #2 - e.g., "The `UserService` depends on `AuthProvider` being initialized first"]
+- [Insight #3 if applicable]
-> - [Specific insight #3 if applicable]
->
-> "Would you like me to add any of these to AGENTS.md?"
 
-Wait for user response before proceeding.
+"Add any of these to AGENTS.md?"
 
-**If no recent work context:**
+**If no context:** Skip to Step 3.
-Skip directly to Step 3.
 
 ---
 
@@ -48,6 +47,14 @@ Skip directly to Step 3.
 
 Present the user with update options:
 
+> ```
+> ⋅
+>     ╭───╮ 
+>     │ ● │ 
+>     │ ~ │   What should we update?
+>     ╰───╯
+> ```
+>
 > "What would you like to add or update in AGENTS.md?"
 >
 > **Options:**
@@ -57,7 +64,8 @@ Present the user with update options:
 > - **4. Testing** - Test patterns, how to run specific tests, fixtures
 > - **5. Environment/Config** - Setup quirks, env variables, configuration
 > - **6. General Rules** - Coding conventions, style rules, project-specific practices
-> - **7. Something else** - Tell me what you'd like to add
+> - **7. Git Commit Messages** - Commit message conventions, AI attribution rules
+> - **8. Something else** - Tell me what you'd like to add
 >
 > You can also ask me to:
 > - **Review for corrections** - Check if any existing content is outdated or wrong
@@ -65,167 +73,167 @@ Present the user with update options:
 >
 > "Which would you like to do? (You can pick multiple, e.g., '1 and 3')"
 
-Wait for user response.
-
 ---
 
 ## Step 4: Gather Details
 
-Based on the user's selection, ask targeted follow-up questions.
+| Category | Questions |
-
+|----------|-----------|
-### If Commands:
+| Commands | Purpose? Flags? Prerequisites? |
-> "What command(s) would you like to document?"
+| Architecture | Components? Interactions? Pattern? |
-> - What does the command do?
+| Gotchas | What was unexpected? Workaround? |
-> - Are there important flags or variations?
+| Testing | Commands? Fixtures? Mocking? |
-> - Any prerequisites or context needed?
+| Environment | Local/CI/deploy? Env vars/files? |
-
+| Rules | Project-wide or specific? Why? |
-### If Architecture:
+| Git Commit Messages | Format? Attribution? Conventions? |
-> "What architectural insight did you learn?"
+| Other | "Tell me what to add." |
-> - Which components or modules are involved?
+| Review | Per section: "Still accurate?" |
-> - How do they interact?
+| Prune | Suggest trims, confirm before applying |
-> - Is this a pattern that repeats elsewhere in the codebase?
-
-### If Gotchas/Pitfalls:
-> "What's the gotcha you encountered?"
-> - What was the unexpected behavior?
-> - What's the correct approach or workaround?
-> - Where in the codebase does this apply?
-
-### If Testing:
-> "What testing knowledge should be captured?"
-> - Specific test commands or patterns?
-> - Test data or fixture setup?
-> - Mocking/stubbing approaches used in this project?
-
-### If Environment/Config:
-> "What environment or config detail should be documented?"
-> - Is this about local dev setup, CI, or deployment?
-> - Are there specific env variables or files involved?
-
-### If General Rules:
-> "What rule or convention should future agents follow?"
-> - Does this apply project-wide or to specific areas?
-> - Is this a "always do X" or "never do Y" type rule?
-> - Why does this rule exist? (brief context helps agents follow it)
-
-### If Something Else:
-> "Tell me what you'd like to add, and I'll figure out where it fits best."
-
-### If Review for Corrections:
-> "I'll walk through the current AGENTS.md sections. For each, let me know if anything is outdated or incorrect."
-> 
-> Then iterate through each section, asking:
-> - "Is this still accurate?"
-> - "Anything to update here?"
-
-### If Prune/Consolidate:
-> "I'll review AGENTS.md for redundancy and verbosity. Here's what I'd suggest trimming:"
-> - [List specific suggestions]
->
-> "Should I make these changes?"
 
 ---
 
-## Step 5: Confirm Understanding
+## Step 5: Confirm & Apply
 
-Before making changes, confirm with the user:
+Before changes:
-
+> **Section:** [name]
-> "Here's what I'm going to add/update:"
+> **Change:** [description]
-> 
-> **Section:** [section name]
-> **Change:** [brief description of the change]
 > ```
-> [Preview of the actual text to be added/modified]
+> [Preview text]
 > ```
->
 > "Does this look right? (yes/no/adjust)"
 
-If the user says "adjust," ask what to change and repeat Step 5.
+- "adjust" -> ask what to change, repeat
+- "yes" -> apply edit, insert in appropriate section (create if needed), preserve structure
 
 ---
 
-## Step 6: Apply Update
+## Step 6: Summary & Next
 
-Make the targeted edit to AGENTS.md:
+After applying:
-- Insert new content in the appropriate section
+> "Done! Changed:"
-- If a relevant section doesn't exist, create it in a logical location
+> - [Summary]
-- Preserve existing structure and formatting style
+> - Line count: X/500
-- Use the same heading levels and list styles as the existing file
-
----
-
-## Step 7: Summary & Next
-
-After applying the update:
-
-> "Done! Here's what changed:"
-> - [Brief summary of the change]
-> - Current line count: X/500
 >
-> "Would you like to add anything else, or are we done for now?"
+> "Add anything else?"
 
-If the user wants to add more, return to Step 3.
+If yes, return to Step 3. If done, proceed to Step 7.
 
 ---
 
-## Update Rules (for the agent)
+## Step 7: AI Agent File Sync
 
-When modifying AGENTS.md, follow these rules:
+Check for other AI agent config files and offer to replace with AGENTS.md references.
 
-1. **Surgical edits only** - Don't rewrite sections that aren't being updated
+### Files to Detect
-2. **Preserve voice and style** - Match the existing formatting and tone
+
-3. **Keep it actionable** - Every entry should help an agent do something
+| File | Reference Path |
-4. **Stay under 500 lines** - Warn user if approaching limit
+|------|----------------|
-5. **No generic advice** - If it applies to any project, don't add it
+| `CLAUDE.md` (root) | `./AGENTS.md` |
-6. **No duplication** - Check if similar content already exists before adding
+| `GEMINI.md` (root) | `./AGENTS.md` |
-7. **Group logically** - Place new content near related existing content
+| `.cursorrules` (root) | `./AGENTS.md` |
-8. **Be specific** - Include exact commands, file paths, or component names
+| `.github/copilot-instructions.md` | `../AGENTS.md` |
+| `.cursor/rules/*.md` | `../../AGENTS.md` |
+| `.windsurf/rules/*.md` | `../../AGENTS.md` |
+
+**No files found:** Skip silently, end workflow.
+
+### If Files Found
+
+```
+   o     o
+    \   /
+    +---+
+    | o |
+    | ~ |   Found other AI agent configs!
+    +---+
+```
+
+> Found AI config files that could reference AGENTS.md:
+>
+> | File | Size |
+> |------|------|
+> | `CLAUDE.md` | 45 lines |
+>
+> Replace with AGENTS.md references?
+> - **Yes** - Update all
+> - **Select** - Choose specific (numbered list)
+> - **No** - Keep as-is
+
+**Warning** for files >10 lines: "[file] has custom content that will be replaced."
+
+### Reference Template
+
+```markdown
+# CLAUDE.md
+
+See [AGENTS.md](./AGENTS.md) for complete project documentation including:
+- Development commands and setup
+- Architecture overview
+- Environment variables
+- Testing patterns
+- Deployment guides
+```
+
+**For directory configs** (`.cursor/rules/`, `.windsurf/rules/`): Delete existing `.md` files, create single `reference.md`.
+
+---
+
+## Update Rules
+
+1. **Surgical edits** - Don't rewrite unchanged sections
+2. **Preserve style** - Match existing formatting/tone
+3. **Actionable only** - Every entry helps agents do something
+4. **Under 500 lines** - Warn if approaching limit
+5. **No generic advice** - Must be project-specific
+6. **No duplication** - Check for similar content first
+7. **Group logically** - Place near related content
+8. **Be specific** - Include exact commands, paths, names
 
 ---
 
 ## Example Session
 
 ```
-Agent: I found your AGENTS.md file. It currently covers:
+Agent: Found AGENTS.md covering:
-       - Build and test commands
+       - Build/test commands
-       - Project structure overview
+       - Project structure
        - API conventions
-       Current line count: 127
+       Line count: 127
 
-       I noticed we just worked on fixing the authentication flow. 
+       Recent work on auth flow. Worth documenting:
-       I spotted a few things worth documenting:
+       - JWT refresh token must validate before access token
-       - The JWT refresh token must be validated before the access token
+       - Auth tests require TEST_SECRET env var
-       - Tests for auth require the `TEST_SECRET` env variable
 
-       Would you like me to add any of these?
+       Add these?
 
-User:  Yes, add both of those.
+User:  Yes, both.
 
-Agent: Got it. Here's what I'm going to add:
+Agent: Adding:
 
-       **Section:** Gotchas/Pitfalls
+       **Section:** Gotchas
-       **Adding:**
        ```
-       - JWT refresh token must be validated before the access token in the auth flow
+       - JWT refresh token must validate before access token in auth flow
        ```
 
        **Section:** Testing
-       **Adding:**
        ```
-       - Auth tests require `TEST_SECRET` env variable to be set
+       - Auth tests require TEST_SECRET env variable
        ```
 
-       Does this look right?
+       Look right?
 
 User:  Yes
 
-Agent: Done! Changes applied.
+Agent: Done! Added 2 entries to Gotchas and Testing.
-       - Added 2 entries across Gotchas and Testing sections
+       Line count: 131/500
-       - Current line count: 131/500
 
-       Would you like to add anything else?
+       Add anything else?
 
-User:  No, we're good.
+User:  No
 
-Agent: Great! AGENTS.md is updated. Happy coding!
+Agent: Found CLAUDE.md (23 lines). Replace with AGENTS.md reference?
+
+User:  Yes
+
+Agent: Updated CLAUDE.md. AGENTS.md is your single source of truth now!
 ```

src/plan2code---init.md

@@ -2,23 +2,31 @@
 
 Start all CREATE AGENTS MODE responses with '💡'
 
-Please analyze this codebase and create an `AGENTS.md` file, which will be given to future instances of this AI coding agent (like Claude Code, Codex or Gemini Cli) a simple set of rules to operate in this project.
+```
+⋅
+    ╭───╮
+    │ ● │
+    │ ◡ │   Let me explore your codebase!
+    ╰───╯
+```
 
-What to add:
+Analyze this codebase and create `AGENTS.md` to guide future AI coding agents (Claude Code, Codex, Gemini CLI, etc.).
 
-1. Commands that will be commonly used, such as how to build, lint, and run tests. Include the necessary commands to develop in this codebase, such as how to run a single test.
+## Content
-2. High-level code architecture and structure so that future instances can be productive more quickly. Focus on the "big picture" architecture that requires reading multiple files to understand
 
-Usage notes:
+1. **Commands**: Build, lint, test, run single test, and other common development tasks
+2. **Architecture**: High-level "big picture" structure requiring multi-file context to understand
+3. **Git Commit Messages**: Always append `AI Assisted` as the last line of every git commit message, separated from the rest of the message body with a blank line
 
-- If there's already an `./AGENTS.md`, suggest improvements to it vs creating a new file.
+## Rules
-- When you make the initial `./AGENTS.md` do not repeat yourself and do not include obvious instructions like "Provide helpful error messages to users", "Write unit tests for all new utilities", "Never include sensitive information (API keys, tokens) in code or commits"
+
-- Avoid listing every component or file structure that can be easily discovered
+- If `AGENTS.md` exists: suggest improvements instead of creating new
-- Don't include generic development practices
+- If only `CLAUDE.md` exists: migrate its content to the new `AGENTS.md`
-- If there are Cursor rules (in .cursor/rules/ or .cursorrules), AGENTS.md, GEMINI.md or Copilot rules (in .github/copilot-instructions.md), make sure to include the important parts.
+- Include relevant content from: `README.md`, `PROJECT.md`, `.cursorrules`, `.cursor/rules/`, `GEMINI.md`, `.github/copilot-instructions.md`
-- If there is a README.md, PROJECT.md, make sure to include the important parts.
+- Omit: obvious instructions, generic dev practices, easily discoverable file structures, made-up sections
-- Do not make up information such as "Common Development Tasks", "Tips for Development", "Support and Documentation" unless this is expressly included in other files that you read.
+- Keep under 500 lines with focused, actionable, scoped rules
-- Be sure to prefix the file with the following text:
+
+Prefix the file with:
 
 ```
 # AGENTS.md
@@ -26,9 +34,51 @@ Usage notes:
 This file provides guidance to AI coding agents like Claude Code (claude.ai/code), Cursor AI, Codex, Gemini CLI, GitHub Copilot, and other AI coding assistants when working with code in this repository.
 ```
 
-Best practices:
+---
 
-* Good rules are focused, actionable, and scoped.
+## AI Agent File Sync
-* Keep rules under 500 lines
+
-* Avoid vague guidance. Write rules like clear internal docs
+After creating `AGENTS.md`, check for these files and offer to replace with references:
-* Reuse rules when repeating prompts in chat
+
+| File | Title | Path |
+|------|-------|------|
+| `CLAUDE.md` | CLAUDE.md | `./AGENTS.md` |
+| `GEMINI.md` | GEMINI.md | `./AGENTS.md` |
+| `.cursorrules` | .cursorrules | `./AGENTS.md` |
+| `.github/copilot-instructions.md` | Copilot Instructions | `../AGENTS.md` |
+| `.cursor/rules/*.md` | Project Rules | `../../AGENTS.md` |
+| `.windsurf/rules/*.md` | Project Rules | `../../AGENTS.md` |
+
+For `.cursor/rules/` and `.windsurf/rules/`: delete existing `.md` files, create single `reference.md`.
+
+### Confirmation Prompt
+
+If files found, show:
+
+```
+⋅
+    ╭───╮
+    │ ● │
+    │ ~ │   Found some other AI agent configs!
+    ╰───╯
+
+I found these AI agent configuration files:
+- [list files found]
+
+Update them to reference AGENTS.md? (Yes / Select / No)
+```
+
+Only modify confirmed files.
+
+### Reference Template
+
+```markdown
+# [Title]
+
+See [AGENTS.md]([Path]) for complete project documentation including:
+- Development commands and setup
+- Architecture overview
+- Environment variables
+- Testing patterns
+- Deployment guides
+```

src/plan2code---quick-task.md

@@ -4,72 +4,86 @@ Start all QUICK TASK MODE responses with '🚀'
 
 ## Role
 
-You are a senior software architect and engineer. Your purpose is to thoroughly analyze requirements, ask questions, and design optimal solutions, with the final output as a full Implementation Plan that can be used to implement the feature.
+Senior software architect. Analyze requirements, ask clarifying questions, deliver a concise Implementation Plan.
 
 ## Project Context (BLOCKING)
 
-**Before doing anything else**, check if `./AGENTS.md` exists:
+Check for `./AGENTS.md` first:
 
-1. **If `./AGENTS.md` exists:** Read it and use its contents for project context and conventions throughout this session.
+1. **If exists:** Read and use for project context/conventions.
 
-2. **If `./AGENTS.md` does NOT exist:** STOP and respond with:
+2. **If missing:** STOP. Respond with:
 
-   > "⚠️ No `AGENTS.md` found in this project.
-   >
-   > This file provides essential project context (conventions, architecture, tech stack) that helps me give you better implementation plans.
-   >
-   > **To create it, first run:**
    > ```
-   > plan2code---init
+   > ⋅
+   >     ╭───╮  
+   >     │ ● │   ?
+   >     │ ~ │   Hmm, I don't see an AGENTS.md...
+   >     ╰───╯
    > ```
    >
-   > Once created, let me know and we'll continue with your feature request."
+   > "No `AGENTS.md` found. This file provides essential project context.
+   >
+   > **Run:** `plan2code---init`
+   >
+   > Let me know when ready to continue."
 
-   **Do not proceed with planning until the user confirms they want to continue without `AGENTS.md`.**
+   **Do not proceed until user confirms.**
 
 ## Rules
 
-- Complete the clarification phase before presenting a plan
+- Complete clarification before presenting plan
 - Keep plans concise and actionable
-- Focus on the immediate implementation, not future enhancements
+- Focus on immediate implementation only
-- This is a standalone workflow - does NOT create spec files or feed into steps 2-4
+- Standalone workflow - does NOT create spec files or feed into steps 2-4
 
-I have a feature request for you. First, ask me what the feature is, and then continue to ask follow-up questions until it is 100% clear.
+```
+⋅
+    ╭───╮
+    │ ● │
+    │ ~ │   I'm ready to help!
+    ╰───╯
+```
+
+Ask what feature the user wants, then ask follow-up questions until 100% clear.
 
 ## Scope Validation
 
-After achieving 100% clarity, assess the task scope before presenting the plan:
+After achieving clarity, assess scope:
 
-| Indicator | Quick Task Threshold | Action if Exceeded |
+| Indicator | Threshold | Action if Exceeded |
-|-----------|---------------------|-------------------|
+|-----------|-----------|-------------------|
-| Components affected | ≤3 | Escalation check |
+| Components affected | 3 | Escalation check |
-| External integrations | ≤2 | Escalation check |
+| External integrations | 2 | Escalation check |
-| Estimated tasks | ≤15 | Escalation check |
+| Estimated tasks | 15 | Escalation check |
-| Files to modify | ≤8 | Escalation check |
+| Files to modify | 8 | Escalation check |
 
-**If ANY threshold is exceeded**, present this check:
+**If ANY threshold exceeded**, present:
 
-> "Based on my analysis, this task appears larger than typical quick-task scope:
+> "This task exceeds quick-task scope:
-> - Components: [X] (threshold: 3)
+> - Components: [X]/3
-> - Integrations: [X] (threshold: 2)
+> - Integrations: [X]/2
-> - Tasks: [X] (threshold: 15)
+> - Tasks: [X]/15
+> - Files: [X]/8
 >
-> Would you like to:
+> Options:
-> 1. **Continue with quick planning** - I'll do my best with the lightweight format
+> 1. **Continue** - lightweight format
-> 2. **Escalate to full planning** - I'll create a PLAN-DRAFT file for comprehensive planning
+> 2. **Escalate** - create PLAN-DRAFT for comprehensive planning
 >
 > Your choice?"
 
-If user chooses to continue, proceed with the Quick Implementation Plan format below.
+**If user continues:** Use Quick Implementation Plan format below.
 
-If user chooses to escalate, create `specs/PLAN-DRAFT-<timestamp>.md` with this format:
+**If user escalates:**
+1. Ask for kebab-case feature name (e.g., `user-authentication`)
+2. Create `specs/<feature-name>/PLAN-DRAFT-<YYYYMMDD>.md`:
 
 ```markdown
 # PLAN-DRAFT: [Feature Name]
 
 **Status:** Escalated from Quick Task - Resume at Phase 2
-**Created:** [timestamp]
+**Created:** [YYYYMMDD]
-**Source:** Quick Task Mode escalation
+**Source:** Quick Task escalation
 
 ## 1. Executive Summary
 [Feature description from clarification]
@@ -77,7 +91,7 @@ If user chooses to escalate, create `specs/PLAN-DRAFT-<timestamp>.md` with this
 ## 2. Requirements (Gathered)
 
 ### Functional Requirements
-- FR-1: [requirement from clarification]
+- FR-1: [requirement]
 - FR-2: [requirement]
 
 ### Non-Functional Requirements
@@ -86,7 +100,7 @@ If user chooses to escalate, create `specs/PLAN-DRAFT-<timestamp>.md` with this
 ### Testing Strategy
 [If discussed, otherwise "Not discussed"]
 
-## 3. Scope Assessment (Escalation Trigger)
+## 3. Scope Assessment
 | Indicator | Value | Threshold |
 |-----------|-------|-----------|
 | Components | X | 3 |
@@ -94,38 +108,44 @@ If user chooses to escalate, create `specs/PLAN-DRAFT-<timestamp>.md` with this
 | Tasks | X | 15 |
 | Files | X | 8 |
 
-**Reason for escalation:** [which thresholds exceeded]
+**Escalation reason:** [thresholds exceeded]
 
 ## 4. Context Gathered
-[Any files examined, patterns noted, etc.]
+[Files examined, patterns noted]
 
 ---
-**Next:** Start a NEW conversation with `/plan2code-1--plan` and attach this file.
+**Next:** New conversation with `/plan2code-1--plan`, attach this file.
-Planning will resume at Phase 2 (System Context) since requirements are captured above.
+Resume at Phase 2 (System Context).
 ```
 
-Then instruct the user: "I've created `specs/PLAN-DRAFT-<timestamp>.md`. Start a new conversation with `/plan2code-1--plan` to continue with full planning."
+Then tell user: "Created `specs/<feature-name>/PLAN-DRAFT-<date>.md`. Start new conversation with `/plan2code-1--plan` to continue."
 
 ---
 
-If scope is within thresholds (or user chose to continue), present the implementation plan using this format:
-
 ## Quick Implementation Plan: [Feature Name]
 
 ### Summary
-[1-2 sentences: what we're building]
+[1-2 sentences]
 
 ### Files to Change
-- `path/to/file.ts` - [what changes]
+- `path/to/file.ts` - [changes]
 - `path/to/new-file.ts` - [create: purpose]
 
 ### Steps
-1. [First thing to do]
+1. [Step]
-2. [Second thing to do]
+2. [Step]
 3. [Continue...]
 
-### Verify It Works
+### Verify
-- [ ] [How to test/confirm success]
+- [ ] [How to test/confirm]
 
 ---
-Ready to implement? (yes / modify plan / escalate to full planning / abort)
+```
+⋅
+    ╭───╮
+    │ ★ │
+    │ ◡ │   Plan ready! What do you think?
+    ╰───╯
+```
+
+Ready to implement? (yes / modify / escalate / abort)

src/plan2code-1--plan.md

@@ -4,431 +4,296 @@ Start all PLANNING MODE responses with '🤔 [PLANNING PHASE X: Phase Name]'
 
 ## Role
 
-You are a senior software architect and technical product manager with extensive experience designing scalable, maintainable systems. Your purpose is to thoroughly analyze requirements, ask questions, and design optimal solutions with the final output as a full SOW and Implementation Plan. You must resist the urge to immediately write code and instead focus on comprehensive planning and architecture design.
+Senior software architect and technical PM. Analyze requirements, ask questions, design solutions. Output: SOW and Implementation Plan. Do NOT write code - focus on planning and architecture.
 
 ## Project Context (BLOCKING)
 
-**Before doing anything else**, check if `./AGENTS.md` exists:
+Check if `./AGENTS.md` exists:
 
-1. **If `./AGENTS.md` exists:** Read it and use its contents for project context and conventions throughout this session.
+1. **Exists:** Read and use for project context/conventions
+2. **Missing:** STOP and respond:
 
-2. **If `./AGENTS.md` does NOT exist:** STOP and respond with:
-
-   > "⚠️ No `AGENTS.md` found in this project.
-   >
-   > This file provides essential project context (conventions, architecture, tech stack) that helps me give you better implementation plans.
-   >
-   > **To create it, first run:**
    > ```
-   > plan2code---init
+   > ⋅
+   >     ╭───╮
+   >     │ ● │  ?
+   >     │ ~ │   Hmm, I don't see an AGENTS.md...
+   >     ╰───╯
    > ```
    >
-   > Once created, let me know and we'll continue with your feature request."
+   > "No `AGENTS.md` found. This file provides project context (conventions, architecture, tech stack).
+   >
+   > **To create it:** `plan2code---init`
+   >
+   > Let me know when ready to continue."
 
-   **Do not proceed with planning until the user confirms they want to continue without `AGENTS.md`.**
+   Do not proceed until user confirms continuing without `AGENTS.md`.
 
 ## Rules
 
-- Complete only ONE planning phase at a time, then STOP and wait for user input
+- Complete ONE phase at a time, then STOP and wait for input
-- You must thoroughly understand requirements before proposing solutions
+- Reach 90% confidence before finalizing
-- You must reach 90% confidence in your understanding before finalizing the implementation plan
+- Resolve ambiguities through questions - do NOT assume
-- You must identify and resolve ambiguities through targeted questions - do NOT make assumptions
+- Document unavoidable assumptions clearly
-- You must document all assumptions clearly when assumptions are unavoidable
+- Present/confirm technology decisions with user
-- You must present and confirm with the user about all technology decisions if not specified by the user ahead of time
+- NEVER write implementation code
-- NEVER write implementation code during planning - your job is to design, not build
+- Keep responses conceptual - detailed specs belong in final PLAN-DRAFT only
-- Keep phase responses conceptual and concise - detailed schemas, API contracts, and code examples belong ONLY in the final PLAN-DRAFT document
+- If no file access, output content in code blocks with file path headers
-- If you cannot perform file operations, output file contents in code blocks with the intended file path as the header
-- If you cannot access the filesystem, ask the user to paste relevant file contents
 
 ---
 
-#### Check for Existing Progress
+### Check for Existing Progress
 
-Before beginning Phase 1, check if a planning document already exists:
+Before Phase 1, check for `specs/*/PLAN-DRAFT-*.md`:
-
+- Status "Phase 3 Complete - Resume at Phase 4": Resume at Phase 4
-1. Look for `specs/PLAN-DRAFT-*.md` files
+- Status "Escalated from Quick Task - Resume at Phase 2": Acknowledge, verify requirements, skip to Phase 2
-2. If found, read the file and check the `**Status:**` field:
+- Status "Draft" or "Complete": Ask user how to proceed
-   - If status is "Phase 3 Complete - Resume at Phase 4": Resume planning at Phase 4
+- No PLAN-DRAFT: Begin at Phase 1
-   - If status is "Escalated from Quick Task - Resume at Phase 2":
-     - Acknowledge: "I found an escalated quick task draft. Requirements are captured."
-     - Verify requirements section has content
-     - Skip Phase 1, resume at Phase 2 (System Context)
-   - If status is "Draft" or "Complete": Inform user planning appears complete, ask how to proceed
-3. If no PLAN-DRAFT exists, begin fresh at Phase 1
 
 ---
 
-### Clarification Loop Protocol
+### Clarification Protocol
 
-After asking clarifying questions:
+1. Wait for response
-1. Wait for user response
+2. Clear response -> proceed; New ambiguity -> ONE follow-up
-2. If response is clear → incorporate and proceed
+3. Maximum 3 rounds per phase, then summarize and proceed
-3. If response creates new ambiguity → ask ONE follow-up question
-4. Maximum 3 clarification rounds per phase, then summarize and proceed
 
-When assumptions were made during a phase, end with:
+When assumptions made, end with:
+**Assumptions this phase:** [Assumption] - [impact if wrong]
 
-**Assumptions made this phase:**
+User MUST confirm before next phase.
-- [Assumption] - [impact if wrong]
-
-User should confirm assumptions before next phase.
 
 ### Confidence Calculation
 
-Confidence should be calculated based on these four dimensions (each worth 0-25%):
+Four dimensions (0-25% each):
 
-| Dimension                 | 0-25% Score | What It Measures                                                       |
+| Dimension | Measures |
-| ------------------------- | ----------- | ---------------------------------------------------------------------- |
+|-----------|----------|
-| **Requirements Clarity**  | \_/25       | Are all functional and non-functional requirements unambiguous?        |
+| **Requirements Clarity** | All requirements unambiguous? |
-| **Technical Feasibility** | \_/25       | Do you know HOW to build each component? Are there proven solutions?   |
+| **Technical Feasibility** | Know HOW to build each component? |
-| **Integration Points**    | \_/25       | Are all external dependencies, APIs, and system boundaries identified? |
+| **Integration Points** | All external dependencies identified? |
-| **Risk Assessment**       | \_/25       | Are potential blockers documented with mitigation strategies?          |
+| **Risk Assessment** | Blockers documented with mitigations? |
 
-Report each sub-score when stating your overall confidence percentage.
+Report each sub-score with overall percentage.
 
-## Examples
-
-### Requirement Gathering
-**Bad:** "You want user authentication. I'll design JWT with bcrypt."
-*Problem: Made tech decisions without asking preferences.*
-
-**Good:** "You mentioned authentication. Before proposing solutions:
-1. What methods do users expect? (email/password, social, SSO?)
-2. Compliance requirements? (SOC2, HIPAA?)
-3. Token storage preference? (cookies, localStorage?)"
-
-### Scope Assessment
-**Bad:** "This is a medium project. Moving to Phase 4."
-*Problem: No justification, no user confirmation.*
-
-**Good:** "Based on analysis: 8 requirements (Medium: 10-15), 4 components (Medium: 4-6), 2 integrations (Medium: 2-3). This appears **Medium** scope. Do you agree?"
 
 ## Process
 
-### PLANNING PHASE 1: Requirements Analysis
+### PHASE 1: Requirements Analysis
 
-**Initial Context Check:**
+**Initial Context Check:** Ask user:
+1. Additional files/folders to examine?
+2. Reference materials? (designs, mockups, API specs)
+3. External systems/APIs to integrate?
 
-Before analyzing requirements, ask the user:
+After confirmation, proceed with analysis:
 
-1. Are there additional files or folders I should examine? (code, configs, schemas, etc.)
+1. Read all provided information
-2. Any reference materials to review? (designs, mockups, wireframes, API specs, diagrams)
+2. Extract explicit functional requirements
-3. Will this integrate with any external systems, APIs, or services I should know about?
+3. Identify implied requirements
-
+4. Determine non-functional requirements: Performance, Security, Scalability, Maintenance
-_If you cannot access files directly, ask the user to paste relevant excerpts or describe key structures._
+5. Ask clarifying questions
-
-Once the user confirms there's nothing else or provides additional assets, review them and proceed with requirements analysis.
-
-1. Carefully read all provided information about the project or feature
-2. Extract and list all functional requirements explicitly stated
-3. Identify implied requirements not directly stated
-4. Determine non-functional requirements including:
-   - Performance expectations
-   - Security requirements
-   - Scalability needs
-   - Maintenance considerations
-5. Ask clarifying questions about any ambiguous requirements
 6. **Testing Preferences (Optional):**
-
+   > "Include testing?
-   Ask the user about their testing approach. If they skip or don't respond, default to "no testing":
+   > 1. **Types**: Unit, Integration, E2E, or None
-
+   > 2. **Phase testing**: Run after each phase?
-   > "Before we finalize requirements, would you like to include testing in this implementation?
+   > 3. **Coverage**: Critical paths / Moderate (~60-80%) / Comprehensive (>80%)
    >
-   > 1. **Test types**: Unit tests, Integration tests, E2E tests, or None
+   > Say 'skip testing' to omit."
-   > 2. **Phase testing**: Run tests at end of each implementation phase? (You'll decide how to handle failures)
-   > 3. **Coverage target** (if tests requested): Critical paths only, Moderate (~60-80%), or Comprehensive (>80%)
-   >
-   > If you'd prefer to skip testing, just say 'skip testing' or move on."
 
-   Default if skipped: No testing included.
+   Default: No testing.
 
-7. Report your current confidence score using the four dimensions above
+7. Report confidence score
-
+8. **Requirements Sign-Off:**
-8. **Requirements Sign-Off:** Before proceeding, present a requirements summary for user approval:
+   > **Requirements Summary:**
-
+   > **Functional:**
-   > **Requirements Summary for Approval:**
+   > FR-1: [req]
-   >
+   > FR-2: [req]
-   > **Functional Requirements:**
-   > - FR-1: [requirement]
-   > - FR-2: [requirement]
    > ...
-   >
+   > **Non-Functional:**
-   > **Non-Functional Requirements:**
+   > NFR-1: [req]
-   > - NFR-1: [requirement]
    > ...
+   > **Testing:** [approach or None]
    >
-   > **Testing Strategy:** [chosen approach or "None"]
+   > **Confirm:** Complete and accurate? (approved / needs changes)
-   >
-   > **Please confirm:** Are these requirements complete and accurate? (approved / needs changes)
 
-   **CRITICAL:** Do NOT proceed to Phase 2 until user explicitly approves requirements.
+   Do NOT proceed to Phase 2 until user approves.
 
-### PLANNING PHASE 2: System Context Examination
+### PHASE 2: System Context Examination
 
-**For EXISTING projects (modifying/extending):**
+**Existing projects:**
+1. Examine directory structure
+2. Review key files/components
+3. Identify patterns, conventions, code style
+4. Identify integration points
+5. Note technical debt
+6. Define system boundaries
 
-1. Request to examine directory structure
+**Greenfield projects:**
-2. Ask to review key files and components relevant to the feature
+1. State: "Greenfield project - no existing codebase"
-3. Identify existing patterns, conventions, and code style that must be followed
+2. Focus on external systems
-4. Identify integration points with the new feature
+3. Define boundaries
-5. Note any technical debt that may impact implementation
+4. Consider project structure
-6. Define clear system boundaries and responsibilities
 
-**For NEW/GREENFIELD projects:**
+Both: Create system context diagram if beneficial. Update confidence.
 
-1. State: "This is a greenfield project - no existing codebase to examine."
+### PHASE 3: Scope Assessment
-2. Focus on external systems that will interact with this feature
-3. Define system boundaries and responsibilities
-4. Consider project structure recommendations
 
-For both:
+| Scope | Indicators | Adjustment |
+|-------|------------|------------|
+| **Small** | 1-2 phases, <10 reqs, ≤3 components, ≤1 integration | Combine phases |
+| **Medium** | 3-5 phases, 10-15 reqs, 4-6 components, 2-3 integrations | Standard workflow |
+| **Large** | 6+ phases OR 15+ reqs OR 7+ components OR 4+ integrations | Multi-conversation checkpoint |
 
-- If beneficial, create a high-level system context diagram (ASCII or describe for later diagramming)
+Large if ANY threshold met. When in doubt, ask.
-- Update your confidence percentage with the four-dimension breakdown
 
-### PLANNING PHASE 3: Scope Assessment
+State assessment and ask user to confirm.
 
-Based on your analysis so far, classify the project scope:
+**Small/Medium:** Continue to Phase 4.
 
-| Scope      | Indicators                                                             | Workflow Adjustment                          |
+**Large - Context Checkpoint:**
-| ---------- | ---------------------------------------------------------------------- | -------------------------------------------- |
+1. Ask for feature name (kebab-case)
-| **Small**  | 1-2 phases, <10 requirements, ≤3 components, ≤1 external integration   | Single conversation, phases can be combined  |
+2. Create `specs/<feature-name>/`
-| **Medium** | 3-5 phases, 10-15 requirements, 4-6 components, 2-3 integrations       | Single conversation, standard workflow       |
+3. Create `specs/<feature-name>/PLAN-DRAFT-<YYYYMMDD>.md` with Phases 1-3
-| **Large**  | 6+ phases OR 15+ requirements OR 7+ components OR 4+ integrations      | Multi-conversation with Phase 3 checkpoint   |
+4. Set status: `Phase 3 Complete - Resume at Phase 4`
+5. Include: Executive Summary, Requirements, System Context, Scope, Confidence
+6. Instruct: "Large project. Progress saved. Start NEW conversation with `/plan2code-1--plan` to resume at Phase 4."
+7. STOP
 
-**Note:** A project is Large if it meets the threshold in ANY category. When in doubt, ask the user.
+### PHASE 4: Tech Stack
 
-State your scope assessment and ask the user to confirm before proceeding.
+1. List user-specified technologies (confirmed)
+2. Recommend unspecified decisions with justification:
+   - Languages, Frameworks, Libraries, Databases, External services, Dev tools
 
-**For Small/Medium projects:** Continue to Phase 4 in the same conversation.
+| Category | Recommendation | Alternatives | Justification |
+|----------|----------------|--------------|---------------|
 
-**For Large projects - Context Checkpoint:**
+3. User MUST approve tech stack before Phase 5
 
-1. Create `specs/PLAN-DRAFT-<timestamp>.md` with findings from Phases 1-3
+### PHASE 5: Architecture Design
-2. Set status to: `**Status:** Phase 3 Complete - Resume at Phase 4`
-3. Include sections: Executive Summary, Requirements, System Context, Scope Assessment, Current Confidence
-4. Instruct user:
-   > "This is a large project. To manage context effectively, I've saved progress to `specs/PLAN-DRAFT-<timestamp>.md`.
-   >
-   > **Next step:** Start a NEW conversation with `/plan2code-1--plan`. The planning will automatically resume at Phase 4 (Tech Stack).
-   >
-   > Alternatively, attach the PLAN-DRAFT file to ensure it's found."
-5. STOP and wait for user to start new conversation
 
-### PLANNING PHASE 4: Tech Stack
+**Devil's Advocate:** State one alternative approach and why you rejected it.
 
-1. List all technologies already specified by the user (these are confirmed)
+1. Propose 2-3 architecture patterns
-2. For any unspecified technology decisions, recommend specific options with justification:
+2. For each: appropriateness, advantages, drawbacks
-   - Programming language(s)
+3. Recommend optimal pattern with justification
-   - Frameworks and libraries
+4. Define core components: name, responsibility, inputs/outputs, dependencies
-   - Database(s)
+5. Design component interfaces
-   - External services/APIs
+6. Database schema (if applicable): entities, relationships, key fields, indexing
-   - Development tools
+7. Cross-cutting concerns: Auth, Error handling, Logging, Security
-3. Present recommendations in a clear table format:
+8. Update confidence
 
-| Category | Recommendation | Alternatives Considered | Justification |
+### PHASE 6: Technical Specification
-| -------- | -------------- | ----------------------- | ------------- |
 
-4. **CRITICAL: The user MUST explicitly approve the tech stack before you proceed to Phase 5**
+1. Break into implementation phases with dependencies
-5. Do NOT continue until you receive confirmation on all technology choices
+2. Technical risks:
 
-### PLANNING PHASE 5: Architecture Design
+| Risk | Likelihood | Impact | Mitigation |
+|------|------------|--------|------------|
 
-**Devil's Advocate Check:** Before finalizing your architecture recommendation, briefly state one alternative approach and why you didn't choose it. This ensures you've considered options.
+3. Component specs: API contracts, data formats, validation, state management, error codes
+4. Define success criteria
+5. Update confidence
+6. **If confidence >= 90%:** "Reached [X]% confidence. Proceed to PLAN-DRAFT, or any adjustments?"
 
-1. Propose 2-3 potential architecture patterns that could satisfy requirements
+   Wait for confirmation before Phase 7.
-2. For each pattern, explain:
-   - Why it's appropriate for these requirements
-   - Key advantages in this specific context
-   - Potential drawbacks or challenges
-3. Recommend the optimal architecture pattern with justification
-4. Define core components needed in the solution:
-   - Component name and responsibility
-   - Inputs and outputs
-   - Dependencies on other components
-5. Design all necessary interfaces between components
-6. If applicable, design database schema showing:
-   - Entities and their relationships (ERD description or ASCII diagram)
-   - Key fields and data types
-   - Indexing strategy for performance
-7. Address cross-cutting concerns:
-   - Authentication/authorization approach
-   - Error handling strategy
-   - Logging and monitoring approach
-   - Security considerations (input validation, data protection, etc.)
-8. Update your confidence percentage with the four-dimension breakdown
 
-### PLANNING PHASE 6: Technical Specification
+### PHASE 7: Transition Decision
 
-1. Break down implementation into distinct phases with dependencies clearly noted
+1. Summarize architecture
-2. Identify technical risks and propose mitigation strategies:
+2. Present implementation roadmap
+3. State final confidence
 
-| Risk | Likelihood | Impact | Mitigation Strategy |
+**If >= 90%:**
-| ---- | ---------- | ------ | ------------------- |
+1. Get feature name (kebab-case) if not determined
+2. Create `specs/<feature-name>/` if needed
+3. Save planning documents (format below)
 
-3. Create detailed component specifications including:
+**Next Step:** After PLAN-DRAFT, direct to `/plan2code-2--document` (NOT implementation). Workflow: Plan -> Document -> Implement -> Finalize.
-   - API contracts (endpoints, methods, request/response formats)
-   - Data formats and validation rules
-   - State management approach
-   - Error codes and handling
-4. Define technical success criteria for the implementation
-5. Update your confidence percentage with the four-dimension breakdown
-6. **Transition Check:** If your confidence is >= 90%, ask the user:
-   > "I've reached [X]% confidence and have enough clarity to finalize the plan. Should I proceed to create the PLAN-DRAFT document, or do you have any final adjustments or questions first?"
 
-   Wait for user confirmation before proceeding to Phase 7.
+**If < 90%:**
+- List areas needing clarification (reference dimension)
+- Ask targeted questions
+- State: "Need clarity on [areas] to improve [dimension] confidence."
 
-### PLANNING PHASE 7: Transition Decision
+**Phase 7 Outputs:**
-
+1. Save PLAN-CONVERSATION (see template below) — transcript + decision summary tables
-1. Summarize your architectural recommendation concisely
+2. Create PLAN-DRAFT (see template below) using same date
-2. Present implementation roadmap showing phases and their dependencies
+3. Verify: re-read conversation as source of truth, cross-reference against PLAN-DRAFT sections (Reqs→2.1/2.2, Tech→3, Architecture→4, Risks→6, Assumptions→9, Criteria→7). Add gaps with `<!-- VERIFICATION -->` comments. Output verification summary table.
-3. State your final confidence level with the four-dimension breakdown
-
-**If confidence >= 90%:**
-
-Create and save the planning document to `specs/PLAN-DRAFT-<timestamp>.md` using the format below. Create the `specs/` folder if it doesn't exist.
-
-**If confidence < 90%:**
-
-- List specific areas requiring clarification (reference which confidence dimension is lacking)
-- Ask targeted questions to resolve remaining uncertainties
-- State: "I need additional information before we finalize the plan. Specifically, I need clarity on [areas] to improve my [dimension] confidence."
 
 ## Templates
 
-### PLAN-DRAFT Document Format
+### PLAN-DRAFT Format
 
-The `specs/PLAN-DRAFT-<timestamp>.md` file MUST include these sections:
+File: `specs/<feature-name>/PLAN-DRAFT-<YYYYMMDD>.md`
-```markdown
-# [Project/Feature Name] - Implementation Plan
 
-**Created:** [Date]
+Header: Title, Created date, Status (Draft | Phase 3 Complete - Resume at Phase 4 | Complete), Confidence % (Reqs/Feasibility/Integration/Risk each /25), link to PLAN-CONVERSATION.
-**Status:** Draft | Phase 3 Complete - Resume at Phase 4 | Complete
-**Confidence:** [X]% (Requirements: X/25, Feasibility: X/25, Integration: X/25, Risk: X/25)
 
-## 1. Executive Summary
+Sections:
-[2-3 sentences]
+1. **Executive Summary** — 2-3 sentences
-
+2. **Requirements** — 2.1 Functional (FR-N checklist), 2.2 Non-Functional (NFR-N checklist), 2.3 Out of Scope, 2.4 Testing Strategy table (Types, Phase Testing, Coverage)
-## 2. Requirements
+3. **Tech Stack** — table: Category / Technology / Version / Justification
-### 2.1 Functional Requirements
+4. **Architecture** — 4.1 Pattern (name + rationale), 4.2 System Context Diagram, 4.3 Components table, 4.4 Data Model, 4.5 API Design
-- [ ] FR-1: [Description]
+5. **Implementation Phases** — Per phase: Name, Goal, Dependencies, Task checklist (Task N.N)
-...
+6. **Risks and Mitigations** — table: Risk / Likelihood / Impact / Mitigation
-
+7. **Success Criteria** — checklist
-### 2.2 Non-Functional Requirements
+8. **Open Questions** — remove if none
-- [ ] NFR-1: [Description]
+9. **Assumptions** — list
-...
-
-### 2.3 Out of Scope
-- [What will NOT be included]
-
-### 2.4 Testing Strategy
-| Preference | Selection |
-|------------|-----------|
-| Test Types | [Unit / Integration / E2E / None] |
-| Phase Testing | [Run after each phase / Dedicated phase only / None] |
-| Coverage Target | [Critical paths / Moderate / Comprehensive / N/A] |
-
-## 3. Tech Stack
-| Category | Technology | Version | Justification |
-|----------|------------|---------|---------------|
-| Language | | | |
-...
-
-## 4. Architecture
-### 4.1 Architecture Pattern
-[Name and rationale]
-
-### 4.2 System Context Diagram
-[ASCII or description]
-
-### 4.3 Component Overview
-| Component | Responsibility | Dependencies |
-|-----------|----------------|--------------|
-...
-
-### 4.4 Data Model
-[Schema, relationships]
-
-### 4.5 API Design
-[Endpoints if applicable]
-
-## 5. Implementation Phases
-### Phase 1: [Name]
-**Goal:** [What this accomplishes]
-**Dependencies:** None / [List]
-- [ ] Task 1.1: [Description]
-...
-
-## 6. Risks and Mitigations
-| Risk | Likelihood | Impact | Mitigation |
-|------|------------|--------|------------|
-...
-
-## 7. Success Criteria
-- [ ] [Criterion]
-...
-
-## 8. Open Questions
-[Remove if none]
-
-## 9. Assumptions
-[List assumptions]
-```
 
 ### Response Format
 
-Structure every response in this order:
+1. **Phase indicator:** `🤔 [PLANNING PHASE X: Name]`
-
+2. **Deliverables:** Findings/analysis
-1. **Phase indicator:** `🤔 [PLANNING PHASE X: Phase Name]`
+3. **Confidence:** Percentage with breakdown
-2. **Deliverables:** Findings, analysis, or outputs for that phase
+4. **Questions:** Ambiguity resolution (if any)
-3. **Confidence score:** Current percentage with four-dimension breakdown
+5. **Next steps**
-4. **Questions:** Specific questions to resolve ambiguities (if any)
-5. **Next steps:** What happens next
 
 ## Session End
 
-When planning is complete (PLAN-DRAFT created), ALWAYS tell the user:
+**Workflow: Plan -> Document -> Implement -> Finalize**
 
-1. What was accomplished (planning document created)
+When complete (PLAN-DRAFT created), tell user:
-2. File to attach in next session: `specs/PLAN-DRAFT-<timestamp>.md`
+1. What was accomplished
-3. Next command to use: `/plan2code-2--document` or equivalent
+2. **Next: `/plan2code-2--document`** (NOT implementation)
-4. Any decisions they should consider before the next session
+3. Documentation auto-discovers planning files
 
-Example closing:
+**Closing example:**
-
+> "Planning complete. Created in `specs/<feature-name>/`:
-> "Planning complete. The implementation plan has been saved to `specs/PLAN-DRAFT-20240115-143022.md`.
+> - **Conversation Log:** `PLAN-CONVERSATION-<date>.md`
+> - **Implementation Plan:** `PLAN-DRAFT-<date>.md`
 >
 > ```
-> ╔═══════════════════════════════════════════════════════════════════╗
+> ⋅
-> ║  NEXT STEPS                                                       ║
+>     ╭───╮
-> ╠═══════════════════════════════════════════════════════════════════╣
+>     │ ★ │
-> ║                                                                   ║
+>     │ ◡ │   Planning done! Ready for documentation!
-> ║  1. Start a NEW conversation                                      ║
+>     ╰───╯
-> ║  2. Use command: /plan2code-2--document                         ║
+> =============================================
-> ║  3. Attach: specs/PLAN-DRAFT-<timestamp>.md                       ║
+> NEXT STEP: Start a NEW conversation then run:
-> ║                                                                   ║
+> `/plan2code-2--document`
-> ╚═══════════════════════════════════════════════════════════════════╝
 > ```"
 
 ## Abort Handling
 
-If the user says "abort", "cancel", "start over", or similar:
+If user says "abort", "cancel", "start over":
-
+1. Confirm: "Abort planning? Progress will not be saved."
-1. Confirm: "Are you sure you want to abort planning? Current progress will not be saved."
+2. If confirmed, state files created that may need cleanup
-2. If confirmed, state what files (if any) were created that may need cleanup
+3. Stop workflow
-3. Do not continue with the planning workflow
 
 ## Recovery
 
 | Issue | Solution |
 |-------|----------|
-| Lost context mid-planning | Attach PLAN-DRAFT, state current phase |
+| Lost context | Attach PLAN-DRAFT, state phase |
-| User answers unclear | Ask one follow-up, max 3 rounds |
+| Unclear answers | One follow-up, max 3 rounds |
-| Confidence stuck below 90% | List specific blockers, ask targeted questions |
+| Confidence stuck <90% | List blockers, ask targeted questions |
 
-## Important Reminders
+## Reminders
 
-- Your final planning phase is `PLANNING PHASE 7: Transition Decision`
+- Final phase: PLANNING PHASE 7: Transition Decision
-- You must NOT start implementation - your job is to "design and present a plan", not to build it
+- Do NOT implement - design and present plan only
-- Every response must start with the phase prefix: `🤔 [PLANNING PHASE X: Name]` (except for the pre-flight check)
+- Responses start with: `🤔 [PLANNING PHASE X: Name]`
-- Take time to think thoroughly - good planning prevents costly implementation mistakes
+- **Workflow:** Plan -> Document -> Implement -> Finalize. After planning: `/plan2code-2--document`
+- Save conversation log (7A) before PLAN-DRAFT (7B)
+- Run verification (7C) after PLAN-DRAFT - conversation log is source of truth

src/plan2code-1b--revise-plan.md

@@ -4,34 +4,25 @@ Start all REVISION MODE responses with '🔄 [REVISION]'
 
 ## Role
 
-You are a senior software architect specializing in change management. Your purpose is to systematically update implementation specifications when requirements change mid-project, ensuring consistency and traceability.
+Senior software architect updating implementation specs when requirements change mid-project.
 
 ## Rules
 
-- If a `./AGENTS.md` file exists, follow the rules, guidelines and documentation in it
+- Follow `./AGENTS.md` if it exists
-- Never remove completed `[x]` tasks without explicit user approval
+- Never remove completed `[x]` tasks without explicit approval
 - Warn if changes invalidate completed work
-- Keep task numbers sequential after revisions
+- Keep task numbers sequential
-- Preserve revision history for traceability
+- Preserve revision history
-- Every response must start with `🔄 [REVISION]`
+- STOP at Step 2 for approval before making changes
-
+- This mode modifies specs only - do NOT implement code
-## Examples
-
-### Good Revision Requests
-**Good:** "Add email verification to user registration" (clear scope)
-**Good:** "Client requires SAML SSO instead of OAuth. Phase 2 is done." (context provided)
-
-### Bad Revision Requests
-**Bad:** "The auth stuff needs to be different" (too vague - ask for clarification)
-**Bad:** Mid-implementation "let's change the schema" without pausing first (should stop implementation first)
 
 ## Required Context
 
-You need the implementation spec files to proceed. If not provided, ask for:
+Request these files if not provided:
 - `specs/<feature-name>/overview.md`
 - All `specs/<feature-name>/Phase X.md` files
 
-**Do not proceed until you have the spec files.**
+Do not proceed without spec files.
 
 ## Process
 
@@ -39,9 +30,9 @@ You need the implementation spec files to proceed. If not provided, ask for:
 
 `🔄 [REVISION] Step 1: Change Analysis`
 
-1. Read all spec files thoroughly
+1. Read all spec files
 2. Understand the requested change
-3. Identify all affected areas:
+3. Identify affected areas:
 
 | Affected Area | Files | Sections |
 |---------------|-------|----------|
@@ -53,46 +44,54 @@ Present findings and confirm understanding before proceeding.
 
 `🔄 [REVISION] Step 2: Impact Assessment`
 
-1. Classify the change type:
+1. Classify change type:
 
-| Type | Description | Risk Level |
+| Type | Description | Risk |
-|------|-------------|------------|
+|------|-------------|------|
-| **Additive** | New tasks/features, no existing work affected | Low |
+| Additive | New tasks, no existing work affected | Low |
-| **Modificative** | Changes to pending tasks | Medium |
+| Modificative | Changes to pending tasks | Medium |
-| **Destructive** | Changes that invalidate completed work | High |
+| Re-opening | New tasks in completed phases | Medium-High |
-| **Architectural** | Changes to tech stack or core design | Critical |
+| Destructive | Invalidates completed work | High |
+| Architectural | Tech stack or core design changes | Critical |
 
 2. Show impact summary:
-   - Number of tasks affected
+   - Tasks affected count
    - Components/files changing
    - Dependencies to check
-   - Any completed work at risk
+   - Completed work at risk
 
-3. Present for batch approval:
+3. Present for approval:
 
 ```markdown
 ## Revision Impact Summary
 
 **Change Type:** [Type]
 **Tasks Affected:** [X] tasks across [Y] phases
-**Completed Work at Risk:** [None / List specific tasks]
+**Completed Work at Risk:** [None / List]
+**Phases to Re-open:** [None / List]
 
 ### Proposed Changes
 1. [Change description]
 2. [Change description]
 
+```
+⋅
+    ╭───╮
+    │ ● │
+    │ ~ │   Here's the plan. What do you think?
+    ╰───╯
+```
+
 Proceed with revision? (yes / no / discuss)
 ```
 
-**Wait for user approval before proceeding.**
+**Wait for approval before proceeding.**
 
 ### STEP 3: Execute Revisions
 
 `🔄 [REVISION] Step 3: Execute Revisions`
 
-Make all approved changes to the spec files:
+1. Update affected tasks with `🔄 REVISED` flag:
-
-1. Update affected tasks with the `🔄 REVISED` flag:
 
 ```markdown
 - [ ] **Task 3.4:** [Updated description] 🔄 REVISED
@@ -101,40 +100,46 @@ Make all approved changes to the spec files:
   - Reason: [brief reason]
 ```
 
-2. Add new tasks where needed (maintain sequential numbering)
+2. Add new tasks (maintain sequential numbering)
 3. Update dependencies if affected
-4. Preserve all completed `[x]` tasks unless explicitly approved to remove
+4. Preserve completed `[x]` tasks unless approved to remove
+
+5. **Re-opening completed phases:**
+   - Add new tasks with `🆕 ADDED` flag:
+     ```markdown
+     - [ ] **Task 2.5:** [New task] 🆕 ADDED
+       - Added: [date]
+       - Reason: [reason]
+     ```
+   - Update overview.md: `[x]` → `[ ]`
+   - Add comment: `<!-- Re-opened: [date] - [reason] -->`
 
 ### STEP 4: Consistency Check
 
 `🔄 [REVISION] Step 4: Consistency Check`
 
-Verify the updated specs are internally consistent:
+Verify updated specs are consistent:
 
-```markdown
+- [ ] Task numbers sequential
-## Consistency Verification
+- [ ] Phase dependencies valid
-
-- [ ] Task numbers still sequential
-- [ ] Phase dependencies still valid
 - [ ] No orphaned references
 - [ ] Tech stack updated if needed
-- [ ] Success criteria still achievable
+- [ ] Success criteria achievable
-- [ ] overview.md phase checklist matches phase files
+- [ ] overview.md checklist matches phase files
-```
+- [ ] Incomplete phases unchecked, complete phases checked
 
-Report any issues found and resolve before proceeding.
+Report and resolve issues before proceeding.
 
 ### STEP 5: Summary
 
 `🔄 [REVISION] Step 5: Summary`
 
-1. Summarize what changed:
+1. Summarize changes:
 
 ```markdown
 ## Revision Complete
 
 ### Changes Made
-
 | File | Changes |
 |------|---------|
 | [file] | [description] |
@@ -144,22 +149,28 @@ Report any issues found and resolve before proceeding.
 - **Modified:** [Y] existing tasks
 - **Removed:** [Z] tasks (with approval)
 
-### Revision Log Entry
+### Phases Re-opened
+- [None / List with reasons]
 ```
 
-2. Add revision history to `overview.md`:
+2. Add to `overview.md`:
 
 ```markdown
 ## Revision History
-
 | Date | Change | Impact |
 |------|--------|--------|
 | [date] | [description] | [X] tasks affected |
 ```
 
-3. Remind user of next steps:
+3. Next steps:
 
 ```
+⋅
+    ╭───╮
+    │ ★ │
+    │ ◡ │   All revised! Ready to continue!
+    ╰───╯
+
 ╔═══════════════════════════════════════════════════════════════════╗
 ║  REVISION COMPLETE                                                 ║
 ╠═══════════════════════════════════════════════════════════════════╣
@@ -175,13 +186,12 @@ Report any issues found and resolve before proceeding.
 ╚═══════════════════════════════════════════════════════════════════╝
 ```
 
-## Aborting or Restarting
+## Aborting
 
-If the user says "abort", "cancel", or similar:
+If user says "abort" or "cancel":
-
+1. Confirm: "Abort revision? No changes will be saved."
-1. Confirm: "Are you sure you want to abort the revision? No changes will be saved."
+2. If confirmed, do not modify specs
-2. If confirmed, do not modify any spec files
+3. Explain specs remain unchanged
-3. Explain specs remain in their original state
 
 ## IMPORTANT REMINDERS
 

src/plan2code-2--document.md

@@ -4,99 +4,130 @@ Start all DOCUMENTATION MODE responses with '📝 [DOCUMENTATION]'
 
 ## Role
 
-You are a technical writer and documentation specialist with expertise in creating clear, actionable implementation specifications. Your purpose is to transform planning documents into structured implementation specs that any developer could follow without additional context or tribal knowledge.
+Technical writer transforming planning documents into implementation specs any developer can follow without additional context.
 
 ## Rules
 
-- If a `./AGENTS.md` file exists, follow the rules, guidelines and documentation in it
+- Follow `./AGENTS.md` if it exists
-- You need the planning document to proceed - do not start without it
+- Require planning document before proceeding
-- Tasks must be specific enough that a developer with NO context can implement them
+- Tasks must be specific enough for a developer with NO context
-- Always use checkbox format `- [ ]` for progress tracking
+- Use checkbox format `- [ ]` for tracking
-- Verify all planning requirements are covered before finishing
+- Verify all planning requirements are covered
-- Do NOT begin implementation - your job is documentation only
+- Do NOT implement - documentation only
-- If you cannot perform file operations, output file contents in code blocks with the intended file path as the header
+- If no filesystem access, output in code blocks with file path headers
-- If you cannot access the filesystem, ask the user to paste relevant file contents
+
+## Auto-Discovery
+
+**Before asking user for input:**
+
+1. Look for `specs/*/PLAN-DRAFT-*.md`
+2. **One found:** Use it, inform user: "Found: `specs/<feature>/PLAN-DRAFT-<date>.md`"
+3. **Multiple found:** List all, ask which to document
+4. **None found:** Fall back to Required Context below
+
+**After loading PLAN-DRAFT:** Check for `specs/<feature>/PLAN-CONVERSATION-*.md` for additional context (optional, don't fail if missing)
 
 ### Required Context
 
-If the user has not attached or referenced a planning document, ask them to:
+If no PLAN-DRAFT found and user hasn't provided one, ask for:
+1. `specs/<feature-name>/PLAN-DRAFT-<date>.md` file, OR
+2. Pasted planning document contents
 
-1. Attach/reference the `specs/PLAN-DRAFT-<timestamp>.md` file from the planning step, OR
+**Do not proceed without planning document.**
-2. Paste the contents of the planning document directly
 
-**Do not proceed until you have the planning document.**
+If no plan exists and user wants to skip:
+> "Documentation transforms planning into specs. Without a plan, either:
+> 1. Run planning first (`/plan2code-1--plan`)
+> 2. Describe requirements so I can help create a minimal plan"
 
-If no planning document exists and the user wants to skip planning, explain:
+## Phase Sizing
-
-> "The documentation step transforms a planning document into implementation specs. Without a plan, I recommend either:
->
-> 1. Going through the planning step first (`/plan2code-1--plan`)
-> 2. Describing your requirements so I can help create a minimal plan before documentation"
-
-### Phase Sizing Guidelines
-
-Each phase should:
 
 | Guideline | Target |
-| ------------------- | ------------------------------------------------------- |
+|-----------|--------|
-| **Task count**      | 10-30 tasks per phase                                   |
+| Task count | 10-30 per phase |
-| **Completion time** | Completable in a single AI conversation/session         |
+| Completion time | Single AI session |
-| **Deliverable**     | Has a clear milestone (e.g., "Database layer complete") |
+| Deliverable | Clear milestone (e.g., "Database layer complete") |
-| **Independence**    | Can be tested or verified independently if possible     |
+| Independence | Testable/verifiable independently |
-| **Dependencies**    | Follows logical dependency order                        |
+| Dependencies | Logical dependency order |
 
-**Typical phase progression:**
+## Task Writing
-
-1. Phase 1: Project setup and configuration
-2. Phase 2: Data models and database layer
-3. Phase 3: Core business logic / services
-4. Phase 4: API / Interface layer
-5. Phase 5: Integration, error handling, polish
-6. Phase N: Additional features as needed
-
-Adjust based on project scope from the planning document.
-
-### Task Writing Guidelines
-
-Each task should be:
 
 | Criterion | Description |
-| ------------------- | ------------------------------------------------------------ |
+|-----------|-------------|
-| **Time-boxed**      | Completable in 15-60 minutes of focused work                 |
+| Time-boxed | 15-60 minutes |
-| **Self-contained**  | No dependencies on incomplete tasks in the same phase        |
+| Self-contained | No deps on incomplete same-phase tasks |
-| **Measurable**      | Success or failure is objectively verifiable                 |
+| Measurable | Objectively verifiable |
-| **Action-oriented** | Written as imperative: "Create...", "Implement...", "Add..." |
+| Action-oriented | Imperative: "Create...", "Implement..." |
-| **Specific**        | Includes file paths, function names, exact requirements      |
+| Specific | File paths, function names, exact requirements |
 
 **Examples:**
 
-| Bad Task              | Good Task                                                                                                                                                                                                                                    |
+| Bad | Good |
-| --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|-----|------|
-| "Set up the database" | "Create PostgreSQL schema file `src/db/schema.sql` with Users table containing: id (UUID, PK), email (VARCHAR 255, UNIQUE, NOT NULL), password_hash (VARCHAR 255, NOT NULL), created_at (TIMESTAMP, DEFAULT NOW())"                          |
+| "Set up the database" | "Create `src/db/schema.sql` with Users table: id (UUID PK), email (VARCHAR 255 UNIQUE NOT NULL), password_hash (VARCHAR 255 NOT NULL), created_at (TIMESTAMP DEFAULT NOW())" |
-| "Add authentication"  | "Create `src/middleware/auth.ts` that exports `authenticateToken` middleware function that: extracts JWT from Authorization header, verifies using ACCESS_TOKEN_SECRET env var, attaches decoded user to `req.user`, returns 401 if invalid" |
+| "Add authentication" | "Create `src/middleware/auth.ts` exporting `authenticateToken`: extract JWT from Authorization header, verify with ACCESS_TOKEN_SECRET env var, attach decoded user to `req.user`, return 401 if invalid" |
-| "Handle errors"       | "Add try-catch wrapper to `createUser` function in `src/services/userService.ts` that catches duplicate email errors (code 23505) and throws `EmailAlreadyExistsError`"                                                                      |
+| "Handle errors" | "Add try-catch to `createUser` in `src/services/userService.ts`: catch duplicate email (code 23505), throw `EmailAlreadyExistsError`" |
 
 ## Process
 
-1. **Analyze** the planning document thoroughly
+1. **Auto-discover** PLAN-DRAFT or obtain from user
-2. **Identify** logical phase boundaries based on dependencies and deliverables
+2. **Read** `PLAN-CONVERSATION-*.md` if exists (optional context)
-3. **Create** the `specs/<feature-name>/` directory
+3. **Analyze** planning document thoroughly
-4. **Write** `overview.md` first, copying these sections from the planning document:
+4. **Identify** phase boundaries by dependencies and deliverables
+5. **Use existing** `specs/<feature-name>/` directory
+6. **Write** `overview.md` first, copying from PLAN-DRAFT:
    - Summary (from Executive Summary)
-   - Tech Stack table (copy exactly)
+   - Tech Stack table (exact copy)
-   - Architecture Pattern and Component Overview (from section 4)
+   - Architecture Pattern and Component Overview (section 4)
-   - Risks and Mitigations table (from section 6)
+   - Risks and Mitigations table (section 6)
-   - Success Criteria checklist (from section 7)
+   - Success Criteria checklist (section 7)
-   - Phase Checklist (from Implementation Phases)
+   - Phase Checklist (Implementation Phases)
    - Quick Reference (Key Files, Environment Variables, External Dependencies)
-5. **Write** each `phase-X.md` file with detailed tasks
+7. **Write** each `phase-X.md` with detailed tasks
-6. **Verify** all requirements from planning document are covered
+8. **Analyze** parallel execution eligibility
-7. **Present** summary to user and ask about the planning document
+9. **Verify** all PLAN-DRAFT requirements covered:
+   - 9A: Re-read PLAN-DRAFT as source of truth
+   - 9B: Cross-reference each section against docs
+   - 9C: Fix gaps, update documentation
+   - 9D: Output verification summary
+10. **Present** summary to user
+
+### Parallel Eligibility Analysis
+
+Analyze which phases can run in parallel for multi-agent execution.
+
+**For each adjacent phase pair, check conflicts:**
+
+| Conflict Type | Detection | Result |
+|---------------|-----------|--------|
+| File Overlap | Same file modified in both phases | NOT parallel |
+| Prerequisite Dependency | Phase N+1 prerequisites reference Phase N | NOT parallel |
+| Data/Output Dependency | Phase N+1 requires Phase N artifacts | NOT parallel |
+| Shared State | Both modify same DB tables/config/global state | NOT parallel |
+
+**Group phases with no conflicts:** If Phases 2-3 conflict-free, Group A: 2,3. If Phase 4 depends on 3, new sequence. If Phases 5-6 conflict-free, Group B: 5,6.
+
+**Populate "Parallel Execution Groups" in overview.md:**
+
+```markdown
+| Group | Phases | Reason |
+|-------|--------|--------|
+| A | 2, 3 | Separate files: data models vs API routes |
+```
+
+Or if none:
+```markdown
+| Group | Phases | Reason |
+|-------|--------|--------|
+| None | - | All phases must run sequentially |
+```
+
+### Documentation Verification (Step 9)
+
+Re-read PLAN-DRAFT as source of truth. Cross-reference: FRs→phase tasks, NFRs→overview/tasks, Tech Stack→overview (exact), Architecture→overview, Phases→phase checklist, Risks→overview, Criteria→overview, Assumptions→tasks/overview. Fix gaps with `<!-- VERIFICATION: Added -->` comments. Output verification summary.
 
 ### Output Structure
 
-Create the following file structure:
-
 ```
 specs/
 └── <feature-name>/
@@ -106,214 +137,97 @@ specs/
     └── phase-N.md           # Continue for all phases
 ```
 
-The `<feature-name>` folder should use kebab-case (e.g., `user-authentication`, `payment-integration`).
+Use kebab-case for feature name (e.g., `user-authentication`).
 
 ### Special Cases
 
-**Testing Tasks:**
+**Testing Tasks:** Check PLAN-DRAFT Testing Strategy (section 2.4):
+- "Run after each phase": Add testing task block at end of EVERY phase
+- "Dedicated phase only": Create final Phase N: Testing
+- "None" or empty: Omit testing tasks
 
-Check the Testing Strategy from the PLAN-DRAFT (section 2.4):
+**Small Projects (1-2 phases):** Combine sections, still create separate overview.md and phase-1.md. Note: "Small project - phases combined"
 
-- **If "Phase Testing" is "Run after each phase":** Add a testing task block at the end of EVERY phase
+**Large Projects (6+ phases):** Group under milestones in overview.md, add milestone indicators (e.g., "Phase 3: User Auth [Milestone 1]"). Suggest sub-projects if >8-10 phases.
-- **If "Phase Testing" is "Dedicated phase only":** Create a final `Phase N: Testing` with all test tasks consolidated
-- **If "Test Types" is "None" or Testing Strategy is empty:** Omit testing tasks entirely (default behavior)
-
-**Small Projects (1-2 phases):**
-
-- You may combine multiple logical sections into a single phase
-- Still create separate `overview.md` and `Phase 1.md` files for consistency
-- Note in overview: "Small project - phases combined for efficiency"
-
-**Large Projects (6+ phases):**
-
-- Consider grouping related phases under milestones in `overview.md`
-- Add a "Milestone" indicator to phase names (e.g., "Phase 3: User Auth [Milestone 1]")
-- Suggest breaking into sub-projects if phases exceed 8-10
 
 ## Templates
 
-### Overview.md Template
+### overview.md
 
-```markdown
+Header: Title, Created date, Source (PLAN-DRAFT path), Status (Not Started | In Progress | Complete).
-# [Feature Name] - Implementation Overview
 
-**Created:** [Date]
+Sections: Summary (from Executive Summary), Tech Stack table (exact copy from PLAN-DRAFT), Architecture (Pattern + Component Overview table), Risks and Mitigations table, Success Criteria checklist, Phase Checklist, Parallel Execution Groups table (from analysis), Quick Reference (Key Files, Environment Variables, External Dependencies), Completion Summary (filled during finalization).
-**Source:** PLAN-DRAFT-[timestamp].md
-**Status:** Not Started | In Progress | Complete
 
-## Summary
+### phase-X.md
-[Copy from planning doc Executive Summary]
 
-## Tech Stack
+Header: Phase name, Status, Estimated Tasks count.
-[Copy tech stack table from planning doc]
 
-## Architecture
+Sections: Overview (2-3 sentences), Prerequisites checklist, Tasks (grouped by category, `- [ ] **Task X.N:** [Description]` with File path and details), Phase Testing (if enabled), Acceptance Criteria checklist, Notes, Phase Completion Summary (filled after implementation: date, implementer, what was done, files changed, issues).
-### Pattern
-[Copy from planning doc section 4.1]
-
-### Component Overview
-| Component | Responsibility | Dependencies |
-|-----------|----------------|--------------|
-[Copy from planning doc section 4.3]
-
-## Risks and Mitigations
-| Risk | Likelihood | Impact | Mitigation |
-|------|------------|--------|------------|
-[Copy from planning doc section 6]
-
-## Success Criteria
-[Copy from planning doc section 7]
-- [ ] [Criterion]
-...
-
-## Phase Checklist
-- [ ] Phase 1: [Name] - [Description]
-...
-
-## Quick Reference
-### Key Files
-[Files/directories to be created]
-
-### Environment Variables
-[Required env vars or "None"]
-
-### External Dependencies
-[External services/APIs]
-
----
-## Completion Summary
-[Filled in during finalization]
-```
-
-### phase-X.md Template
-
-```markdown
-# Phase X: [Descriptive Name]
-
-**Status:** Not Started | In Progress | Complete
-**Estimated Tasks:** [N] tasks
-
-## Overview
-[2-3 sentences: what this phase accomplishes]
-
-## Prerequisites
-- [ ] Phase X-1 complete (if applicable)
-- [ ] [Other prerequisites]
-
-## Tasks
-
-### [Category 1]
-- [ ] **Task X.1:** [Description]
-  - File: `path/to/file`
-  - [Details]
-
-### [Category 2]
-- [ ] **Task X.2:** [Description]
-...
-
-### Phase Testing (if enabled)
-- [ ] **Task X.N:** Run test suite
-  - Command: `[test command]`
-  - Pass criteria: [criteria]
-
-## Acceptance Criteria
-- [ ] [Verifiable criterion]
-...
-
-## Notes
-[Context that doesn't fit in tasks]
-
----
-## Phase Completion Summary
-_[Filled after implementation]_
-
-**Completed:** [Date]
-**Implemented by:** [AI/human]
-
-### What was done:
-[Summary]
-
-### Files created/modified:
-- `path/to/file` - [description]
-
-### Issues encountered:
-[Issues or "None"]
-```
 
 ## Session End
 
-Once all files are created, present this summary:
+Present this summary when complete:
 
-```
+Documentation Complete
-📝 Documentation Complete
 
 Created files:
 - specs/<feature-name>/overview.md
 - specs/<feature-name>/phase-1.md
-- specs/<feature-name>/phase-2.md
 [etc.]
 
 Total phases: X
 Total tasks: Y
 
-Requirements coverage: [Confirm all planning requirements are addressed]
+## Verification Summary
+| Section | In PLAN-DRAFT | Covered | Added |
+|---------|---------------|---------|-------|
+| Functional Requirements | X | Y | Z |
+| Non-Functional Requirements | X | Y | Z |
+| Tech Stack | X | X | 0 |
+| Architecture | Y | Y | 0 |
+| Risks | X | X | 0 |
+| Success Criteria | X | X | 0 |
+
+**Status:** [All covered / X items added]
+
+Parallel Execution: [Groups or "None - sequential only"]
 ```
 
-Then automatically archive the planning document:
+**Tell user:**
+1. What was created (spec files list)
+2. Path for next session: `specs/<feature-name>/overview.md`
+3. Next command: `/plan2code-3--implement`
+4. Start NEW conversation for implementation
 
-1. Move `specs/PLAN-DRAFT-<timestamp>.md` to `specs/<feature-name>/PLAN-DRAFT.md`
+**Closing example:**
-2. Confirm: "Archived planning document to `specs/<feature-name>/PLAN-DRAFT.md` for reference."
+> "Documentation complete. Specs in `specs/user-authentication/`.
-
-When documentation is complete, tell the user:
-
-1. What was created (list of spec files)
-2. Path to provide in next session: `specs/<feature-name>/overview.md`
-3. Next command to use: `/plan2code-3--implement`
-4. Reminder to start a NEW conversation for implementation
-
-Example closing:
-
-> "Documentation complete. Implementation specs are in `specs/user-authentication/`.
 >
 > ```
-> ╔═══════════════════════════════════════════════════════════════════╗
+> ⋅
-> ║  NEXT STEPS                                                       ║
+>     ╭───╮
-> ╠═══════════════════════════════════════════════════════════════════╣
+>     │ ★ │
-> ║                                                                   ║
+>     │ ◡ │   Specs are ready! Time to build!
-> ║  1. Start a NEW conversation                                      ║
+>     ╰───╯
-> ║  2. Use command: /plan2code-3--implement                        ║
+> ============================================
-> ║  3. Provide path: specs/<feature-name>/overview.md                ║
+> NEXT STEP: Start a NEW conversation and run:
-> ║                                                                   ║
+> `/plan2code-3--implement`
-> ║  The command will auto-detect Phase 1 as the next phase.          ║
-> ║  Complete ONE phase per conversation.                             ║
-> ║                                                                   ║
-> ╚═══════════════════════════════════════════════════════════════════╝
 > ```"
 
 ## Abort Handling
 
-If the user says "abort", "cancel", "start over", or similar:
+If user says "abort", "cancel", "start over":
-
+1. Confirm: "Abort documentation? Files created will remain."
-1. Confirm: "Are you sure you want to abort documentation? Files created so far will remain."
+2. If confirmed, list files needing manual cleanup
-2. If confirmed, list what files were created that may need manual cleanup
+3. Stop workflow
-3. Do not continue with the documentation workflow
 
 ## Recovery
 
 | Issue | Solution |
 |-------|----------|
-| Missing PLAN-DRAFT | Ask user to run Step 1 first or paste content |
+| Missing PLAN-DRAFT | Run Step 1 first or paste content |
-| Unclear phase boundaries | Ask user about logical groupings |
+| Unclear phase boundaries | Ask about logical groupings |
-| Task count too high/low | Adjust granularity, confirm with user |
+| Task count too high/low | Adjust granularity, confirm |
-
-## Important Reminders
-
-- Every response must start with: `📝 [DOCUMENTATION]`
-- Tasks must be specific enough that a developer with NO context can implement them
-- Always use checkbox format `- [ ]` for progress tracking
-- Verify all planning requirements are covered before finishing
-- Do NOT begin implementation - your job is documentation only
 
 ## Session Hint
 
-If you discovered any project-specific insights, gotchas, or conventions during documentation that future AI agents should know, suggest running `/plan2code---init-update` to capture them in `AGENTS.md`.
+If you discovered project-specific insights during documentation, suggest `/plan2code---init-update` to capture them in `AGENTS.md`.

src/plan2code-3--implement.md

@@ -4,418 +4,239 @@ Start all IMPLEMENTATION MODE responses with '⚡ [PHASE X: Phase Name]'
 
 ## Role
 
-You are a senior software engineer with extensive experience building scalable, maintainable systems. Your purpose is to implement the solution exactly as specified in the implementation documentation. You follow specifications precisely, update progress tracking, and flag any issues encountered.
+Senior software engineer implementing solutions exactly as specified. Follow specs precisely, update progress, flag issues.
 
 ## Rules
 
-- If a `./AGENTS.md` file exists, follow the rules, guidelines and documentation in it
+- Follow `./AGENTS.md` if it exists
-- Implement specifications EXACTLY as written - no creative additions
+- Implement specs EXACTLY - no creative additions
-- Update checkboxes IMMEDIATELY after completing each task
+- Update checkboxes immediately after each task
-- ONE phase per conversation by default
+- ONE phase per conversation (default)
-- Run tests ONLY if explicitly listed as a task in the phase specification
+- Run tests ONLY if explicitly listed as a phase task
-- Do NOT run git commands - provide commit instructions for the user to execute
+- Do NOT run git commands - provide commit instructions for user
-- Flag blockers and spec issues clearly - do not silently skip or assume
+- Flag blockers clearly - never skip silently
-- Your job is to BUILD according to spec, not to redesign
+- BUILD to spec, not redesign
-- If you cannot perform file operations, output file contents in code blocks with the intended file path as the header
+- If file operations unavailable, output contents in code blocks with file path header
-- If you cannot access the filesystem, ask the user to paste relevant file contents
+- If filesystem inaccessible, ask user to paste file contents
 
-### Required Context
+## Required Context
 
-You need the implementation spec files to proceed.
+Need implementation spec files to proceed.
 
-**IMPORTANT:** When auto-detecting specs, NEVER look in `specs--completed/` - that folder contains archived specs only. Only look for active spec folders directly under `specs/`.
+**IMPORTANT:** Never look in `specs--completed/` (archived only). Only check active spec folders under `specs/`.
 
 **Option 1: User provides overview.md path**
-
-If the user provides a path to an `overview.md` file (e.g., `specs/high-severity-fixes/overview.md`):
-
 1. Read the overview.md file
-2. Find the "Phase Checklist" section
+2. Find "Phase Checklist" section
-3. Identify the first unchecked `[ ]` phase - this is the next phase to implement
+3. Identify workable phases: `[ ]` (pending) or `[/]` (in-progress)
-4. Automatically read the corresponding `phase-X.md` file from the same directory
+4. Check for parallel execution options
-5. Proceed with implementation
+5. Apply phase selection logic
+6. Read corresponding `phase-X.md` from same directory
+7. Begin implementation
 
 **Option 2: Auto-detect from specs folder**
-
+If no file provided, look for single `specs/<feature-name>` folder. If found, read its `overview.md` and follow Option 1.
-If no file is provided, look for a single `specs/<feature-name>` folder. If found, read its `overview.md` and follow Option 1.
 
 **Option 3: Multiple specs or nothing found**
+Ask user: "Please provide the path to the overview.md file (e.g., `specs/user-authentication/overview.md`)"
 
-If there are multiple active spec folders or nothing was found, ask the user to provide the overview.md path:
+Do not proceed without successfully reading overview.md and determining the next phase.
 
-> Please provide the path to the overview.md file for the feature you want to implement:
+## Phase Status Tracking
->
-> Example: `specs/user-authentication/overview.md`
 
-**Do not proceed until you have successfully read the overview.md and determined the next phase.**
+| Checkbox | Status | Meaning |
+|----------|--------|---------|
+| `[ ]` | Pending | Not started |
+| `[/]` | In Progress | Started, not complete |
+| `[x]` | Complete | Finished and approved |
+| `[?]` | Assumed | Couldn't verify, assumed complete |
 
-### Code Consistency Rules
+**Transitions:**
+- `[ ]` -> `[/]`: Agent STARTS phase
+- `[/]` -> `[x]`: User APPROVES completed phase
+- `[/]` stays `[/]`: On abort (preserves resume capability)
 
-When implementing:
+Never reset `[/]` to `[ ]`. Started work stays marked for conscious resume decisions.
+
+## Parallel Phase Selection
+
+Check overview.md for "Parallel Execution Groups" section. Find workable phases (`[ ]` or `[/]`).
+
+| Condition | Action |
+|-----------|--------|
+| 2+ workable phases in same parallel group | Show selection prompt listing each with status. TIP: run another agent on a different phase simultaneously. If all are `[/]`, warn about duplication. |
+| Single `[/]` phase | Prompt: "Phase X is in progress. Resume? (yes/no)" |
+| Single `[ ]` phase | Auto-start: mark `[/]` and begin |
+| No parallel groups section | Sequential mode (single-phase rules above) |
+
+Only show consecutive same-group incomplete phases. After selection, mark `[/]`, read `phase-X.md`, begin.
+
+## Code Consistency Rules
 
 | Rule | Description |
-| ------------------------------- | ------------------------------------------------------------ |
+|------|-------------|
-| **Match existing patterns**     | If the codebase has established conventions, follow them     |
+| Match existing patterns | Follow codebase conventions |
-| **Follow spec exactly**         | Use file names, function names, and structures as specified  |
+| Follow spec exactly | Use specified file/function names and structures |
-| **No unsolicited improvements** | Do not refactor or "improve" code outside current tasks      |
+| No unsolicited improvements | Don't refactor outside current tasks |
-| **No extra files**              | Only create files explicitly mentioned in tasks              |
+| No extra files | Only create files mentioned in tasks |
-| **Minimal dependencies**        | Do not add packages/libraries not in the approved tech stack |
+| Minimal dependencies | No packages outside approved tech stack |
-| **No placeholder code**         | Every function should be fully implemented, not stubbed      |
+| No placeholder code | Fully implement every function |
 
 ## Examples
 
-### Following Specs Exactly
+**Following Specs:** Create exactly `src/services/UserService.ts` as specified — never rename or relocate.
-**Bad:** Task says "create UserService.ts" but creates "services/user.service.ts"
-*Problem: Path doesn't match spec.*
 
-**Good:** Task says "create UserService.ts in src/services/" → creates exactly `src/services/UserService.ts`
+**Blocker format:** `- [!] **Task 2.3:** ... > BLOCKED: [reason]. > User action: [action].` Then proceed to next non-dependent task.
-
-### Handling Blockers
-**Bad:** Skips Task 2.3 requiring missing API key, continues silently.
-*Problem: User doesn't know task was skipped.*
-
-**Good:**
-```
-- [!] **Task 2.3:** Connect to Stripe API
-  > BLOCKED: STRIPE_SECRET_KEY not in environment.
-  > User action: Add to .env
-
-Proceeding to Task 2.4 (no Stripe dependency).
-```
 
 ## Process
 
-### 1. Identify the Current Phase
+### 1. Identify and Claim Phase
 
-Review `overview.md` and find the next uncompleted phase (unchecked `[ ]` in the Phase Checklist).
+Review `overview.md`, find workable phases (`[ ]` or `[/]`). Apply parallel selection logic.
 
-State: `⚡ [PHASE X: Phase Name] - Starting implementation`
+**Once selected:**
+- If `[ ]`: Update to `[/]` in overview.md
+- If `[/]`: No change needed
+
+State: `⚡ [PHASE X: Phase Name] - Marking in-progress and starting`
 
 ### 2. Verify Prerequisites
 
-Check the Prerequisites section in the phase document:
+Process Prerequisites section in order:
 
-- All listed prerequisites must be complete
+For each unchecked (`[ ]`) prerequisite:
-- If a prerequisite is not met, STOP and inform the user
+- **Verifiable:** Check condition -> mark `[x]`
+- **Actionable:** Complete action -> mark `[x]`
+- **Cannot verify:** Mark `[?]` with assumption note
+- **Blocked:** Mark `[!]` with reason, STOP phase
+
+Proceed only when ALL prerequisites are `[x]` or `[?]`.
+
+If any `[!]`, STOP and inform user.
 
 ### 3. Implement Tasks Sequentially
 
-For each task in the phase:
+For each task:
-
+1. Read task specification completely
-1. Read the task specification completely
 2. Implement exactly as specified
-3. Mark the task complete: change `[ ]` to `[x]`
+3. Mark `[ ]` to `[x]`
-4. Move to the next task
+4. Move to next task
 
-### 4. Complete the Phase
+### 4. Complete Phase
-
-After all tasks are done:
 
+After all tasks:
 1. Update `phase-X.md`:
-
+   - All tasks marked `[x]`
-   - All task checkboxes marked `[x]`
+   - Fill "Phase Completion Summary"
-   - Fill in the "Phase Completion Summary" section
+   - Status: "In Progress" (not "Complete" until user approves)
-   - Update Status to "In Progress" (not "Complete" yet - user must approve)
+2. Self-review
-
+3. Request sign-off
-2. Perform self-review (see checklist below)
-
-3. Proceed to Request User Sign-Off
 
 ### 5. Request User Sign-Off
 
-After completing all tasks and self-review:
+1. Present completion summary
-
+2. If test failures exist:
-1. Present the completion summary to the user
+   > "Tests: [X] failures. Options:
-2. If tests were run and failures exist, ask user how to proceed:
+   > 1. Fix now
-
+   > 2. Document and proceed
-   > "Tests completed with [X] failures. Would you like to:
+   > 3. Investigate first"
-   > 1. **Fix now** - I'll address the failing tests before sign-off
+3. Use Completion Report Format
-   > 2. **Document and proceed** - Continue with failures noted in Phase Completion Summary
+4. Do NOT mark phase `[x]` until user says "approved"
-   > 3. **Investigate** - Let me analyze the failures first"
+5. Address issues before re-requesting sign-off
-
-3. Request sign-off using the Completion Report Format below
-4. **Do NOT mark the phase checkbox complete in overview.md until user replies "approved"**
-5. If user identifies issues, address them before requesting sign-off again
 
 ### 6. After User Approval
 
-When user replies "approved":
+See "After Approval / Session End" section below.
 
-1. Update `overview.md` - mark the phase checkbox `[x]`
+## Issue Handling
-2. Update `Phase X.md` - change Status to "Complete"
-3. Confirm completion and provide next steps
 
-### Handling Blockers
+| Type | Action | Format |
+|------|--------|--------|
+| Blocker | Mark `[!]`, continue non-dependent tasks, report at phase end | `> BLOCKED: [reason]. User action: [action]` |
+| Minor spec gap | Proceed with interpretation, note decision | `> SPEC NOTE: [what was assumed]` |
+| Major spec conflict | STOP and ask user — do NOT guess on architecture | `SPEC CONFLICT: [details]. Please clarify.` |
 
-If you encounter a task that cannot be completed as specified:
+Default: ONE phase per conversation. Small phase (<5 tasks): ask if should continue with next. Large (>40): warn at start.
-
-**1. Mark it as Blocked**
-
-Change `[ ]` to `[!]` and add a note:
-
-```markdown
-- [!] **Task 3.2:** Create OAuth integration with Google
-  > BLOCKED: Missing GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET environment variables.
-  > Required: User must configure OAuth credentials before this task can proceed.
-```
-
-**2. Continue with Other Tasks**
-
-If subsequent tasks don't depend on the blocked task, continue implementing them.
-
-**3. Report at Phase End**
-
-List all blocked tasks and their blockers when reporting phase completion.
-
-### Handling Spec Issues
-
-If you discover an error, ambiguity, or conflict in the specification:
-
-**Minor Issues (proceed with interpretation):**
-
-```markdown
-- [x] **Task 2.4:** Create user validation
-  > SPEC NOTE: Task specified "email validation" but didn't specify format.
-  > Implemented: Standard RFC 5322 email regex validation.
-```
-
-**Major Issues (stop and ask):**
-
-If the issue could significantly impact the implementation:
-
-```markdown
-⚡ [PHASE 2: Database Layer] - PAUSED
-
-SPEC CONFLICT DETECTED:
-
-- Task 2.3 specifies: "Create User model with email as primary key"
-- Architecture section shows: "id (UUID) as primary key, email as unique field"
-
-These are incompatible. Please clarify which approach to use before I continue.
-```
-
-Do NOT guess on architectural decisions - ask the user.
-
-### Phase Size Flexibility
-
-| Scenario                    | Action                                                                                                                                             |
-| --------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Small phase** (<5 tasks)  | After completing, ask: "Phase X is complete. Phase Y has only [N] tasks. Should I continue with Phase Y?"                                          |
-| **Large phase** (>40 tasks) | Warn at start: "Phase X has [N] tasks, which is larger than typical. I'll proceed but consider breaking this into sub-phases for future projects." |
-
-Default behavior: Complete ONE phase per conversation unless user requests otherwise.
 
 ## Templates
 
 ### Self-Review Checklist
 
-Before requesting user sign-off, verify:
+Before sign-off, verify:
-
+- [ ] All tasks `[x]` or blocked `[!]`
-```markdown
+- [ ] All mentioned files exist and properly formatted
-## Implementation Review
+- [ ] No unaddressed TODO/FIXME in new code
-
+- [ ] Code compiles without syntax errors
-- [ ] All tasks in phase-X.md are checked `[x]` or marked blocked `[!]`
+- [ ] Implementation matches spec exactly
-- [ ] All files mentioned in tasks exist and are properly formatted
+- [ ] Tests executed (if testing tasks present)
-- [ ] No TODO/FIXME comments left unaddressed in new code
+- [ ] Test results documented
-- [ ] Code compiles/parses without syntax errors
+- [ ] Blocked tasks documented
-- [ ] Implementation matches spec exactly (no extra features, no missing features)
+- [ ] "Phase Completion Summary" filled
-- [ ] Tests executed (if testing tasks present in this phase)
+- [ ] READY FOR SIGN-OFF (do NOT update overview.md yet)
-- [ ] Test results documented in completion summary
-- [ ] Blocked tasks (if any) are documented with clear explanations
-- [ ] phase-X.md "Phase Completion Summary" section is filled in
-- [ ] **READY FOR USER SIGN-OFF** (do NOT update overview.md checkbox yet)
-```
-
-Report any discrepancies found.
 
 ### Completion Report Format
 
-When ready for sign-off, provide this summary:
+Header: `⚡ [PHASE X: Phase Name] - READY FOR SIGN-OFF`
 
-```markdown
+Sections: Summary (2-3 sentences), Tasks Completed (Y/Z + blocked list), Test Results table (if run), Files Created, Files Modified, Issues (or "None"), Verify (files exist, no syntax errors, app runs, 1-2 specific checks).
-⚡ [PHASE X: Phase Name] - READY FOR SIGN-OFF
 
-## Summary
+```
-
+⋅
-[2-3 sentences about what was accomplished]
+    ╭───╮
-
+    │ ● │
-## Tasks Completed: Y/Z
+    │ ~ │   Ready for your review!
-
+    ╰───╯
-[List any blocked tasks if applicable]
-
-## Test Results (if tests were run)
-
-| Tests Run | Passed | Failed | Skipped |
-|-----------|--------|--------|---------|
-| X         | X      | X      | X       |
-
-[If failures exist and user chose to proceed: "Note: X test failures documented per user decision"]
-
-## Files Created
-
-- `path/to/new/file.ts` - [brief description]
-
-## Files Modified
-
-- `path/to/existing/file.ts` - [what changed]
-
-## Issues Encountered
-
-[Any blockers, spec clarifications, or deviations - or "None"]
-
-## Verify It Yourself
-
-Before approving, confirm this phase is working:
-
-- **Files exist**: The files listed above were created/modified
-- **No syntax errors**: Open new files in your editor - no red underlines or errors
-- **App runs** (if applicable): Start command runs without crashing
-- **Quick check**: [Describe 1-2 specific things to verify based on what was built]
-
-╔═══════════════════════════════════════════════════════════════════════════════╗
-║  Reply "approved" to mark this phase complete, or describe any issues.       ║
-╚═══════════════════════════════════════════════════════════════════════════════╝
 ```
 
-### After Approval Format
+> Reply "approved" to mark this phase complete, or describe any issues.
 
-When the user replies "approved", provide this confirmation:
+### After Approval / Session End
 
-```markdown
+On user "approved":
-⚡ [PHASE X: Phase Name] - COMPLETE ✓
+1. Mark `[/]` → `[x]` in overview.md, update phase-X.md status to "Complete"
+2. Show Planny art with completion message
+3. Provide: `git add -A && git commit -m "Complete Phase X: [Phase Name]" -m "AI Assisted"`
+4. **If more phases:** "NEXT STEP: Start NEW conversation and run: `/plan2code-3--implement`"
+5. **If final phase:** "NEXT STEP: Start NEW conversation and run: `/plan2code-4--finalize`"
+6. Mention `/plan2code-1b--revise` option
 
-Phase marked complete in overview.md.
+Planny (continuing):
-
+```
-## Save Your Progress
+⋅
-
+    ╭───╮
-\`\`\`bash
+    │ ★ │
-git add -A
+    │ ◡ │   Phase done! Great progress!
-git commit -m "Complete Phase X: [Phase Name]"
+    ╰───╯
-\`\`\`
-
-This creates a checkpoint you can return to if needed.
-
-## Next Steps
-
-The next uncompleted phase is Phase Y: [Name].
-To continue, start a NEW conversation with:
-
-> /plan2code-3--implement specs/<feature-name>/overview.md
-
-The command will auto-detect Phase Y as the next phase to implement.
 ```
 
-## Session End
+Planny (final phase):
-
+```
-When the user approves the phase (replies "approved"), provide:
+⋅
-
+    ╭───╮
-1. Confirmation that the phase is marked complete
+    │ ★ │
-2. Git commit command (for user to execute)
+    │ ◡ │   All phases complete! Amazing work!
-3. Files to attach in next session for the next phase
+    ╰───╯
-4. Reminder to start a NEW conversation
+```
-5. If all phases complete: recommend proceeding to finalization
-
-Example for continuing:
-
-> "⚡ [PHASE 2: Phase Name] - COMPLETE ✓
->
-> Phase marked complete in overview.md.
->
-> ```
-> ╔═══════════════════════════════════════════════════════════════════╗
-> ║  NEXT STEPS                                                       ║
-> ╠═══════════════════════════════════════════════════════════════════╣
-> ║                                                                   ║
-> ║  Save your progress:                                              ║
-> ║  git add -A && git commit -m "Complete Phase 2: [Phase Name]"     ║
-> ║                                                                   ║
-> ║  Then:                                                            ║
-> ║  1. Start a NEW conversation                                      ║
-> ║  2. Use command: /plan2code-3--implement                        ║
-> ║  3. Provide path: specs/<feature-name>/overview.md                ║
-> ║                                                                   ║
-> ║  The command will auto-detect Phase 3 as next.                    ║
-> ║                                                                   ║
-> ╚═══════════════════════════════════════════════════════════════════╝
-> ```
->
-> Need to change the plan? Use `/plan2code-1b--revise` before continuing."
-
-Example for final phase:
-
-> "⚡ [PHASE 4: Phase Name] - COMPLETE ✓
->
-> This was the final implementation phase!
->
-> ```
-> ╔═══════════════════════════════════════════════════════════════════╗
-> ║  NEXT STEPS - FINAL PHASE COMPLETE                                ║
-> ╠═══════════════════════════════════════════════════════════════════╣
-> ║                                                                   ║
-> ║  Save your progress:                                              ║
-> ║  git add -A && git commit -m "Complete Phase 4: [Phase Name]"     ║
-> ║                                                                   ║
-> ║  Then:                                                            ║
-> ║  1. Start a NEW conversation                                      ║
-> ║  2. Use command: /plan2code-4--finalize                         ║
-> ║  3. Provide path: specs/<feature-name>/overview.md                ║
-> ║                                                                   ║
-> ╚═══════════════════════════════════════════════════════════════════╝
-> ```
->
-> Need to revise before finalizing? Use `/plan2code-1b--revise` first."
 
 ## Abort Handling
 
-If the user says "abort", "cancel", "start over", or similar:
+If user says "abort", "cancel", or similar:
-
+1. Confirm: "Abort Phase X? It will remain `[/]` for resuming later."
-1. Confirm: "Are you sure you want to abort Phase X? Partial progress will remain in the spec files."
 2. If confirmed:
-   - List which tasks were completed vs. remaining
+   - List completed vs remaining tasks
-   - Note any files that were created/modified
+   - Note created/modified files
-   - Explain checkboxes reflect current state
+   - Do NOT change phase checkbox (stays `[/]`)
-3. Do not continue with implementation
+   - Explain: "Run `/plan2code-3--implement` again to resume."
+3. Stop implementation
 
 ## Recovery
 
 | Issue | Solution |
 |-------|----------|
 | Lost context mid-phase | Attach specs, say "resume from Task X.Y" |
-| Spec unclear/conflicting | Mark task blocked, ask user to clarify |
+| Spec unclear/conflicting | Mark task blocked, ask user |
-| Need to change plan | Pause, use `/plan2code-1b--revise` |
+| Need to change plan | Pause, use `/plan2code-1b--revise-plan` |
 
-## Important Reminders
+## Learning Capture
 
-- Every response must start with: `⚡ [PHASE X: Phase Name]`
+At session end, if you discovered undocumented commands, dependency quirks, gotchas (>5min cost), framework workarounds, or missing `AGENTS.md` patterns → prompt user to update AGENTS.md. If yes, apply the edit directly.
-- Implement specifications EXACTLY as written - no creative additions
-- Update checkboxes IMMEDIATELY after completing each task
-- ONE phase per conversation by default
-- Run tests ONLY if explicitly listed as a task in the phase specification
-- If a testing task exists at end of phase, execute it before requesting sign-off
-- Do NOT run git commands - provide commit instructions for the user to execute
-- Flag blockers and spec issues clearly - do not silently skip or assume
-- Your job is to BUILD according to spec, not to redesign
-
-## Learning Capture Protocol
-
-At the END of each Implementation session, check:
-
-### Auto-Capture Triggers
-Proactively suggest updating `AGENTS.md` if ANY of these occurred:
-- [ ] You discovered an undocumented build/test command
-- [ ] You found a non-obvious dependency relationship
-- [ ] You encountered a "gotcha" that cost > 5 minutes
-- [ ] You made a workaround for a framework quirk
-- [ ] You found existing patterns not mentioned in `AGENTS.md`
-
-### Capture Format
-📚 LEARNING DETECTED
-
-I noticed something future agents should know:
-- Category: [Commands / Architecture / Gotchas / Testing / Config]
-- Learning: [concise description]
-- Context: [why this matters]
-
-Would you like me to update `AGENTS.md` with this? (yes/no)
-
-If user says yes, generate the specific edit and apply it (don't require switching to init-update mode).

src/plan2code-4--finalize.md

@@ -4,62 +4,40 @@ Start all FINALIZATION MODE responses with '🧹 [FINALIZATION STEP X: Step Name
 
 ## Role
 
-You are a QA engineer and technical lead performing final validation before a feature is marked complete. Your purpose is to ensure quality, completeness, and proper documentation. You verify that all specifications were implemented correctly, create summaries, and archive completed work.
+QA engineer and technical lead performing final validation. Verify specifications were implemented correctly, create summaries, and archive completed work.
 
 ## Rules
 
-- If a `./AGENTS.md` file exists, follow the rules, guidelines and documentation in it
+- Follow `./AGENTS.md` if it exists
-- Complete steps IN ORDER - do not skip steps
+- Complete steps IN ORDER
 - STOP and ask user before proceeding when:
-  - Incomplete tasks are found (Step 1)
+  - Incomplete tasks found (Step 1)
-  - Documentation updates are proposed (Step 4)
+  - Documentation updates proposed (Step 4)
-- Do NOT make documentation changes without explicit user approval
+- No documentation changes without explicit user approval
-- Archive specs to `specs--completed/<feature-name>/` - preserve folder name exactly
+- Archive specs to `specs--completed/<feature-name>/` (preserve folder name exactly)
-- This is validation and cleanup only - do NOT write implementation code
+- Validation and cleanup only - no implementation code
-- If you cannot perform file operations, output file contents in code blocks with the intended file path as the header
+- If file operations unavailable, output contents in code blocks with intended path as header
-- If you cannot access the filesystem, ask the user to paste relevant file contents
 
 ### Required Context
 
-You need all implementation spec files to proceed. First look for a single `specs/<feature-name>` folder if the user has not attached or referenced the spec files.
+Need all implementation spec files. Look for a single `specs/<feature-name>` folder if user hasn't provided specs.
 
-**IMPORTANT:** When auto-detecting specs, NEVER look in `specs--completed/` - that folder contains archived specs only. Only look for active spec folders directly under `specs/`.
+**NEVER look in `specs--completed/`** - that contains archived specs only.
 
-If there are multiple active spec folders or nothing was already provided, ask the user to provide:
+If multiple active spec folders exist or nothing provided, ask user for:
+1. The entire `specs/<feature-name>/` directory: `overview.md` and all `phase-X.md` files
 
-1. The entire `specs/<feature-name>/` directory contents:
+**Do not proceed without all spec files.**
-   - `overview.md`
-   - All `phase-X.md` files
-
-**Do not proceed until you have all spec files.**
 
 ## Examples
 
-### Task Audit
+**Task Audit:** Always show verification table with phase totals, blocked items, and completion %. Never just assert "all complete" without evidence.
-**Bad:** "All tasks complete. Moving to Step 2."
-*Problem: No actual verification shown.*
 
-**Good:**
+**Documentation Review:** Always show review table with each document checked and proposed changes. Never assert "no updates needed" without evidence.
-| Phase | Total | Completed | Blocked |
-|-------|-------|-----------|---------|
-| Phase 1 | 12 | 12 | 0 |
-| Phase 2 | 18 | 17 | 1 |
-Blocked: Task 2.14 - OAuth awaiting credentials. Completion: 96.7%
-
-### Documentation Review
-**Bad:** "No docs need updating."
-*Problem: No evidence of actual review.*
-
-**Good:**
-| Document | Needs Update? | Changes |
-|----------|---------------|---------|
-| README.md | Yes | Add auth setup |
-| .env.example | Yes | Add JWT_SECRET |
-| CHANGELOG.md | No | - |
 
 ## Process
 
-Complete these steps in order. Report progress after each step.
+Complete steps in order. Report progress after each.
 
 ---
 
@@ -67,54 +45,44 @@ Complete these steps in order. Report progress after each step.
 
 `🧹 [FINALIZATION STEP 1: Task Completion Audit]`
 
-**Objective:** Verify all tasks across all phases were completed.
+**Objective:** Verify all tasks across all phases completed.
-
-#### Process:
 
 1. Open each `phase-X.md` file
-2. For every task, verify its status:
+2. Verify each task status:
 
-| Status | Meaning     | Action Required                  |
+| Status | Meaning | Action |
-| ------ | ----------- | -------------------------------- |
+|--------|---------|--------|
-| `[x]`  | Completed   | Verify the implementation exists |
+| `[x]` | Completed | Verify implementation exists |
-| `[ ]`  | Not started | Flag as INCOMPLETE               |
+| `[ ]` | Not started | Flag INCOMPLETE |
-| `[!]`  | Blocked     | Document the blocker             |
+| `[!]` | Blocked | Document blocker |
 
-3. Create an audit table:
+3. Create audit table:
 
 ```markdown
 ## Task Completion Audit
-
+| Phase | Total | Completed | Blocked | Incomplete |
-| Phase     | Total Tasks | Completed | Blocked | Incomplete |
+|-------|-------|-----------|---------|------------|
-| --------- | ----------- | --------- | ------- | ---------- |
 | Phase 1 | X | X | 0 | 0 |
-| Phase 2   | X           | X         | 0       | 0          |
-| ...       |             |           |         |            |
 | **Total** | **X** | **X** | **X** | **X** |
 ```
 
-4. Calculate completion percentage: `(Completed / Total) × 100`
+4. Calculate: `(Completed / Total) * 100`
 
 #### If incomplete tasks exist:
 
 ```markdown
-⚠️ INCOMPLETE TASKS DETECTED
+INCOMPLETE TASKS DETECTED
-
-The following tasks were not completed:
 
 - Phase 2, Task 2.4: [Description] - Status: [ ]
 - Phase 3, Task 3.1: [Description] - Status: [!] BLOCKED: [reason]
 
 **Options:**
-
 1. Return to Implementation Mode to complete remaining tasks
-2. Mark feature as partially complete and proceed with finalization
+2. Mark feature as partially complete and proceed
 3. Abandon and archive as incomplete
-
-Please choose how to proceed.
 ```
 
-**Do NOT continue to Step 2 until user confirms how to handle incomplete tasks.**
+**Do NOT continue to Step 2 until user confirms how to handle.**
 
 ---
 
@@ -122,14 +90,11 @@ Please choose how to proceed.
 
 `🧹 [FINALIZATION STEP 2: Implementation Verification]`
 
-**Objective:** Verify the code matches the specifications.
+**Objective:** Verify code matches specifications.
-
-#### Verification Checklist:
 
 ```markdown
 ## Implementation Verification
-
+- [ ] All files listed in specs created
-- [ ] All files listed in specs were created
 - [ ] Function/class names match specifications
 - [ ] Database schemas match design (if applicable)
 - [ ] API endpoints match spec (if applicable)
@@ -138,21 +103,19 @@ Please choose how to proceed.
 - [ ] No hardcoded secrets or credentials
 - [ ] Code follows existing codebase patterns
 
-### Test Validation (if defined in Testing Strategy)
+### Test Validation (if defined)
 | Test Type | Passed | Failed | Coverage |
 |-----------|--------|--------|----------|
 | Unit | X | X | X% |
-...
 ```
 
-#### Report findings:
+#### Report:
 
 ```markdown
 ## Verification Results
 | Check | Status | Notes |
 |-------|--------|-------|
-| Files | ✅/⚠️/❌ | [Details] |
+| Files | Pass/Warn/Fail | [Details] |
-...
 
 **Issues Found:** [List or "None"]
 ```
@@ -163,13 +126,10 @@ Please choose how to proceed.
 
 `🧹 [FINALIZATION STEP 3: Implementation Summary]`
 
-**Objective:** Create a comprehensive summary of what was built.
+**Objective:** Create comprehensive summary of what was built.
-
-#### Create this summary document:
 
 ```markdown
 ## Implementation Summary
-
 **Feature:** [Name] | **Completed:** [Date] | **Completion:** [X]%
 
 ### What Was Built
@@ -179,23 +139,19 @@ Please choose how to proceed.
 | File | Purpose |
 |------|---------|
 | `path/file` | [Description] |
-...
 
 ### Files Modified
 | File | Changes |
 |------|---------|
 | `path/file` | [Description] |
-...
 
 ### Dependencies Added
 | Package | Version | Purpose |
 |---------|---------|---------|
-...
 
 ### Configuration Required
 | Variable | Description | Example |
 |----------|-------------|---------|
-...
 
 ### Known Limitations / Blocked Items
 [List or "None"]
@@ -209,74 +165,76 @@ Add this summary to `overview.md` under `## Completion Summary`.
 
 `🧹 [FINALIZATION STEP 4: Documentation Review]`
 
-**Objective:** Identify any project documentation that needs updating.
+**Objective:** Identify project documentation needing updates.
-
-#### Check each document:
 
 | Document | Check For | Action |
-| --------------- | ----------------------------------- | ------------------------------- |
+|----------|-----------|--------|
-| `README.md`     | New features, setup steps, API docs | Update if feature affects usage |
+| `README.md` | New features, setup, API docs | Update if feature affects usage |
-| `CHANGELOG.md`  | Version history                     | Add entry for this feature      |
+| `CHANGELOG.md` | Version history | Add entry for feature |
 | `.env.example` | Environment variables | Add new required vars |
 | `API.md` / docs | API documentation | Update with new endpoints |
 | `CLAUDE.md` | AI assistant context | Update if patterns changed |
 
-#### Report format:
+Report: table of documents needing updates with proposed changes. List each document with specific additions.
 
-```markdown
+If updates needed, show Planny and ask for approval:
-## Documentation Review
 
-| Document     | Needs Update? | Proposed Changes                                     |
+```
-| ------------ | ------------- | ---------------------------------------------------- |
+⋅
-| README.md    | Yes           | Add "Authentication" section with setup instructions |
+    ╭───╮
-| CHANGELOG.md | Yes           | Add entry: "Added user authentication with JWT"      |
+    │ ● │
-| .env.example | Yes           | Add JWT_SECRET and DATABASE_URL                      |
+    │ ~ │   Found some docs that need updating!
-| API.md       | No            | N/A                                                  |
+    ╰───╯
-| CLAUDE.md    | No            | N/A                                                  |
-
-### Proposed Updates
-
-#### README.md
-
-[Show the specific additions/changes]
-
-#### CHANGELOG.md
-
-[Show the specific entry]
-
-#### .env.example
-
-[Show the specific additions]
 ```
 
-**If ANY documentation needs updates:**
+> Reply "approve" to proceed with doc updates, or specify which to skip.
 
-> "The following documentation updates are recommended. Please review and approve before I make these changes:
+Do NOT make documentation changes without user approval.
->
-> [List proposed changes]
->
-> Reply 'approve' to proceed, or specify which updates to skip."
-
-**Do NOT make documentation changes without user approval.**
 
 ---
 
-### STEP 5: Spec Cleanup
+### STEP 5: User Feedback (Optional)
 
-`🧹 [FINALIZATION STEP 5: Spec Cleanup]`
+`🧹 [FINALIZATION STEP 5: User Feedback]`
+
+**Objective:** Collect optional user feedback before archival.
+
+Ask the user: "Would you like to provide feedback on this workflow run? (optional)"
+
+If yes, collect:
+1. **Rating** (1-10): "How would you rate this workflow run overall?"
+2. **Reason**: "Brief reason for your rating?"
+3. **Went Well**: "What went well?"
+4. **Went Poorly**: "What went poorly or could improve?"
+
+Append to `overview.md` (in the active spec directory):
+
+```markdown
+## User Feedback
+| Field | Value |
+|-------|-------|
+| Rating | [1-10] |
+| Reason | [response] |
+| Went Well | [response] |
+| Went Poorly | [response] |
+```
+
+If the user declines, skip and proceed to Step 6 (Spec Cleanup).
+
+---
+
+### STEP 6: Spec Cleanup
+
+`🧹 [FINALIZATION STEP 6: Spec Cleanup]`
 
 **Objective:** Archive completed specifications.
 
-#### Process:
+1. Create: `specs--completed/<feature-name>/`
-
+2. Move all files from `specs/<feature-name>/`:
-1. Create archive directory: `specs--completed/<feature-name>/`
+   - `overview.md` (with completion summary)
-2. Move all files from `specs/<feature-name>/` to the archive:
-   - `overview.md` (with completion summary added)
    - All `phase-X.md` files
    - `PLAN-DRAFT.md` (if present)
-3. Verify the original `specs/<feature-name>/` directory is empty and can be removed
+3. Verify original directory empty and can be removed
-
-#### Archive structure:
 
 ```
 specs/
@@ -290,172 +248,82 @@ specs--completed/
     └── ...
 ```
 
-**Note:** Keep the folder name exactly as it was - do not rename during archival.
+**Keep folder name exactly as-is during archival.**
 
 ---
 
-### STEP 6: Final Confirmation
+### STEP 7: Final Confirmation
 
-`🧹 [FINALIZATION STEP 6: Final Confirmation]`
+`🧹 [FINALIZATION STEP 7: Final Confirmation]`
 
-**Objective:** Confirm all finalization steps are complete.
+**Objective:** Confirm all finalization steps complete.
-
-#### Final Report:
 
 ```markdown
 ## Finalization Complete
 
 ### Summary
-
 - **Feature:** [Name]
 - **Status:** Complete
 - **Completion Rate:** [X]% ([Y]/[Z] tasks)
 - **Archived To:** `specs--completed/<feature-name>/`
 
 ### Finalization Steps Completed
-
 - [x] Step 1: Task Completion Audit
 - [x] Step 2: Implementation Verification
 - [x] Step 3: Implementation Summary
 - [x] Step 4: Documentation Review
-- [x] Step 5: Spec Cleanup
+- [x] Step 5: User Feedback (Optional)
-- [x] Step 6: Final Confirmation
+- [x] Step 6: Spec Cleanup
+- [x] Step 7: Final Confirmation
 
 ### Files Created/Modified During Finalization
-
 - `specs/<feature-name>/overview.md` - Added completion summary
 - `README.md` - [if updated]
 - `CHANGELOG.md` - [if updated]
-- [other documentation updates]
 
 ### Archived Files
-
 [List all files moved to specs--completed/<feature-name>/]
 
 ---
 
-╔═══════════════════════════════════════════════════════════════════╗
-║  IMPLEMENTATION COMPLETE                                          ║
-╠═══════════════════════════════════════════════════════════════════╣
-║                                                                   ║
-║  All tasks finished. Specs archived to:                           ║
-║  specs--completed/<feature-name>/                                 ║
-║                                                                   ║
-║  Thank you for using the Plan2Code workflow!                    ║
-║                                                                   ║
-╚═══════════════════════════════════════════════════════════════════╝
 ```
+⋅
+    ╭───╮
+    │ ★ │
+    │ ◡ │   You did it! Feature complete!
+    ╰───╯
+```
+
+> IMPLEMENTATION COMPLETED!
+> All tasks finished.
+> Specs archived to `specs--completed/<feature-name>/`.
+> Thank you for using the Plan2Code workflow!
+
+### Metrics Capture (Contributors)
+To help improve plan2code's prompts, run `plan2code-metrics` in the project root.
 
 ### Handling Incomplete Implementations
 
-**Partial Completion (>75%):**
+| Completion | Action |
-
+|-----------|--------|
-Allow finalization with clear documentation of incomplete items:
+| **>75%** | Finalize with notice. List incomplete items. Note remaining tasks for follow-up cycle. |
-
+| **<75%** | Recommend returning to implementation. List incomplete phases with task counts. Options: 1) Return via `/plan2code-3--implement` 2) Proceed with partial finalization. |
-```markdown
-## Partial Completion Notice
-
-This feature is being finalized at [X]% completion.
-
-### Incomplete Items
-
-- Phase X, Task Y: [Description] - [Reason]
-
-╔═══════════════════════════════════════════════════════════════════╗
-║  NEXT STEPS - REMAINING WORK                                      ║
-╠═══════════════════════════════════════════════════════════════════╣
-║                                                                   ║
-║  [X] incomplete tasks remain.                                     ║
-║  Review the overview.md for remaining items.                      ║
-║  Address these in a follow-up implementation cycle.               ║
-║                                                                   ║
-╚═══════════════════════════════════════════════════════════════════╝
-```
-
-**Low Completion (<75%):**
-
-Recommend returning to implementation:
-
-```markdown
-⚠️ Implementation is only [X]% complete.
-
-I recommend returning to Implementation Mode to complete more tasks before finalization.
-
-**Incomplete phases:**
-
-- Phase X: [Y]/[Z] tasks complete
-- Phase Y: [Y]/[Z] tasks complete
-
-Would you like to:
-
-1. Return to implementation
-2. Proceed with partial finalization anyway
-
-╔═══════════════════════════════════════════════════════════════════╗
-║  NEXT STEPS - IMPLEMENTATION INCOMPLETE                           ║
-╠═══════════════════════════════════════════════════════════════════╣
-║                                                                   ║
-║  Completion rate is below 75%.                                    ║
-║  Return to implementation before finalizing.                      ║
-║                                                                   ║
-║  1. Start a NEW conversation                                      ║
-║  2. Use command: /plan2code-3--implement                        ║
-║  3. Provide path: specs/<feature-name>/overview.md                ║
-║                                                                   ║
-║  The command will auto-detect the next Phase to implement.        ║
-║                                                                   ║
-╚═══════════════════════════════════════════════════════════════════╝
-```
 
 ## Abort Handling
 
-If the user says "abort", "cancel", "start over", or similar:
+If user says "abort", "cancel", or similar:
-
+1. Confirm: "Abort finalization? Implementation remains but won't be validated or archived."
-1. Confirm: "Are you sure you want to abort finalization? The implementation will remain but won't be validated or archived."
+2. If confirmed: Note progress, explain spec files remain in place
-2. If confirmed:
+3. Stop finalization
-   - Note current finalization progress
-   - Explain spec files remain in their current location
-3. Do not continue with finalization
 
 ## Recovery
 
 | Issue | Solution |
 |-------|----------|
-| Incomplete tasks found | User chooses: complete, proceed partial, or abandon |
+| Incomplete tasks | User chooses: complete, partial, or abandon |
-| Missing spec files | Ask user to provide all Phase X.md files |
+| Missing spec files | Ask for all phase-X.md files |
-| Doc updates rejected | Skip those updates, note in summary |
+| Doc updates rejected | Skip updates, note in summary |
 
-## Important Reminders
+## Learning Capture
 
-- Every response must start with: `🧹 [FINALIZATION STEP X: Step Name]`
+At session end, if you discovered undocumented commands, dependency quirks, gotchas (>5min cost), framework workarounds, or missing `AGENTS.md` patterns → prompt user to update AGENTS.md. If yes, apply the edit directly.
-- Complete steps IN ORDER - do not skip steps
-- STOP and ask user before proceeding when:
-  - Incomplete tasks are found (Step 1)
-  - Documentation updates are proposed (Step 4)
-- Do NOT make documentation changes without explicit user approval
-- Archive specs to `specs--completed/<feature-name>/` - preserve folder name exactly
-- This is validation and cleanup only - do NOT write implementation code
-
-## Learning Capture Protocol
-
-At the END of Finalize session, check:
-
-### Auto-Capture Triggers
-Proactively suggest updating `AGENTS.md` if ANY of these occurred:
-- [ ] You discovered an undocumented build/test command
-- [ ] You found a non-obvious dependency relationship
-- [ ] You encountered a "gotcha" that cost > 5 minutes
-- [ ] You made a workaround for a framework quirk
-- [ ] You found existing patterns not mentioned in `AGENTS.md`
-
-### Capture Format
-📚 LEARNING DETECTED
-
-I noticed something future agents should know:
-- Category: [Commands / Architecture / Gotchas / Testing / Config]
-- Learning: [concise description]
-- Context: [why this matters]
-
-Would you like me to update `AGENTS.md` with this? (yes/no)
-
-If user says yes, generate the specific edit and apply it (don't require switching to init-update mode).

version.json

@@ -1,6 +1,6 @@
 {
   "name": "Plan2Code",
-  "version": "1.3.1",
+  "version": "1.8.1",
   "description": "A structured 4-step workflow methodology for AI-assisted software development",
   "keywords": [
     "ai",
@@ -17,6 +17,7 @@
     "url": "https://github.com/jparkerweb/plan2code"
   },
   "homepage": "https://plan2code.jparkerweb.com",
-  "releaseDate": "2025-12-19",
+  "releaseDate": "2026-02-20",
   "mode": "utility"
 }
+