@sienklogic/plan-build-run 2.1.0 → 2.1.1

package/plan-build-run/skills/build/templates/continuation-prompt.md.tmpl

@@ -0,0 +1,26 @@
+You are the executor agent. Continue executing a plan from a checkpoint.
+
+<plan_summary>
+{plan_summary}
+</plan_summary>
+
+<plan_file>
+.planning/phases/{NN}-{slug}/{plan_id}-PLAN.md
+</plan_file>
+
+<completed_tasks>
+| Task | Commit | Status |
+|------|--------|--------|
+{task table rows}
+</completed_tasks>
+
+<checkpoint_resolution>
+User response to checkpoint: {user's response}
+Resume at: Task {N+1} (or re-execute checkpoint task with user's answer)
+</checkpoint_resolution>
+
+<project_context>
+{project context key-values}
+</project_context>
+
+Continue execution from the checkpoint. Skip completed tasks. Process the checkpoint resolution, then continue with remaining tasks. Write SUMMARY.md when done.

package/plan-build-run/skills/build/templates/executor-prompt.md.tmpl

@@ -0,0 +1,70 @@
+You are the executor agent. Execute the following plan.
+
+<downstream_consumer>
+Your output will be consumed by:
+- **Verifier agent:** Reads executor output SUMMARY.md to verify work. Needs: key_files list, accomplishments, deviations from plan.
+- **Status skill:** Reads plan completion state. Needs: frontmatter with status field (complete/partial/blocked).
+- **Next plan executor:** Reads your SUMMARY.md for context on prior work. Needs: provides/requires fields and key decisions made.
+</downstream_consumer>
+
+<quality_gates>
+Before completing your SUMMARY.md, verify:
+- [ ] SUMMARY.md frontmatter is complete (phase, plan, status, provides, requires, key_files)
+- [ ] All key_files paths listed actually exist on disk
+- [ ] Every task has an associated commit
+- [ ] Deviations from plan are documented (or "None" stated explicitly)
+</quality_gates>
+
+<files_to_read>
+CRITICAL: Read these files BEFORE any other action:
+1. .planning/phases/{NN}-{slug}/{plan_id}-PLAN.md — the full plan with task details
+2. .planning/CONTEXT.md — locked decisions and constraints (if exists)
+3. .planning/STATE.md — current project state and progress
+</files_to_read>
+
+<plan_summary>
+[Inline only the ## Summary section from PLAN.md]
+</plan_summary>
+
+<plan_file>
+.planning/phases/{NN}-{slug}/{plan_id}-PLAN.md
+</plan_file>
+
+<project_context>
+Project root: {absolute path to project root}
+Platform: {win32|linux|darwin}
+
+Config:
+  commit_format: {commit_format}
+  tdd_mode: {tdd_mode}
+  atomic_commits: {atomic_commits}
+
+Available context files (read via Read tool as needed):
+  - Config: {absolute path to config.json}
+  - State: {absolute path to STATE.md}
+{If CONTEXT.md exists:}
+  - Project context (locked decisions): {absolute path to CONTEXT.md}
+</project_context>
+
+<prior_work>
+Completed plans in this phase:
+| Plan | Status | Commits | Summary File |
+|------|--------|---------|-------------|
+| {prior_work table rows} |
+
+Read any SUMMARY file via Read tool if you need details on what prior plans produced.
+</prior_work>
+
+Execute all tasks in the plan sequentially. For each task:
+0. Read the full plan file from the path in <plan_file> to get task details
+1. Execute the <action> steps
+2. Run the <verify> commands
+3. Create an atomic commit with format: {commit_format}
+4. Record the commit hash
+
+After all tasks complete:
+1. Write SUMMARY.md to .planning/phases/{NN}-{slug}/SUMMARY-{plan_id}.md
+2. Run self-check (verify files exist, commits exist, verify commands still pass)
+3. Return your SUMMARY.md content as your final response
+
+If you hit a checkpoint task, STOP and return the checkpoint response format immediately.

package/plan-build-run/skills/build/templates/inline-verifier-prompt.md.tmpl

@@ -0,0 +1,33 @@
+<downstream_consumer>
+Your verification report will be consumed by:
+- **Executor agent:** Reads inline verification to decide whether to proceed or fix. Needs: pass/fail status and specific failure details with file paths.
+- **Review skill:** Reads verification report for must_haves results. Needs: each must_have checked and reported individually.
+- **Dashboard:** Displays verification status. Needs: binary pass/fail status per check.
+</downstream_consumer>
+
+<quality_gates>
+Your verification must satisfy:
+- [ ] Every must_have from the plan is checked and reported
+- [ ] Failure details include file path and expected vs actual
+- [ ] Automated checks are run (not just visual inspection)
+- [ ] Verification status is binary (PASS/FAIL, not "mostly works")
+</quality_gates>
+
+<files_to_read>
+CRITICAL: Read these files BEFORE any other action:
+1. .planning/phases/{NN}-{slug}/{plan_id}-PLAN.md — must-haves to verify against
+2. .planning/phases/{NN}-{slug}/SUMMARY-{plan_id}.md — what the executor claims was built
+3. .planning/phases/{NN}-{slug}/VERIFICATION.md — prior verification results (if exists)
+</files_to_read>
+
+Targeted inline verification for plan {plan_id}.
+
+Verify ONLY these files: {comma-separated key_files list}
+
+For each file, check three layers:
+1. Existence — does the file exist?
+2. Substantiveness — is it more than a stub? (>10 lines, no TODO/FIXME placeholders)
+3. Wiring — is it imported/used by at least one other file?
+
+Report PASS or FAIL with a one-line reason per file.
+Write nothing to disk — just return your results as text.

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

@@ -0,0 +1,342 @@
+---
+name: config
+description: "Configure settings: depth, model profiles, features, git, and gates."
+allowed-tools: Read, Write, Bash, Glob, AskUserQuestion
+---
+
+**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.**
+
+## Step 0 — Immediate Output
+
+**Before ANY tool calls**, display this banner:
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║  PLAN-BUILD-RUN ► CONFIGURATION                              ║
+╚══════════════════════════════════════════════════════════════╝
+```
+
+Then proceed to Step 1.
+
+# /pbr:settings — Configure Plan-Build-Run
+
+## Overview
+
+Reads and writes `.planning/config.json`. Interactive configuration with AskUserQuestion.
+
+## References
+
+- `references/config-reference.md` — Full config.json schema (54 fields, 16 feature toggles, validation rules)
+- `references/model-profiles.md` — Model selection guide for agent spawning
+- `references/questioning.md` — Questioning philosophy for config decision guidance
+- `references/ui-brand.md` — Status symbols, banners, formatting for config display output
+
+## Flow
+
+### 1. Load Current Config
+
+Read `.planning/config.json`. If it doesn't exist, display:
+```
+╔══════════════════════════════════════════════════════════════╗
+║  ERROR                                                       ║
+╚══════════════════════════════════════════════════════════════╝
+
+No Plan-Build-Run project found.
+
+**To fix:** Run `/pbr:new-project` first.
+```
+
+### 1b. Quick Start Path (no arguments, first-time configuration)
+
+If no `$ARGUMENTS` provided and this is the first time running `/pbr:settings` interactively (no prior config changes detected), present:
+
+Use AskUserQuestion:
+  question: "How would you like to configure?"
+  header: "Setup"
+  options:
+    - label: "Quick Start (recommended)"
+      description: "Answer 4 essential questions, sensible defaults for everything else"
+    - label: "Advanced (all fields)"
+      description: "Full config with 54 fields for granular customization"
+
+**If user selects "Quick Start":**
+
+First, check for global defaults: `node ${CLAUDE_PLUGIN_ROOT}/bin/pbr-tools.cjs config load-defaults`
+If defaults exist, use them as pre-populated values. Otherwise, use hardcoded defaults shown below.
+
+Present 4 essential questions sequentially:
+
+**Q1. Mode:**
+Use AskUserQuestion:
+  question: "How do you want to work?"
+  header: "Mode"
+  options:
+    - label: "Interactive (default)"  description: "Pause at key gates for your approval"
+    - label: "Autonomous"             description: "Auto-proceed, only stop for critical decisions"
+
+**Q2. Depth:**
+Use AskUserQuestion:
+  question: "How thorough should planning be?"
+  header: "Depth"
+  options:
+    - label: "Standard (default)"     description: "5-8 phases, includes research"
+    - label: "Quick"                  description: "3-5 phases, skip research, ~50% cheaper"
+    - label: "Comprehensive"          description: "8-12 phases, full deep research, ~2x cost"
+
+**Q3. Parallel agents:**
+Use AskUserQuestion:
+  question: "Run agents in parallel when possible?"
+  header: "Parallel"
+  options:
+    - label: "Yes (default)"          description: "Parallel execution of independent plans"
+    - label: "No"                     description: "Sequential execution only"
+
+**Q4. Git branching:**
+Use AskUserQuestion:
+  question: "Git branching strategy?"
+  header: "Branching"
+  options:
+    - label: "Phase (default, recommended)"  description: "Branch per phase for safe undo"
+    - label: "None"                          description: "All work on current branch"
+
+After 4 answers, write config.json with all other fields set to sensible defaults.
+
+**Quick Start defaults:** mode=interactive, depth=standard, parallel=true, git.branching=phase
+
+After writing config, offer: "Save these as your global defaults for future projects? (y/n)"
+If yes, run: `node ${CLAUDE_PLUGIN_ROOT}/bin/pbr-tools.cjs config save-defaults`
+
+Display: "Config written. For full field reference, see `references/config-reference.md`."
+
+Skip to Step 4 (Apply Changes confirmation).
+
+**If user selects "Advanced":** proceed to Step 3 (Interactive Mode) below.
+
+### 2. Parse Arguments
+
+If `$ARGUMENTS` is provided, handle direct setting:
+- `depth quick|standard|comprehensive` — set depth directly
+- `model <agent> <model>` — set model for specific agent (e.g., `model executor sonnet`)
+- `model-profile quality|balanced|budget|adaptive` — set all models at once using a preset
+- `gate <gate-name> on|off` — toggle a gate
+- `feature <feature-name> on|off` — toggle a feature (e.g., `feature auto_continue on`). When the user specifies a feature name without the `features.` prefix, automatically prepend `features.` before writing to config.
+- `session_phase_limit <N>` — set the session phase limit directly (e.g., `/pbr:settings session_phase_limit 5`). Validate N is an integer between 0 and 20. Write to config.json at top level: `"session_phase_limit": N`. Display: "Session phase limit set to {N}. PBR will suggest pausing after {N} phases per session. (0 = disabled)"
+- `git branching none|phase|milestone|disabled` — set branching strategy
+- `git mode disabled` — disable git integration entirely
+- `show` — display current config (default when no args)
+
+### 3. Interactive Mode (no arguments or just `show`)
+
+Display current configuration in a readable format:
+
+```
+Plan-Build-Run Configuration
+=====================
+
+Workflow:
+  Depth: standard (balanced)
+    Research: on   Plan-check: on   Verify: on
+    Scan mappers: 4   Debug rounds: 5   Inline verify: off
+  Mode: interactive
+  Context Strategy: aggressive
+  Session Phase Limit: 3 (pause after 3 phases)
+  # When session_phase_limit is 0, display: "Session Phase Limit: disabled"
+
+Features:
+  ✓ Structured planning    ✓ Goal verification
+  ✓ Context isolation       ✓ Atomic commits
+  ✓ Session persistence     ✓ Research phase
+  ✓ Plan checking           ✗ TDD mode
+  ✓ Status line             ✗ Auto-continue
+  ✗ Auto-advance           ✗ Team discussions
+
+Models:
+  Researcher: sonnet    Planner: inherit     Executor: inherit
+  Verifier: sonnet      Int-Checker: sonnet  Debugger: inherit
+  Mapper: sonnet        Synthesizer: haiku
+
+Parallelization:
+  Enabled: true    Max concurrent: 3
+  Plan-level: true  Task-level: false
+  Use Teams: false
+
+Git:
+  Mode: enabled      Branching: none
+  Commit docs: true
+  Commit format: {type}({phase}-{plan}): {description}
+
+Gates:
+  ✓ Confirm project   ✓ Confirm roadmap   ✓ Confirm plan
+  ✗ Confirm execute    ✓ Confirm transition ✓ Issues review
+
+Status Line:
+  Sections: [phase, plan, status, context]
+  Brand: PLAN-BUILD-RUN
+  Context bar: 20 chars, green<50%, yellow<80%
+
+Spinner Tips: (none configured — using defaults)
+```
+
+Then present the configuration menu using the **settings-category-select** pattern (see `skills/shared/gate-prompts.md`):
+
+Use AskUserQuestion:
+  question: "What would you like to configure?"
+  header: "Configure"
+  options:
+    - label: "Depth"          description: "quick/standard/comprehensive"
+    - label: "Model profile"  description: "quality/balanced/budget/adaptive"
+    - label: "Features"       description: "Toggle workflow features, gates, status line"
+    - label: "Git settings"      description: "branching strategy, commit mode"
+    - label: "Save as defaults"  description: "Save current config as user-level defaults for new projects"
+  multiSelect: false
+
+Note: The original 7 categories are condensed to 5. "Models" (per-agent) is accessible through "Model profile" with a follow-up option. "Gates", "Parallelization", and "Status Line" are grouped under "Features". "Save as defaults" exports to ~/.claude/pbr-defaults.json.
+
+**Follow-up based on selection:**
+
+If user selects "Depth":
+Use AskUserQuestion:
+  question: "Select workflow depth"
+  header: "Depth"
+  options:
+    - label: "Quick"           description: "Budget mode: skip research/plan-check/verifier, 2 scan mappers, ~1-3 fewer spawns per phase"
+    - label: "Standard"        description: "Balanced mode: conditional research, full plan-check and verification, 4 scan mappers (default)"
+    - label: "Comprehensive"   description: "Thorough mode: always research, always verify, inline verification, 4 scan mappers"
+  multiSelect: false
+
+After setting depth, the profile is automatically resolved. Show the user the effective settings:
+  "Depth set to {value}. Effective profile:"
+  Then display the profile summary (research, plan-check, verify, scan mappers, debug rounds, inline verify).
+
+To resolve the profile, run: `node ${CLAUDE_PLUGIN_ROOT}/bin/pbr-tools.cjs config resolve-depth`
+
+If the user wants to override a specific profile setting, they can set `depth_profiles.{depth}.{key}` directly.
+For example: to use quick mode but keep plan-checking, the user would set depth to quick and then override:
+  `/pbr:settings` -> Features -> Plan checking -> Enable
+This writes `depth_profiles.quick.features.plan_checking: true` to config.json.
+
+If user selects "Model profile":
+Use the **model-profile-select** pattern:
+Use AskUserQuestion:
+  question: "Select model profile"
+  header: "Profile"
+  options:
+    - label: "Quality"    description: "opus for all agents (highest cost)"
+    - label: "Balanced"   description: "sonnet/inherit mix (default)"
+    - label: "Budget"     description: "haiku for all agents (lowest cost)"
+    - label: "Adaptive"   description: "sonnet planning, haiku execution"
+  multiSelect: false
+
+If user asks for per-agent model selection (typed "models" or "per-agent"), present individual agent selection as plain text: list the agents and ask which one to change, then ask for the model. This is a freeform flow because agent names are dynamic.
+
+If user selects "Features":
+List all features and gates with current status, then use the **toggle-confirm** pattern for each change.
+**Feature name normalization:** When toggling a feature, if the user specifies a bare name (e.g., `inline_verify`), normalize it to `features.inline_verify` before writing to config. All feature flags live under the `features.*` namespace in config.json.
+Use AskUserQuestion:
+  question: "Enable {feature_name}?"
+  header: "Toggle"
+  options:
+    - label: "Enable"   description: "Turn this feature on"
+    - label: "Disable"  description: "Turn this feature off"
+  multiSelect: false
+
+Repeat for each feature the user wants to change. Show updated status after each toggle.
+
+For numeric settings like `session_phase_limit`, use the direct command: `/pbr:settings session_phase_limit <N>`
+
+If user selects "Git settings":
+Use AskUserQuestion:
+  question: "Select branching strategy"
+  header: "Branching"
+  options:
+    - label: "None"        description: "All work on current branch"
+    - label: "Phase"       description: "New branch per phase"
+    - label: "Milestone"   description: "New branch per milestone"
+    - label: "Disabled"    description: "No git integration"
+  multiSelect: false
+
+If user selects "Save as defaults":
+Save current project config as user-level defaults for future projects:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/bin/pbr-tools.cjs" config save-defaults
+```
+
+Display: "Saved your preferences to ~/.claude/pbr-defaults.json. New projects created with /pbr:setup will use these as starting values."
+
+If user types something else (freeform): interpret as a direct setting command and handle via Step 2 argument parsing logic.
+
+### 4. Apply Changes
+
+Update config.json with new values. Show what changed with a branded completion:
+```
+╔══════════════════════════════════════════════════════════════╗
+║  PLAN-BUILD-RUN ► CONFIG UPDATED ✓                           ║
+╚══════════════════════════════════════════════════════════════╝
+
+Updated:
+  depth: standard → quick
+  models.executor: inherit → sonnet
+
+
+
+╔══════════════════════════════════════════════════════════════╗
+║  ▶ NEXT UP                                                   ║
+╚══════════════════════════════════════════════════════════════╝
+
+**Continue your workflow** — settings saved
+
+`/pbr:progress`
+
+<sub>`/clear` first → fresh context window</sub>
+
+
+
+**Also available:**
+- `/pbr:continue` — execute next logical step
+- `/pbr:settings` — change more settings
+
+
+```
+
+## Config Schema
+
+See `skills/begin/templates/config.json.tmpl` for the full schema with defaults.
+
+### Version Migration
+
+If config `version` is older than current (2), run migration:
+- v1 → v2: Add missing fields with defaults, rename `model_profile` → per-agent `models` object
+
+## Model Profile Presets
+
+The `model-profile` command sets all agent models at once:
+
+| Profile | researcher | planner | executor | verifier | int-checker | debugger | mapper | synthesizer |
+|---------|-----------|---------|----------|----------|-------------|----------|--------|-------------|
+| `quality` | opus | opus | opus | opus | sonnet | opus | sonnet | sonnet |
+| `balanced` | sonnet | inherit | inherit | sonnet | sonnet | inherit | sonnet | haiku |
+| `budget` | haiku | haiku | haiku | haiku | haiku | haiku | haiku | haiku |
+| `adaptive` | sonnet | sonnet | inherit | sonnet | haiku | inherit | haiku | haiku |
+
+`balanced` is the default and matches the initial config template. `adaptive` front-loads intelligence in research/planning and uses lighter models for mechanical work.
+
+## Feature Reference
+
+| Feature | Key | Default | Description |
+|---------|-----|---------|-------------|
+| Auto-continue | `features.auto_continue` | `false` | Automatically spawn continuation agents without user prompt |
+| Auto-advance | `features.auto_advance` | `false` | Chain build→review→plan automatically in autonomous mode |
+| Session phase limit | `session_phase_limit` | `3` | Maximum phases per session before auto-pause. 0 disables. Requires `auto_continue: true`. |
+| Team discussions | `features.team_discussions` | `false` | Enable team-based discussion workflows |
+
+**Team boundaries**: Teams are NEVER used for execution, planning, or verification. Teams are only for discussion and brainstorming workflows. All execution, planning, and verification use single-agent Task() spawns with proper subagent types.
+
+## Validation
+
+- `depth` must be one of: quick, standard, comprehensive
+- `models.*` must be one of: sonnet, inherit, haiku, opus
+- `context_strategy` must be one of: aggressive, balanced, minimal
+- `git.branching` must be one of: none, phase, milestone, disabled
+- `git.mode` must be one of: enabled, disabled. When `disabled`, no git commands are run (no commits, no branching). Useful for prototyping or non-git projects.
+- Boolean fields must be true/false

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

@@ -0,0 +1,190 @@
+---
+name: continue
+description: "Execute the next logical step automatically. No prompts, no decisions — just do it."
+allowed-tools: Read, Write, Bash, Glob, Grep, Task, Skill
+---
+
+**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:continue — Action-Oriented Resumption
+
+You are running the **continue** skill. Unlike `/pbr:progress` which shows the dashboard and suggests the next action, `/pbr:continue` determines and EXECUTES the next logical step automatically. Stops safely at milestones, checkpoints, errors, and verification gaps.
+
+This skill runs **inline** and may delegate to other skills via Task().
+
+---
+
+## Step 0 — Immediate Output
+
+**Before ANY tool calls**, display this banner:
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║  PLAN-BUILD-RUN ► NEXT STEP                                  ║
+╚══════════════════════════════════════════════════════════════╝
+```
+
+Then proceed to Step 1.
+
+## Context Budget
+
+Reference: `skills/shared/context-budget.md` for the universal orchestrator rules.
+
+Additionally for this skill:
+- **Minimize** state reads — read only STATE.md lines 1-20 to determine next action
+- **Delegate** execution to the appropriate skill via Skill() or Task()
+
+---
+
+## Core Principle
+
+**Do, don't ask.** Read STATE.md, determine the next action, and execute it. The user wants hands-off forward progress.
+
+---
+
+## Flow
+
+### Step 1: Read State
+
+Before reading STATE.md, check `.planning/config.json` exists. If it does not exist, display:
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║  ERROR                                                       ║
+╚══════════════════════════════════════════════════════════════╝
+
+No Plan-Build-Run project found.
+
+**To fix:** Run `/pbr:new-project` to start a new project.
+```
+
+Stop execution.
+
+Read `.planning/STATE.md` and determine current position:
+- Current phase number and name
+- Current plan progress
+- Phase status (planning, building, reviewing, complete)
+
+Then read `.planning/ROADMAP.md` to identify the current milestone boundary:
+- Find which `## Milestone:` section contains the current phase
+- Determine if the current phase is the **last phase** in that milestone section
+- If this is the last phase and it is verified/complete, warn: "This is the final phase of milestone {name}. After verification, run `/pbr:milestone` to complete it."
+- If the current phase's `Depends on` references a phase from the **previous** milestone that is not yet complete, warn: "Cross-milestone dependency: Phase {N} depends on Phase {M} from milestone {prev}, which is not yet complete."
+
+If STATE.md doesn't exist, display:
+```
+╔══════════════════════════════════════════════════════════════╗
+║  ERROR                                                       ║
+╚══════════════════════════════════════════════════════════════╝
+
+No project state found.
+
+**To fix:** Run `/pbr:new-project` first.
+```
+
+#### Context Budget Guard
+
+Before proceeding to priority evaluation, check for runaway continue chains:
+
+1. Read `last_command` from STATE.md. **If `last_command` is missing, empty, or the field does not exist, skip directly to the fallback detection** — do NOT error or warn.
+2. If `last_command` is present and equals `/pbr:continue`, this is a chained continue. Check session context for consecutive `/pbr:continue` invocations.
+3. **Fallback detection** — if `last_command` is not available or not present in STATE.md:
+   - Check `.planning/.active-skill` file — if it contains `continue`, treat as a chained continue
+   - Check STATE.md `last_action` field — if it contains `continue`, treat as a chained continue
+   - If neither source is available, assume this is the first invocation (do not warn)
+4. **If this is the 6th consecutive `/pbr:continue` in a row**, display:
+
+```
+WARNING: Context budget warning: 6 consecutive auto-continues detected.
+Recommend running /pbr:pause-work then resuming in a fresh session.
+```
+
+Then present the user with a choice:
+- **"Continue"** — proceed with the next action
+- **"Pause"** — run `/pbr:pause-work` logic to save state and stop
+
+This prevents runaway chains that fill the context window without a human checkpoint.
+
+### Step 2: Scan for Priority Items
+
+Check the resumption priority hierarchy (same as /pbr:resume-work):
+
+1. **UAT Blockers**: VERIFICATION.md with `status: gaps_found` → Execute `/pbr:plan-phase {N} --gaps`
+2. **Checkpoint pending**: `.checkpoint-manifest.json` with pending items → Resume the build
+3. **Continue-here file**: `.continue-here.md` exists → Follow its next step
+4. **Incomplete build**: PLAN.md files without SUMMARY.md → Execute `/pbr:execute-phase {N}`
+4b. **Empty phase directory**: Phase directory exists but contains no PLAN.md or SUMMARY.md files → Execute `/pbr:plan-phase {N}`
+5. **Unverified phase**: All plans complete, no VERIFICATION.md → Execute `/pbr:verify-work {N}`
+5b. **Verified with gaps**: VERIFICATION.md with `status: complete-with-gaps` → Display: "Phase {N} verified with accepted gaps. Proceeding to next phase." Then chain to `/pbr:plan-phase {N+1}` (same as item 6).
+6. **Phase complete, more phases exist**: Verification passed → Execute `/pbr:plan-phase {N+1}`
+7. **Last phase in current milestone complete**: Verification passed on the last phase of the current milestone's phase range → Stop. Display: "Milestone complete! Run `/pbr:audit-milestone` to verify cross-phase integration, then `/pbr:complete-milestone` to archive."
+8. **Between milestones**: Current milestone is marked complete in STATE.md, but more milestones exist or user needs to create the next one → Stop. Display: "Current milestone is complete. Run `/pbr:new-milestone` to start the next milestone, or `/pbr:audit-milestone` if not yet audited."
+9. **Unknown state**: STATE.md exists but status field is empty, missing, or unrecognized → Display: "Could not determine workflow state from STATE.md. Status: '{raw_status}'." **To fix:** Run `/pbr:health` to diagnose and repair, or `/pbr:progress` to see current state. Stop execution (do not guess).
+
+### Step 3: Execute
+
+Based on the determined action, display the delegation indicator to the user:
+```
+◐ Delegating to /pbr:{skill} {args}...
+```
+
+Then invoke the appropriate skill via the Skill tool. **NEVER read SKILL.md files into your context** — this wastes the main context budget with 500+ lines of instructions. Instead, use the Skill tool which runs the skill in a clean invocation:
+
+| Situation | Action | How |
+|-----------|--------|-----|
+| Gaps need closure | Plan gap closure | `Skill({ skill: "pbr:plan", args: "{N} --gaps" })` |
+| Build incomplete | Continue build | `Skill({ skill: "pbr:build", args: "{N}" })` |
+| Review needed | Run review | `Skill({ skill: "pbr:review", args: "{N}" })` |
+| Next phase needed | Plan next phase | `Skill({ skill: "pbr:plan", args: "{N+1}" })` |
+| Project not started | Plan phase 1 | `Skill({ skill: "pbr:plan", args: "1" })` |
+
+Where `{N}` is the current phase number determined from STATE.md in Step 1.
+
+### Step 4: Report and Chain
+
+After execution completes, display a branded completion:
+```
+╔══════════════════════════════════════════════════════════════╗
+║  PLAN-BUILD-RUN ► STEP COMPLETE ✓                            ║
+╚══════════════════════════════════════════════════════════════╝
+
+✓ Completed: {what was done}
+
+
+
+╔══════════════════════════════════════════════════════════════╗
+║  ▶ NEXT UP                                                   ║
+╚══════════════════════════════════════════════════════════════╝
+
+**{Next action description}**
+
+`/pbr:continue` or `{specific command}`
+
+
+```
+
+**If `features.auto_advance` is `true` AND `mode` is `autonomous`:**
+After the delegated skill completes, immediately re-run Step 1-3 to determine and execute the NEXT action. Continue chaining until a hard stop is reached. This enables hands-free phase cycling: build→review→plan→build→...
+
+---
+
+## Hard Stops
+
+Do NOT auto-continue when:
+- `config.mode` is NOT `autonomous` and a gate confirmation is needed
+- A checkpoint requires human input (decision, verify, action)
+- An error occurred during execution
+- The milestone is complete
+- Verification found gaps (need user review before advancing)
+
+In these cases, explain why auto-continue stopped and what the user needs to do.
+
+---
+
+## Anti-Patterns
+
+1. **DO NOT** ask the user what to do — determine it from state
+2. **DO NOT** skip error handling — if something fails, stop and report
+3. **DO NOT** continue past checkpoints that need human input
+4. **DO NOT** auto-continue into a new milestone — that needs user initiation
+5. **DO NOT** modify STATE.md directly — let the delegated skill handle it

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

@@ -0,0 +1,12 @@
+---
+name: dashboard
+description: "Launch the PBR web dashboard for the current project."
+allowed-tools: Bash
+argument-hint: "[--port N]"
+---
+
+Run this Bash command and display the output to the user. Nothing else.
+
+```bash
+node .claude/plan-build-run/bin/dashboard-launch.cjs $ARGUMENTS
+```