@sienklogic/plan-build-run 2.1.0 → 2.1.1

package/plan-build-run/skills/plan/SKILL.md

@@ -0,0 +1,700 @@
+---
+name: plan
+description: "Create a detailed plan for a phase. Research, plan, and verify before building."
+allowed-tools: Read, Write, Bash, Glob, Grep, WebFetch, WebSearch, Task, AskUserQuestion, Skill
+argument-hint: "<phase-number> [--skip-research] [--assumptions] [--gaps] [--model <model>] | add | insert <N> | remove <N>"
+---
+
+**STOP — DO NOT READ THIS FILE. You are already reading it. This prompt was injected into your context by Claude Code's plugin system. Using the Read tool on this SKILL.md file wastes ~7,600 tokens. Begin executing Step 1 immediately.**
+
+# /pbr:plan-phase — Phase Planning
+
+**References:** `@references/questioning.md`, `@references/ui-brand.md`
+
+You are the orchestrator for `/pbr:plan-phase`. This skill creates detailed, executable plans for a specific phase. Plans are the bridge between the roadmap and actual code — they must be specific enough for an executor agent to follow mechanically. Your job is to stay lean, delegate heavy work to Task() subagents, and keep the user's main context window clean.
+
+## Context Budget
+
+Reference: `skills/shared/context-budget.md` for the universal orchestrator rules.
+
+Additionally for this skill:
+- **Minimize** reading subagent output — read only plan frontmatter for summaries
+- **Delegate** all research and planning work to subagents — the orchestrator routes, it doesn't plan
+
+## Step 0 — Immediate Output
+
+**Before ANY tool calls**, display this banner:
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║  PLAN-BUILD-RUN ► PLANNING PHASE {N}                         ║
+╚══════════════════════════════════════════════════════════════╝
+```
+
+Where `{N}` is the phase number from `$ARGUMENTS`. Then proceed to Step 1.
+
+**Step progress**: Display step progress indicators at major transitions using the pattern from `@references/ui-brand.md` § Step Progress. Show `── Step {N} of 6: {Name} ──────────────────────` before each major step begins. Steps: Parse Arguments, Load Context, Research Phase, Generate Plans, Validate Plans, Approval Gate.
+
+## Multi-Session Sync
+
+Before any phase-modifying operations (writing PLAN files, updating STATE.md/ROADMAP.md), acquire a claim:
+
+```
+acquireClaim(phaseDir, sessionId)
+```
+
+If the claim fails (another session owns this phase), display: "Another session owns this phase. Use `/pbr:progress` to see active claims."
+
+On completion or error (including all exit paths), release the claim:
+
+```
+releaseClaim(phaseDir, sessionId)
+```
+
+## Prerequisites
+
+- `.planning/config.json` exists (run `/pbr:new-project` first)
+- `.planning/ROADMAP.md` exists with at least one phase
+- `.planning/REQUIREMENTS.md` exists
+
+---
+
+## Argument Parsing
+
+Parse `$ARGUMENTS` according to `skills/shared/phase-argument-parsing.md`.
+
+### Standard Invocation
+
+`/pbr:plan-phase <N>` — Plan phase N
+
+Parse the phase number and optional flags:
+
+| Argument | Meaning |
+|----------|---------|
+| `3` | Plan phase 3 |
+| `3 --skip-research` | Plan phase 3, skip research step |
+| `3 --assumptions` | Surface assumptions before planning phase 3 |
+| `3 --gaps` | Create gap-closure plans for phase 3 (from VERIFICATION.md) |
+| `3 --teams` | Plan phase 3 using specialist agent teams |
+| `3 --model opus` | Use opus for all researcher, planner, and checker spawns in phase 3 |
+| (no number) | Use current phase from STATE.md |
+| `3 --preview` | Preview what planning would produce for phase 3 without spawning agents |
+
+### Subcommands
+
+| Subcommand | Meaning |
+|------------|---------|
+| `add` | Append a new phase to the end of the roadmap |
+| `insert <N>` | Insert a new phase at position N (uses decimal numbering) |
+| `remove <N>` | Remove phase N from the roadmap |
+
+### Freeform Text Guard — CRITICAL
+
+**STOP. Before ANY context loading or Step 1 work**, you MUST check whether `$ARGUMENTS` looks like freeform text rather than a valid invocation. This check is non-negotiable. Valid patterns are:
+
+- Empty (no arguments)
+- A phase number: integer (`3`, `03`) or decimal (`3.1`)
+- A subcommand: `add`, `insert <N>`, `remove <N>`
+- A phase number followed by flags: `3 --skip-research`, `3 --assumptions`, `3 --gaps`, `3 --teams`
+- The word `check` (legacy alias)
+
+If `$ARGUMENTS` does NOT match any of these patterns — i.e., it contains freeform words that are not a recognized subcommand or flag — then **stop execution** and respond:
+
+```
+`/pbr:plan-phase` expects a phase number or subcommand.
+
+Usage:
+  /pbr:plan-phase <N>              Plan phase N
+  /pbr:plan-phase <N> --gaps       Create gap-closure plans
+  /pbr:plan-phase add              Add a new phase
+  /pbr:plan-phase insert <N>       Insert a phase at position N
+  /pbr:plan-phase remove <N>       Remove phase N
+```
+
+Then suggest the appropriate skill based on the text content:
+
+| If the text looks like... | Suggest |
+|---------------------------|---------|
+| A task, idea, or feature request | `/pbr:todo` to capture it, or `/pbr:explore` to investigate |
+| A bug or debugging request | `/pbr:debug` to investigate the issue |
+| A review or quality concern | `/pbr:verify-work` to assess existing work |
+| Anything else | `/pbr:explore` for open-ended work |
+
+Do NOT proceed with planning. The user needs to use the correct skill.
+
+**Self-check**: If you reach Step 1 without having matched a valid argument pattern above, you have a bug. Stop immediately and show the usage block.
+
+---
+
+## Orchestration Flow: Standard Planning
+
+Execute these steps in order for standard `/pbr:plan-phase <N>` invocations.
+
+---
+
+### Step 1: Parse and Validate (inline)
+
+Reference: `skills/shared/config-loading.md` for the tooling shortcut (`state load`, `plan-index`, `phase-info`) and config field reference.
+
+1. Parse `$ARGUMENTS` for phase number and flags
+   - If `--model <value>` is present in `$ARGUMENTS`, extract the value (sonnet, opus, haiku, inherit). Store as `override_model`. When spawning researcher, planner, and plan-checker Task() agents, use `override_model` instead of the config-derived model values. If an invalid value is provided, display an error and list valid values.
+2. Read `.planning/config.json` for settings (see config-loading.md for field reference)
+   **CRITICAL (hook-enforced): Write .active-skill NOW.** Write the text "plan" to `.planning/.active-skill` using the Write tool.
+3. Resolve depth profile: run `node ${CLAUDE_PLUGIN_ROOT}/bin/pbr-tools.cjs config resolve-depth` to get the effective feature/gate settings for the current depth. Store the result for use in later gating decisions.
+4. Validate:
+   - Phase exists in ROADMAP.md
+   - Phase directory exists at `.planning/phases/{NN}-{slug}/`
+   - Phase does not already have PLAN.md files (unless user confirms re-planning)
+5. If no phase number given, read current phase from `.planning/STATE.md`
+6. **CONTEXT.md existence check**: If the phase is non-trivial (has 2+ requirements or success criteria), check whether a CONTEXT.md exists at EITHER `.planning/CONTEXT.md` (project-level) OR `.planning/phases/{NN}-{slug}/CONTEXT.md` (phase-level). If NEITHER exists, warn: "Phase {N} has no CONTEXT.md. Consider running `/pbr:discuss-phase {N}` first to capture your preferences. Continue anyway?" If user says no, stop. If yes, continue. If at least one exists, proceed without warning.
+
+#### --preview mode
+
+If `--preview` is present in `$ARGUMENTS`:
+
+1. Detect the `--preview` flag and extract the phase number.
+2. Render the following dry-run banner:
+
+   ```
+   ╔══════════════════════════════════════════════════════════════╗
+   ║  DRY RUN — /pbr:plan-phase {N} --preview                           ║
+   ║  No researchers or planners will be spawned                  ║
+   ╚══════════════════════════════════════════════════════════════╝
+   ```
+
+3. Show the 5 steps that would occur:
+
+   1. Parse ROADMAP.md for phase {N} goal, dependencies, and requirements
+   2. Spawn researcher agents to investigate codebase and gather context
+   3. Spawn planner agent to write PLAN files based on research
+   4. Run plan-checker to validate structure and completeness
+   5. Present plans for your approval before building
+
+4. Show estimated agent spawns: ~2-4 agents (1-2 researchers + 1 planner + 1 plan-checker)
+5. Show output location: `.planning/phases/{NN}-{slug}/PLAN-NN.md`
+
+6. **STOP** — do not proceed to Step 2.
+
+---
+
+**If phase already has plans:**
+- Use AskUserQuestion (pattern: yes-no from `skills/shared/gate-prompts.md`):
+  question: "Phase {N} already has plans. Re-plan from scratch?"
+  header: "Re-plan?"
+  options:
+    - label: "Yes"  description: "Delete existing plans and create new ones"
+    - label: "No"   description: "Keep existing plans unchanged"
+- If "Yes": delete existing PLAN.md files in the phase directory
+- If "No" or "Other": stop
+
+---
+
+### Step 2: Load Context (inline)
+
+**Init-first pattern**: When spawning agents, pass the output of `node $HOME/.claude/plan-build-run/bin/pbr-tools.cjs init plan-phase {N}` as context rather than having the agent read multiple files separately. This reduces file reads and prevents context-loading failures.
+
+Read context file PATHS and metadata. Build lean context bundles for subagent prompts — include paths and one-line descriptions, NOT full file bodies. Agents have the Read tool and will pull file contents on-demand.
+
+```
+1. Read .planning/ROADMAP.md — extract current phase goal, dependencies, requirements
+2. Read .planning/REQUIREMENTS.md — extract requirements mapped to this phase
+3. Read .planning/PROJECT.md (if exists) — extract the `## Context` section (locked decisions, user constraints, deferred ideas). This is the primary context source. Fall back to .planning/CONTEXT.md if PROJECT.md has no ## Context section (backwards compat).
+4. Read .planning/phases/{NN}-{slug}/CONTEXT.md (if exists) — extract only the `## Decision Summary` section. Fall back to full locked decisions + deferred sections if no Decision Summary exists.
+5. Read .planning/config.json — extract feature flags, depth, model settings
+6. List prior SUMMARY.md file paths and extract frontmatter metadata only (status, provides, key_files). Do NOT read full SUMMARY bodies — agents pull these on-demand via Read tool.
+7. Read .planning/research/SUMMARY.md (if exists) — extract research findings
+```
+
+**Digest-select depth for prior SUMMARYs (Step 6):**
+
+Reference: `skills/shared/digest-select.md` for the full depth rules and examples. In short: direct dependencies get frontmatter + key decisions, transitive get frontmatter only, 2+ back get skipped.
+
+Collect all of this into a context bundle that will be passed to subagents.
+
+---
+
+### Step 3: Assumption Surfacing (inline, if `--assumptions` flag)
+
+**IMPORTANT**: This step is FREE (no subagents). It happens entirely inline.
+
+Before spawning any agents, present 4 assumptions to the user — one each for: approach (how the phase will be implemented), key technology, architecture, and scope boundary. For each, ask the user to confirm or correct. Record corrections as new CONTEXT.md locked decisions. After all assumptions are confirmed/corrected, continue to Step 4.
+
+---
+
+### Step 4: Phase Research (delegated, conditional)
+
+**Skip this step if ANY of these are true:**
+- `--skip-research` flag is set
+- `--gaps` flag is set
+- Depth profile has `features.research_phase: false`
+
+To check: run `node ${CLAUDE_PLUGIN_ROOT}/bin/pbr-tools.cjs config resolve-depth` and read `profile["features.research_phase"]`. This replaces checking `features.research_phase` and `depth` separately -- the depth profile already incorporates both.
+
+**Conditional research (standard/balanced mode):** When the profile has `features.research_phase: true`, also check whether `.planning/codebase/` or `.planning/research/` already contains relevant context for this phase. If substantial context exists (>3 files in codebase/ or a RESEARCH.md mentioning this phase's technologies), skip research and note: "Skipping research -- existing context found in {directory}." This implements the balanced mode's "conditional research" behavior.
+
+**If research is needed:**
+
+Display to the user: `◆ Spawning researcher...`
+
+Spawn a researcher Task():
+
+```
+Task({
+  subagent_type: "pbr:researcher",
+  prompt: <phase research prompt>
+})
+
+NOTE: The pbr:researcher subagent type auto-loads the agent definition. Do NOT inline it.
+```
+
+**Path resolution**: Before constructing the agent prompt, resolve `${CLAUDE_PLUGIN_ROOT}` to its absolute path. Do not pass the variable literally in prompts — Task() contexts may not expand it. Use the resolved absolute path for any pbr-tools.cjs or template references included in the prompt.
+
+#### Phase Research Prompt Template
+
+Read `${CLAUDE_SKILL_DIR}/templates/researcher-prompt.md.tmpl` and use it as the prompt template for spawning the researcher agent. Fill in the placeholders with phase-specific context:
+- `{NN}` - phase number (zero-padded)
+- `{phase name}` - phase name from roadmap
+- `{goal from roadmap}` - phase goal statement
+- `{REQ-IDs mapped to this phase}` - requirement IDs
+- `{dependencies from roadmap}` - dependency list
+- Fill `<project_context>` and `<prior_work>` blocks per the shared partial (`templates/prompt-partials/phase-project-context.md.tmpl`): Decision Summary for context, manifest table for prior work
+
+**Prepend this block to the researcher prompt before sending:**
+```
+<files_to_read>
+CRITICAL (no hook): Read these files BEFORE any other action:
+1. .planning/ROADMAP.md — phase goals, dependencies, and structure
+2. .planning/REQUIREMENTS.md — scoped requirements for this phase (if exists)
+</files_to_read>
+```
+
+Wait for the researcher to complete before proceeding.
+
+After the researcher completes, check the Task() output for a completion marker:
+- If `## RESEARCH COMPLETE` is present: proceed to planner
+- If `## RESEARCH BLOCKED` is present: warn the user that research could not complete, ask if they want to proceed with limited context or stop
+- If neither marker is present: warn that researcher may not have completed successfully, but proceed
+
+---
+
+### Step 4.5: Pre-Planner Briefing (delegated)
+
+**CRITICAL (no hook): Run pre-planner briefing before spawning the planner. Do NOT skip this step.**
+
+Consolidate seed scanning and deferred idea surfacing into a single lightweight Task():
+
+```
+Task({
+  subagent_type: "pbr:general",
+  model: "haiku",
+  prompt: "Pre-planner briefing for Phase {NN} ({phase-slug}).
+
+1. SEED SCANNING:
+   Run: `node ${CLAUDE_PLUGIN_ROOT}/bin/pbr-tools.cjs seeds match {phase-slug} {phase-number}`
+   If `matched` is non-empty, output a ## Seeds section listing each seed name, description, and content.
+   If empty, output: ## Seeds\nNo matching seeds found.
+
+2. DEFERRED IDEAS:
+   Read `.planning/CONTEXT.md`. If it has a section containing 'deferred' or 'ideas' (case-insensitive),
+   extract items that mention Phase {NN} or keywords matching the phase slug.
+   If relevant items found, output a ## Deferred Ideas section listing them.
+   If none found, output: ## Deferred Ideas\nNo relevant deferred items.
+
+Output format: Return both sections as markdown. End with ## BRIEFING COMPLETE."
+})
+```
+
+After the Task() completes:
+- If `## Seeds` section contains matches:
+  - If `gates.confirm_seeds` is `true` in config: present them to the user via AskUserQuestion (pattern: yes-no-pick from `skills/shared/gate-prompts.md`):
+      question: "Include these {N} seeds in planning?"
+      header: "Seeds?"
+      options:
+        - label: "Yes, all"     description: "Include all {N} matching seeds"
+        - label: "Let me pick"  description: "Choose which seeds to include"
+        - label: "No"           description: "Proceed without seeds"
+    - If "Yes, all": include seed content in planner context
+    - If "Let me pick": present individual seeds for selection
+    - If "No": proceed without seeds
+  - If `gates.confirm_seeds` is `false` (default): automatically include all matching seeds in planner context without prompting. Log: "Including {N} seeds automatically (gates.confirm_seeds=false)."
+
+- If `## Deferred Ideas` section has items:
+  - If `gates.confirm_deferred` is `true` in config: present via AskUserQuestion (pattern: yes-no from `skills/shared/gate-prompts.md`):
+      question: "Include these deferred ideas in planning context?"
+    - If "Yes": append to planner context under `Deferred ideas to consider:`
+    - If "No": proceed without changes
+  - If `gates.confirm_deferred` is `false` (default): automatically append deferred ideas to planner context without prompting. Log: "Including deferred ideas automatically (gates.confirm_deferred=false)."
+
+- If both sections are empty: proceed silently to Step 5 (no AskUserQuestion needed)
+
+---
+
+### Step 5: Planning (delegated)
+
+#### Team Mode (--teams)
+
+If `--teams` flag is set OR `config.parallelization.use_teams` is true, spawn 3 parallel planner agents (architect, security, test) then a synthesizer to merge their outputs. See `references/agent-teams.md` for agent role definitions, output paths (`.planning/phases/{NN}-{slug}/team/`), and prompt content for each role.
+
+If `--teams` is NOT set and `config.parallelization.use_teams` is false or unset, proceed with the single-planner flow below.
+
+#### Single-Planner Flow (default)
+
+**Learnings injection (opt-in):** Check for planning and estimation learnings before spawning the planner:
+
+```bash
+node {resolved_plugin_root}/bin/pbr-tools.cjs learnings query --tags "estimation,planning,process" 2>/dev/null
+```
+
+If non-empty JSON array returned:
+
+- Write to temp file and note as `{learnings_temp_path}`:
+
+  ```bash
+  node {resolved_plugin_root}/bin/pbr-tools.cjs learnings query --tags "estimation,planning,process" > /tmp/pbr-learnings-$$.md
+  ```
+
+- Add as an additional `files_to_read` item in the planner prompt below
+
+If no learnings or command fails: omit.
+
+Display to the user: `◆ Spawning planner...`
+
+Spawn the planner Task() with all context inlined:
+
+```
+Task({
+  subagent_type: "pbr:planner",
+  prompt: <planning prompt>
+})
+
+NOTE: The pbr:planner subagent type auto-loads the agent definition.
+
+After planner completes, check for completion markers: `## PLANNING COMPLETE`, `## PLANNING FAILED`, or `## PLANNING INCONCLUSIVE`. Route accordingly. Do NOT inline it.
+```
+
+**Path resolution**: Before constructing the agent prompt, resolve `${CLAUDE_PLUGIN_ROOT}` to its absolute path. Do not pass the variable literally in prompts — Task() contexts may not expand it. Use the resolved absolute path for any pbr-tools.cjs or template references included in the prompt.
+
+#### Planning Prompt Template
+
+Read `${CLAUDE_SKILL_DIR}/templates/planner-prompt.md.tmpl` and use it as the prompt template for spawning the planner agent. Fill in all placeholder blocks with phase-specific context:
+
+- `<phase_context>` - phase number, directory, goal, requirements, dependencies, success criteria
+- `<project_context>` - locked decisions, user constraints, deferred ideas, phase-specific decisions
+- `<prior_work>` - manifest table of preceding phase SUMMARY.md file paths with status and one-line exports (NOT full bodies)
+- `<research>` - file path to RESEARCH.md if it exists (NOT inlined content)
+- `<config>` - max tasks, parallelization, TDD mode from config.json
+- `<planning_instructions>` - phase-specific planning rules and output path
+
+**Prepend this block to the planner prompt before sending:**
+
+```
+<files_to_read>
+CRITICAL (no hook): Read these files BEFORE any other action:
+1. .planning/PROJECT.md — project context, locked decisions, and constraints (primary source)
+2. .planning/ROADMAP.md — phase goals, dependencies, and structure
+3. .planning/phases/{NN}-{slug}/RESEARCH.md — research findings (if exists)
+4. .planning/CONTEXT.md — legacy context file (backwards compat fallback, if exists)
+{if learnings_temp_path exists}5. {learnings_temp_path} — cross-project learnings (estimation and planning patterns from past PBR projects){/if}
+</files_to_read>
+```
+
+If `{learnings_temp_path}` was produced in the learnings injection step above, replace `{if...}{/if}` with the actual line. If no learnings were found, omit item 4 entirely.
+
+Wait for the planner to complete.
+
+After the planner returns, read the plan files it created to extract counts. Display a completion summary using standardized status symbols (see `@references/ui-brand.md`):
+
+```
+✓ Planner created {N} plan(s) across {M} wave(s)
+```
+
+Where `{N}` is the number of PLAN.md files written and `{M}` is the number of distinct wave values across those plans (from frontmatter).
+
+Present a wave execution table using standardized symbols:
+
+```
+Wave 1: ○ Plan 01, ○ Plan 02
+Wave 2: ○ Plan 03
+```
+
+Use `○` (pending) for all plans at this stage since none have been executed yet.
+
+### Step 5b: Spot-Check Planner Output
+
+CRITICAL (no hook): Verify planner output before proceeding.
+
+1. **PLAN files exist**: Check `.planning/phases/{NN}-{slug}/PLAN-*.md` files exist on disk
+2. **Valid frontmatter**: Read first 20 lines of each PLAN file — verify `depends_on`, `files_modified`, `must_haves` fields present
+3. **Task structure**: Verify at least one `<task>` block exists in each plan file
+4. **Plan count matches**: Number of PLAN files matches what the planner reported
+5. **implements field**: Read frontmatter of each PLAN file — verify `implements:` field exists and is non-empty (contains at least one REQ-ID). If empty or missing: flag as spot-check failure.
+6. **Summary section**: Check each PLAN file for `## Summary` heading. If missing: flag as spot-check failure.
+7. **Done conditions**: Scan each `<done>` element — if any contains only "Code was written", "File was created", "Feature is implemented", or similar vague text (< 10 characters): flag as warning.
+
+If ANY spot-check fails:
+- Display which checks failed with specific details (e.g., 'Plan 04-02 missing implements field', 'Plan 04-01 missing ## Summary section')
+- If only warnings (vague done conditions): proceed to Step 6 (checker will catch these)
+- If errors (missing implements, missing Summary, missing frontmatter, no tasks): present options: **Retry** (re-spawn planner with explicit instructions to fix) / **Continue anyway** / **Abort**
+
+---
+
+### Step 6: Plan Validation (delegated, conditional)
+
+**Skip this step if:**
+- Depth profile has `features.plan_checking: false`
+
+To check: use the resolved depth profile from Step 1. The profile consolidates the depth setting and any user overrides into a single boolean.
+
+**If validation is enabled:**
+
+Display to the user: `◆ Spawning plan checker...`
+
+Spawn the plan checker Task():
+
+```
+Task({
+  subagent_type: "pbr:plan-checker",
+  prompt: <checker prompt>
+})
+
+NOTE: The pbr:plan-checker subagent type auto-loads the agent definition. Do NOT inline it.
+```
+
+**Path resolution**: Before constructing the agent prompt, resolve `${CLAUDE_PLUGIN_ROOT}` to its absolute path. Do not pass the variable literally in prompts — Task() contexts may not expand it. Use the resolved absolute path for any pbr-tools.cjs or template references included in the prompt.
+
+#### Checker Prompt Template
+
+Read `${CLAUDE_SKILL_DIR}/templates/checker-prompt.md.tmpl` and use it as the prompt template for spawning the plan checker agent. Fill in the placeholders:
+- `<plans_to_check>` - manifest table of PLAN.md file paths (checker reads each via Read tool)
+- `<phase_context>` - phase goal and requirement IDs
+- `<context>` - file paths to project-level and phase-level CONTEXT.md files (checker reads via Read tool)
+
+**Prepend this block to the checker prompt before sending:**
+```
+<files_to_read>
+CRITICAL (no hook): Read these files BEFORE any other action:
+1. .planning/phases/{NN}-{slug}/PLAN-*.md — plan files to validate
+2. .planning/CONTEXT.md — locked decisions to check against (if exists)
+</files_to_read>
+```
+
+**Process checker results:**
+
+After the plan checker returns, display its result:
+
+- If `VERIFICATION PASSED`: display `✓ Plan checker: all plans passed` and proceed to Step 8
+- If issues found: display `⚠ Plan checker found {N} issue(s) — entering revision loop` and proceed to Step 7
+
+---
+
+### Step 7: Revision Loop (max 3 iterations)
+
+Reference: `skills/shared/revision-loop.md` for the full Check-Revise-Escalate pattern.
+
+Follow the revision loop pattern with:
+- **Producer**: planner (re-spawned with `${CLAUDE_SKILL_DIR}/templates/revision-prompt.md.tmpl`)
+- **Checker**: plan-checker (back to Step 6)
+- **Escalation**: present issues to user, offer "Proceed anyway" or "Adjust approach" (re-enter Step 5)
+
+---
+
+### Step 8: User Approval (inline, conditional)
+
+**Skip if:**
+- `gates.confirm_plan` is `false` in config
+- `mode` is `autonomous` in config
+
+**If approval is needed:**
+
+Present a summary of all plans to the user. For each plan include: plan name, wave, task count, must-haves, files_modified. For each task include the task name. Add a wave execution order summary (Wave 1: Plan 01, 02 (parallel), Wave 2: Plan 03, etc.).
+
+Use AskUserQuestion (pattern: approve-revise-abort from `skills/shared/gate-prompts.md`):
+  question: "Approve these {count} plans for Phase {N}?"
+  header: "Approve?"
+  options:
+    - label: "Approve"          description: "Proceed to build phase"
+    - label: "Request changes"  description: "Discuss adjustments before proceeding"
+    - label: "Abort"            description: "Cancel planning for this phase"
+
+**If user selects 'Request changes' or 'Other':**
+- Discuss what needs to change
+- Re-enter Step 5 with updated context/constraints
+- Or make small inline edits to plan files directly
+
+**If user selects 'Approve':**
+- **CONTEXT.md compliance reporting**: Check locked decisions from BOTH sources:
+  a. Project-level: `.planning/CONTEXT.md` (if exists) — cross-cutting decisions for all phases
+  b. Phase-level: `.planning/phases/{NN}-{slug}/CONTEXT.md` (if exists) — phase-specific decisions
+     Phase-level decisions override project-level for the same decision area.
+
+  Collect ALL locked decisions from both files (deduplicate identical decision text).
+  Compare against the generated plan tasks. Print:
+  `CONTEXT.md compliance: {M}/{N} locked decisions mapped to tasks`
+  where M = locked decisions reflected in at least one task action, N = total unique locked decisions.
+  If any locked decisions are unmapped, list them as warnings.
+  If neither CONTEXT.md exists: skip this check silently.
+- **Dependency fingerprinting**: For each dependency phase (phases that this phase depends on, per ROADMAP.md):
+  1. Find all SUMMARY.md files in the dependency phase directory
+  2. Compute a fingerprint string for each: `"len:{bytes}-mod:{mtime}"` and add as a `dependency_fingerprints` map in each plan's YAML frontmatter — this allows the build skill to detect stale plans if dependencies were rebuilt.
+- **Update ROADMAP.md Progress table** (REQUIRED — do this BEFORE updating STATE.md):
+
+  **Tooling shortcut**: Use the CLI for atomic updates:
+  ```bash
+  node ${CLAUDE_PLUGIN_ROOT}/bin/pbr-tools.cjs roadmap update-plans {phase} 0 {N}
+  node ${CLAUDE_PLUGIN_ROOT}/bin/pbr-tools.cjs roadmap update-status {phase} planned
+  node ${CLAUDE_PLUGIN_ROOT}/bin/pbr-tools.cjs state update status planned
+  node ${CLAUDE_PLUGIN_ROOT}/bin/pbr-tools.cjs state update last_activity now
+  ```
+
+  1. Open `.planning/ROADMAP.md`
+  2. Find the `## Progress` table
+  3. Locate the row matching this phase number
+  4. Update the `Plans Complete` column to `0/{N}` where N = number of plan files just created
+  5. Update the `Status` column to `planned`
+  6. Save the file — do NOT skip this step
+- Update STATE.md via CLI **(CRITICAL (no hook) — update BOTH frontmatter AND body)**: set `status: "planned"`, `plans_total`, `last_command` in frontmatter AND update `Status:`, `Plan:` lines in body `## Current Position`
+
+**Tooling shortcut**: `node ${CLAUDE_PLUGIN_ROOT}/bin/pbr-tools.cjs state patch '{"status":"planned","last_command":"/pbr:plan-phase {N}"}'`
+- **If `features.auto_advance` is `true` AND `mode` is `autonomous`:** Chain directly to build: `Skill({ skill: "pbr:build", args: "{N}" })`. This continues the build→review→plan→build cycle automatically.
+- **Otherwise:** Suggest next action: `/pbr:execute-phase {N}`
+
+---
+
+## Orchestration Flow: Subcommands
+
+### Subcommand: `add`
+
+**CRITICAL (hook-enforced): Write .active-skill NOW.** Write the text "plan" to `.planning/.active-skill` using the Write tool.
+
+1. Read `.planning/ROADMAP.md`
+2. Calculate next phase number (last phase + 1)
+3. Ask user: "What's the goal for this new phase?"
+4. Ask user: "What requirements does it address?" (show available unassigned REQ-IDs)
+5. Ask user: "What phases does it depend on?"
+6. Append phase to ROADMAP.md
+7. Create phase directory: `.planning/phases/{NN}-{slug}/`
+8. Update STATE.md if needed
+9. Suggest: `/pbr:plan-phase {N}` to plan the new phase
+10. Delete `.planning/.active-skill` if it exists.
+
+### Subcommand: `insert <N>`
+
+Reference: `${CLAUDE_SKILL_DIR}/decimal-phase-calc.md` for decimal numbering rules.
+
+**CRITICAL (hook-enforced): Write .active-skill NOW.** Write the text "plan" to `.planning/.active-skill` using the Write tool.
+
+1. Read `.planning/ROADMAP.md`
+2. Calculate decimal phase number:
+   - If inserting at position 3: becomes 3.1
+   - If 3.1 already exists: becomes 3.2
+   - Etc. (see decimal-phase-calc.md)
+3. Ask user for phase goal, requirements, dependencies
+4. Insert phase into ROADMAP.md at the correct position
+5. Create phase directory: `.planning/phases/{NN.M}-{slug}/`
+6. Update dependencies of subsequent phases if affected
+7. Suggest: `/pbr:plan-phase {N.M}` to plan the new phase
+8. Delete `.planning/.active-skill` if it exists.
+
+### Subcommand: `remove <N>`
+
+1. Read `.planning/ROADMAP.md`
+2. Validate:
+   - Phase must exist
+   - Phase must be in `pending` or `not started` status (cannot remove completed/in-progress phases)
+   - No other phases depend on this phase (or user confirms breaking dependencies)
+3. **CRITICAL (hook-enforced): Write .active-skill NOW.** Write the text "plan" to `.planning/.active-skill` using the Write tool.
+4. Confirm with user: "Remove Phase {N}: {name}? This will delete the phase directory and renumber subsequent phases."
+5. If confirmed:
+   - Delete `.planning/phases/{NN}-{slug}/` directory
+   - Remove phase from ROADMAP.md
+   - Renumber subsequent phases (N+1 becomes N, etc.)
+   - Update all `depends_on` references in ROADMAP.md
+   - Update STATE.md if needed
+6. Delete `.planning/.active-skill` if it exists.
+
+---
+
+## Orchestration Flow: Gap Closure (`--gaps`)
+
+When invoked with `--gaps`:
+
+1. Read `.planning/phases/{NN}-{slug}/VERIFICATION.md`
+   - If no VERIFICATION.md exists: tell user "No verification report found. Run `/pbr:verify-work {N}` first."
+2. Extract all gaps from the verification report
+3. Spawn planner Task() in Gap Closure mode:
+
+Read `${CLAUDE_SKILL_DIR}/templates/gap-closure-prompt.md.tmpl` and use it as the prompt template for the gap closure planner. Fill in the placeholders:
+- `<verification_report>` - inline the FULL VERIFICATION.md content
+- `<existing_plans>` - inline all existing PLAN.md files for the phase
+- `<gap_closure_instructions>` - specify output path and gap_closure frontmatter flag
+
+4. After gap-closure plans are created:
+   - Run plan checker (if enabled)
+   - Present to user for approval
+   - Suggest: `/pbr:execute-phase {N} --gaps-only`
+
+---
+
+## Error Handling
+
+### Phase not found
+If the specified phase doesn't exist in ROADMAP.md, use conversational recovery:
+
+1. Run: `node ${CLAUDE_PLUGIN_ROOT}/bin/pbr-tools.cjs suggest-alternatives phase-not-found {slug}`
+2. Parse the JSON response to get `available` phases and `suggestions` (closest matches).
+3. Display: "Phase '{slug}' not found. Did you mean one of these?"
+   - List `suggestions` (if any) as numbered options.
+   - Offer "Show all phases" to list `available`.
+4. Use AskUserQuestion (pattern: yes-no-pick from `skills/shared/gate-prompts.md`) to let the user pick a phase or abort.
+   - If user picks a valid phase slug: re-run with that slug.
+   - If user chooses to abort: stop cleanly with a friendly message.
+
+### Missing prerequisites
+If REQUIREMENTS.md or ROADMAP.md don't exist, use conversational recovery:
+
+1. Run: `node ${CLAUDE_PLUGIN_ROOT}/bin/pbr-tools.cjs suggest-alternatives missing-prereq {phase}`
+2. Parse the JSON response to get `existing_summaries`, `missing_summaries`, and `suggested_action`.
+3. Display what is already complete and what is missing.
+4. Use AskUserQuestion to offer: "Run /pbr:execute-phase {prerequisite-phase} first, or continue anyway?"
+   - If user chooses to continue: proceed with planning (note missing prereqs in plan frontmatter).
+   - If user chooses to build first: stop and display the suggested build command.
+
+### Research agent fails
+If the researcher Task() fails, display:
+```
+⚠ Research agent failed. Planning without phase-specific research.
+  This may result in less accurate plans.
+```
+Continue to the planning step.
+
+### Planner agent fails
+If the planner Task() fails, display a branded error box — see `skills/shared/error-reporting.md`, pattern: Planner agent failure.
+
+### Checker loops forever
+After 3 revision iterations without passing, display a branded error box — see `skills/shared/error-reporting.md`, pattern: Checker loops.
+Present remaining issues and ask user to decide: proceed or intervene.
+
+---
+
+## Files Created/Modified by /pbr:plan-phase
+
+| File | Purpose | When |
+|------|---------|------|
+| `.planning/phases/{NN}-{slug}/RESEARCH.md` | Phase-specific research | Step 4 |
+| `.planning/phases/{NN}-{slug}/{NN}-{MM}-PLAN.md` | Executable plan files | Step 5 |
+| `.planning/CONTEXT.md` | Updated with assumptions | Step 3 (--assumptions) |
+| `.planning/ROADMAP.md` | Plans Complete + Status → `planned`; updated for add/insert/remove | Step 8, Subcommands |
+| `.planning/STATE.md` | Updated with plan status | Step 8 |
+
+---
+
+## Cleanup
+
+Delete `.planning/.active-skill` if it exists. This must happen on all paths (success, partial, and failure) before reporting results.
+
+## Completion
+
+After planning completes, present:
+
+Use the branded stage banner and next-up block from `${CLAUDE_SKILL_DIR}/templates/completion-output.md.tmpl`.
+Fill in: `{N}` (phase number), `{phase-name}`, `{plan_count}`, `{plan_list_lines}` (one line per plan with wave and task count), `{wave_table_lines}` (one line per wave).