@sienklogic/plan-build-run 2.0.0

package/plugins/pbr/skills/shared/revision-loop.md

@@ -0,0 +1,81 @@
+# Revision Loop Pattern
+
+Standard pattern for iterative agent revision with feedback. Used when a checker/validator finds issues and the producing agent needs to revise its output.
+
+> Referenced by: plan, import, review skills
+
+---
+
+## Pattern: Check-Revise-Escalate (max 3 iterations)
+
+This pattern applies whenever:
+1. An agent produces output (plans, imports, gap-closure plans)
+2. A checker/validator evaluates that output
+3. Issues are found that need revision
+
+### Flow
+
+```
+iteration = 0
+
+LOOP:
+  1. Run checker/validator on current output
+  2. Read checker results
+  3. If PASSED or only INFO-level issues:
+     → Accept output, exit loop
+  4. If BLOCKER or WARNING issues found:
+     a. iteration += 1
+     b. If iteration > 3:
+        → Escalate to user (see "After 3 Iterations" below)
+     c. Re-spawn the producing agent with checker feedback appended
+     d. After revision completes, go to LOOP
+```
+
+### Re-spawn Prompt Structure
+
+When re-spawning the producing agent for revision, append the checker feedback:
+
+```
+<checker_feedback>
+{Inline the checker's issue report}
+</checker_feedback>
+
+<revision_instructions>
+Address ALL BLOCKER and WARNING issues identified above.
+- For each BLOCKER: make the required change
+- For each WARNING: address or explain why it's acceptable
+- Do NOT introduce new issues while fixing existing ones
+- Preserve all content not flagged by the checker
+</revision_instructions>
+```
+
+### After 3 Iterations
+
+If issues persist after 3 revision cycles:
+
+1. Present remaining issues to the user
+2. Use AskUserQuestion (pattern: yes-no from `skills/shared/gate-prompts.md`):
+   question: "Issues remain after 3 revision attempts. Proceed with current output?"
+   header: "Proceed?"
+   options:
+     - label: "Proceed anyway"   description: "Accept output with remaining issues"
+     - label: "Adjust approach"  description: "Discuss a different approach"
+3. If "Proceed anyway": accept current output and continue
+4. If "Adjust approach" or "Other": discuss with user, then re-enter the producing step with updated context
+
+### Skill-Specific Variations
+
+| Skill | Producer Agent | Checker Agent | Revision Template |
+|-------|---------------|---------------|-------------------|
+| plan | planner | plan-checker | `skills/plan/templates/revision-prompt.md.tmpl` |
+| import | inline (orchestrator) | plan-checker | Inline revision by orchestrator |
+| review (auto-fix) | planner (gap mode) | plan-checker | Same as plan |
+
+---
+
+## Important Notes
+
+- **INFO-level issues are always acceptable** -- they don't trigger revision
+- **Each iteration gets a fresh agent spawn** -- don't try to continue in the same context
+- **Checker feedback must be inlined** -- the revision agent needs to see exactly what failed
+- **Don't silently swallow issues** -- always present the final state to the user after exiting the loop

package/plugins/pbr/skills/shared/state-loading.md

@@ -0,0 +1,62 @@
+# State Loading Pattern
+
+Standard pattern for loading project state at the start of a skill invocation. Include this fragment in skills that need project context.
+
+---
+
+## Minimal State Read (for simple skills)
+
+Use when the skill only needs to know the current position. Skills: status, help, note, todo, pause, config.
+STATE.md is lean — it contains only current-phase context. Historical data lives in HISTORY.md.
+
+```
+1. Read .planning/STATE.md lines 1-20 only
+2. Extract: current phase, plan, status
+3. If STATE.md missing: inform user, suggest /pbr:begin
+```
+
+## Full State Read (for workflow skills)
+
+Use when the skill needs complete project context. Skills: build, plan, review, begin, milestone, continue, resume, debug.
+
+Reading order (always this sequence):
+
+```
+1. Read .planning/STATE.md
+   - Extract: Current Position section (phase, plan, status)
+   - Extract: Blockers/Concerns section (if not "None")
+   - Extract: Session Continuity section (if present)
+
+2. Read .planning/config.json
+   - Extract: depth, mode, features flags
+   - Extract: models configuration
+   - Extract: gates configuration
+
+3. Read .planning/ROADMAP.md (if exists)
+   - Extract: Phase Overview table (current + next 2 phases)
+   - Extract: dependency chain for current phase
+   - Do NOT read full phase details for past phases
+
+4. Read .planning/HISTORY.md (ONLY when cross-phase context is needed)
+   - Do NOT read HISTORY.md for normal build/plan/review operations
+   - Read ONLY when: debugging a regression that may trace to a prior phase,
+     or when a milestone audit needs historical context
+   - Use: `node ${CLAUDE_PLUGIN_ROOT}/scripts/pbr-tools.js history load`
+   - This returns structured JSON -- do not read the raw file
+```
+
+## Error Handling
+
+| File Missing | Action |
+|-------------|--------|
+| STATE.md | Warn user: "No STATE.md found. Run /pbr:begin to initialize." |
+| config.json | Use defaults (depth: standard, mode: interactive) |
+| ROADMAP.md | Continue without roadmap context (acceptable for quick tasks) |
+| .planning/ dir | Exit: "No .planning directory. This is not a Plan-Build-Run project." |
+
+## What NOT to Read During State Loading
+
+- Full SUMMARY.md bodies from prior phases (read frontmatter only if needed)
+- Agent definition files (agents/*.md) — auto-loaded by subagent_type
+- PLAN.md files from other phases (only current phase plans)
+- .planning/logs/ files (only health skill reads these)

package/plugins/pbr/skills/shared/state-update.md

@@ -0,0 +1,161 @@
+# STATE.md Update Pattern
+
+Standard pattern for updating `.planning/STATE.md`. Include this fragment in skills that modify project state.
+
+---
+
+## When to Update STATE.md
+
+| Event | What to Update |
+|-------|---------------|
+| Phase status changes (planned, building, verified) | Current Position section |
+| Plan completes or fails | Plan counter, status, last activity |
+| New decision made | Accumulated Context > Decisions |
+| Blocker discovered or resolved | Accumulated Context > Blockers/Concerns |
+| Session starts or ends | Session Continuity section |
+| Milestone boundary | Milestone section |
+
+---
+
+## Section Format
+
+STATE.md has 5 sections. Always preserve this order:
+
+### 1. Project Reference (lines 4-7)
+```
+## Project Reference
+See: .planning/PROJECT.md (updated {date})
+**Core value:** {one-liner from PROJECT.md}
+**Current focus:** Phase {N} - {name}
+```
+Update `Current focus` when phase changes.
+
+### 2. Current Position (lines 9-14)
+```
+## Current Position
+Phase: {N} of {total} ({Phase name})
+Plan: {completed} of {total_plans} in current phase
+Status: {Ready to plan | Planning | Building | Reviewing | Verified}
+Last activity: {YYYY-MM-DD} -- {brief description}
+Progress: [{progress_bar}] {percent}%
+```
+
+**Progress bar format:** 20 characters using `█` (done) and `░` (remaining).
+```
+Phase 3 of 10 = 20% → [████░░░░░░░░░░░░░░░░] 20%
+Phase 7 of 10 = 70% → [██████████████░░░░░░] 70%
+```
+Calculation: `filled = Math.round((completed_phases / total_phases) * 20)`
+
+### 3. Accumulated Context (lines 16-25)
+```
+## Accumulated Context
+
+### Decisions
+{Active decisions relevant to current work}
+
+### Pending Todos
+{Outstanding items, or "None"}
+
+### Blockers/Concerns
+{Active blockers, or "None"}
+```
+
+### 4. Milestone (lines 27-30)
+```
+## Milestone
+Current: {project_name} {version}
+Phases: {start}-{end}
+Status: {In progress | Complete}
+```
+
+### 5. Session Continuity (lines 32-35)
+```
+## Session Continuity
+Last session: {ISO timestamp}
+Stopped at: {brief description of last action}
+Resume file: {path or "None"}
+```
+
+---
+
+## Size Limit Enforcement
+
+**Hard limit: 150 lines.** After every STATE.md write, check the line count. If over 150 lines, compact:
+
+1. **Collapse completed phase entries** to one-liners:
+   ```
+   Phase 1: verified 2026-02-08
+   Phase 2: verified 2026-02-09
+   ```
+2. **Remove decisions already captured in CONTEXT.md** — avoid duplication between STATE.md and phase CONTEXT.md files
+3. **Remove old session entries** — keep only the current session's continuity data
+4. **Keep these always:** current phase detail, active blockers, core value statement, milestone info
+
+If still over 150 lines after compaction, the Accumulated Context section has grown too large. Move non-critical decisions to the phase's CONTEXT.md file.
+
+---
+
+## HISTORY.md Archival
+
+When a milestone completes or a phase is verified, archive historical context to `.planning/HISTORY.md` to keep STATE.md lean:
+
+### What to Archive
+
+| Trigger | What moves to HISTORY.md |
+|---------|-------------------------|
+| Phase verified | One-liner summary: "Phase {N} ({name}): verified {date}" |
+| Milestone complete | Full milestone record: name, phases covered, key decisions |
+| Accumulated Context > 20 lines | Decisions from completed phases (keep only current-phase decisions in STATE.md) |
+
+### How to Archive
+
+Use `pbr-tools.js history append`:
+```
+node ${CLAUDE_PLUGIN_ROOT}/scripts/pbr-tools.js history append phase "Phase 3 (Auth)" "Verified 2026-02-10. Key decisions: JWT + httpOnly cookies, Discord OAuth."
+node ${CLAUDE_PLUGIN_ROOT}/scripts/pbr-tools.js history append milestone "v1.0 User Auth" "Phases 1-4. All verified. Core auth flow complete."
+```
+
+### After Archiving
+
+Remove the archived content from STATE.md. The Accumulated Context section should contain ONLY:
+- Decisions relevant to the **current** phase
+- Active (unresolved) blockers
+- Pending todos for the current milestone
+
+Historical decisions live in HISTORY.md and per-phase SUMMARY.md files.
+
+---
+
+## Common Update Scenarios
+
+### After build completes
+```
+Plan: {N} of {total} in current phase
+Status: Building → Reviewing (if all plans done) or Building (if more plans remain)
+Last activity: {date} -- Built plan {plan_id}
+```
+
+### After review/verification passes
+```
+Status: Verified
+Last activity: {date} -- Phase {N} verified
+Progress: [{updated bar}] {new percent}%
+```
+Also update **Current focus** to point to the next phase.
+
+### After pause
+```
+## Session Continuity
+Last session: {timestamp}
+Stopped at: {what was in progress}
+Resume file: .planning/.pause-state.json
+```
+
+### After milestone completion
+```
+## Milestone
+Current: {project_name} {next_version}
+Phases: {new_start}-{new_end}
+Status: In progress
+```

package/plugins/pbr/skills/shared/universal-anti-patterns.md

@@ -0,0 +1,33 @@
+# Universal Anti-Patterns
+
+Rules that apply to ALL skills. Individual skills may have additional skill-specific anti-patterns listed in their own SKILL.md.
+
+> Referenced by: all skills with Context Budget or Anti-Patterns sections
+
+---
+
+## Context Budget Rules (apply to every skill)
+
+These rules prevent context rot -- quality degradation as the context window fills up.
+
+1. **Never** read agent definition files (`agents/*.md`) -- `subagent_type` auto-loads them. Reading agent definitions into the orchestrator wastes main context for content that is automatically injected into subagent sessions.
+2. **Never** inline large files into Task() prompts -- tell agents to read files from disk instead. Agents have their own 200k token context windows.
+3. **Minimize** reading subagent output into main context -- read only frontmatter, status fields, or summaries. Never read full SUMMARY.md, VERIFICATION.md, or RESEARCH.md bodies into the orchestrator unless specifically needed for inline presentation.
+4. **Delegate** heavy work to Task() subagents -- the orchestrator routes, it does not build, analyze, research, investigate, or verify.
+5. **Proactive pause warning**: If you have already consumed significant context (large file reads, multiple subagent results), warn the user: "Context budget is getting heavy. Consider running `/pbr:pause` to checkpoint progress." Suggest pause proactively rather than waiting for compaction.
+
+## File Reading Rules (apply to every skill)
+
+6. **Never** read full SUMMARY.md bodies from prior phases -- read frontmatter only (unless the skill specifically requires body content for presentation).
+7. **Never** read full PLAN.md files from other phases -- only current phase plans.
+8. **Never** read `.planning/logs/` files -- only the health skill reads these.
+9. **Do not** re-read full file contents when frontmatter is sufficient -- frontmatter contains status, key_files, commits, and provides fields.
+
+## Behavioral Rules (apply to every skill)
+
+10. **Do not** re-litigate decisions that are already locked in CONTEXT.md -- respect locked decisions unconditionally.
+11. **Do not** create artifacts the user did not approve -- always confirm before writing new planning documents.
+12. **Do not** modify files outside the skill's stated scope -- check the "Files Created/Modified" table in each skill.
+13. **Do not** suggest multiple next actions without clear priority -- one primary suggestion, alternatives listed secondary.
+14. **Do not** use `git add .` or `git add -A` -- stage specific files only.
+15. **Do not** include sensitive information (API keys, passwords, tokens) in planning documents or commits.

package/plugins/pbr/skills/status/SKILL.md

@@ -0,0 +1,353 @@
+---
+name: status
+description: "Show current project status and suggest what to do next."
+allowed-tools: Read, Glob, Grep, AskUserQuestion
+---
+
+# /pbr:status — Project Status Dashboard
+
+You are running the **status** skill. Your job is to read the project state and present a clear, actionable status dashboard. You suggest the most logical next action based on where the project is.
+
+This skill runs **inline** and is **read-only** — it never modifies any files.
+
+---
+
+## Core Principle
+
+**Show the user where they are and what to do next.** The status display should be a quick glance, not a wall of text. Surface problems and route to the right action.
+
+---
+
+## Flow
+
+### Step 1: Read Project State
+
+**Tooling shortcut**: Instead of parsing multiple files manually, you can run:
+```bash
+node ${CLAUDE_PLUGIN_ROOT}/scripts/pbr-tools.js state load
+```
+and
+```bash
+node ${CLAUDE_PLUGIN_ROOT}/scripts/pbr-tools.js state check-progress
+```
+These return structured JSON with config, state, roadmap, and filesystem-verified progress. Falls back gracefully if the script is missing — parse files manually in that case.
+
+Read the following files (skip any that don't exist):
+
+1. **`.planning/config.json`** — Project settings
+   - If this doesn't exist, display:
+     ```
+     ╔══════════════════════════════════════════════════════════════╗
+     ║  ERROR                                                       ║
+     ╚══════════════════════════════════════════════════════════════╝
+
+     No Plan-Build-Run project found.
+
+     **To fix:** Run `/pbr:begin` to start a new project, or `/pbr:scan` to analyze an existing codebase.
+     ```
+   - Stop here if no project found.
+
+2. **`.planning/STATE.md`** — Current position, progress, blockers
+   - Extract: current phase, current plan, overall progress, blockers, session info
+
+3. **`.planning/ROADMAP.md`** — Phase overview
+   - Extract: all phases with names, descriptions, status indicators
+
+4. **`.planning/PROJECT.md`** — Project metadata (if exists)
+   - Extract: project name, milestone info
+
+5. **`.planning/REQUIREMENTS.md`** — Requirements (if exists)
+   - Extract: requirement completion status if tracked
+
+### Step 2: Scan Phase Directories
+
+For each phase listed in ROADMAP.md:
+
+1. Check if the phase directory exists in `.planning/phases/`
+2. If exists, scan for:
+   - `CONTEXT.md` — discussion happened
+   - `PLAN-*.md` or plan files — plans exist
+   - `SUMMARY-*.md` or summary files — plans were executed
+   - `VERIFICATION.md` — phase was reviewed
+   - `.continue-here.md` — paused work
+
+3. Calculate phase status:
+
+| Condition | Status |
+|-----------|--------|
+| No directory | Not started |
+| Directory exists, no plans | Discussed only |
+| Plans exist, no summaries | Planned (ready to build) |
+| Some summaries, not all | Building (in progress) |
+| All summaries exist | Built (ready to review) |
+| VERIFICATION.md exists, status=passed | Verified (complete) |
+| VERIFICATION.md exists, status=gaps_found | Needs fixes |
+
+4. Calculate progress percentage:
+   - Count total plans across all phases
+   - Count plans with SUMMARY.md (status=completed)
+   - Progress = completed / total * 100
+
+### Step 2b: Check STATE.md Size and Consistency
+
+Count lines in `.planning/STATE.md`. If over 150 lines, add a warning to the dashboard:
+```
+Warning: STATE.md is {N} lines (limit: 150). Run any build/review command to auto-compact it.
+```
+
+**Discrepancy check:** Compare STATE.md phase/plan/status claims against the filesystem:
+- Does the phase directory exist? If not: `Warning: STATE.md references Phase {N} but no directory exists.`
+- Does the plan count match? If not: `Warning: STATE.md says {X} plans but filesystem has {Y}.`
+- Does the status match? If STATE.md says "verified" but no `VERIFICATION.md` exists: `Warning: STATE.md says "verified" but no VERIFICATION.md found.`
+
+If any discrepancy found, add: `Run /pbr:resume to auto-reconcile STATE.md.`
+
+### Step 3: Check for Special Conditions
+
+#### Paused Work
+- Search for `.continue-here.md` files in `.planning/phases/`
+- If found: note the phase and brief description of where work stopped
+
+#### Verification Gaps
+- Search for `VERIFICATION.md` files with `gaps_found` status
+- If found: note which phases have gaps
+
+#### Cross-Phase Re-Planning Check
+- For each planned phase, check if its dependency phases have been built yet
+- Logic:
+  1. Read ROADMAP.md to find phase dependencies (phases that come before)
+  2. If Phase N has plans but Phase N-1 doesn't have summaries (wasn't built yet):
+     - This means Phase N was planned without knowledge of what Phase N-1 actually produced
+     - Flag for re-planning
+- **Dependency fingerprint check**: For each planned phase with `dependency_fingerprints` in plan frontmatter:
+  1. Compare the fingerprints against current dependency SUMMARY.md files
+  2. If any fingerprint is stale (dependency was re-built after the plan was created):
+     - Flag: "WARN: Phase {N} plans may be stale — dependency phase {M} was re-built since planning. Consider re-planning with `/pbr:plan {N}`."
+
+#### Active Debug Sessions
+- Check `.planning/debug/` for files with `status: active`
+- Note any active debug sessions
+
+#### Pending Todos
+- Check `.planning/todos/pending/` for pending todo files
+- Count and summarize if any exist
+
+#### Quick Notes
+- Check `.planning/NOTES.md` for active note entries
+- Count active notes (lines matching `^- \[` that don't contain `[promoted]`)
+- Also check `~/.claude/notes.md` for global notes
+
+#### Quick Tasks
+- Check `.planning/quick/` for recent quick tasks
+- Note any failed or partial quick tasks
+
+### Step 4: Display Status Dashboard
+
+Present the status in this format:
+
+```
+Project: {name from PROJECT.md or config.json}
+Phase: {current} of {total} -- {current phase name}
+Progress: [{progress bar}] {percentage}%
+
+Phase Status:
+| Phase | Status | Plans | Progress |
+|-------|--------|-------|----------|
+| 1. {name} | {status indicator} {status text} | {completed}/{total} | {percentage}% |
+| 2. {name} | {status indicator} {status text} | {completed}/{total} | {percentage}% |
+| ...
+
+{If blockers exist:}
+Blockers:
+- {blocker 1}
+- {blocker 2}
+
+{If no blockers:}
+Blockers: None
+
+{If paused work:}
+Paused: Phase {N} has a checkpoint at plan {M}. Run `/pbr:resume` to continue.
+
+{If verification gaps:}
+Gaps: Phase {N} verification found {count} gaps. Run `/pbr:plan {N} --gaps` to address.
+
+{If cross-phase re-planning needed:}
+Warning: Phase {N} was planned before Phase {M} was built. Consider re-planning with `/pbr:plan {N}`.
+
+{If active debug sessions:}
+Debug: {count} active session(s). Run `/pbr:debug` to continue.
+
+{If pending todos:}
+Todos: {count} pending. Run `/pbr:todo list` to see them.
+
+{If notes exist:}
+Notes: {count} quick capture(s). `/pbr:note list` to review.
+```
+
+### Progress Bar
+
+Generate a 20-character progress bar:
+
+```
+[####################] 100%    (all filled)
+[################....] 80%     (16 filled, 4 empty)
+[########............] 40%     (8 filled, 12 empty)
+[....................] 0%      (all empty)
+```
+
+Use the Unicode block characters from the UI formatting reference:
+- Filled: block character
+- Empty: light shade
+
+### Status Indicators
+
+Use indicators from `references/ui-formatting.md`:
+
+| Status | Indicator |
+|--------|-----------|
+| Complete/Verified | checkmark |
+| In Progress | half-filled circle |
+| Not started | empty circle |
+| Needs fixes | warning triangle |
+| Blocked | blocked symbol |
+
+### Step 5: Smart Routing
+
+Based on the project state, suggest the single most logical next action:
+
+**Decision tree:**
+
+```
+1. Is there paused work (.continue-here.md)?
+   YES → "Resume your work: `/pbr:resume`"
+
+2. Is there a verification with gaps?
+   YES → "Fix verification gaps: `/pbr:plan {N} --gaps`"
+
+3. Is the current phase planned but not built?
+   YES → "Build the current phase: `/pbr:build {N}`"
+
+4. Is the current phase built but not reviewed?
+   YES → "Review what was built: `/pbr:review {N}`"
+
+5. Is the current phase verified (complete)?
+   YES → Is there a next phase?
+     YES → Was next phase already planned?
+       YES → Does it need re-planning? (dependency phase changed)
+         YES → "Re-plan with updated context: `/pbr:plan {N+1}`"
+         NO → "Build the next phase: `/pbr:build {N+1}`"
+       NO → "Plan the next phase: `/pbr:plan {N+1}`"
+     NO → "All phases complete! Your next steps:\n       -> /pbr:milestone audit — verify cross-phase integration (recommended)\n       -> /pbr:milestone complete — archive this milestone and create a git tag\n       -> /pbr:milestone new — start planning the next set of features"
+
+6. Is the current phase not started?
+   YES → Has it been discussed?
+     YES → "Plan this phase: `/pbr:plan {N}`"
+     NO → "Start with a discussion: `/pbr:discuss {N}` or jump to `/pbr:plan {N}`"
+
+7. Active debug sessions?
+   YES → "Continue debugging: `/pbr:debug`"
+
+8. Nothing active?
+   → "Start your project: `/pbr:begin`"
+```
+
+**If only one reasonable next action exists**, present it with branded routing:
+
+```
+───────────────────────────────────────────────────────────────
+
+## ▶ Next Up
+
+**{brief explanation}**
+
+`{suggested command}`
+
+<sub>`/clear` first → fresh context window</sub>
+
+───────────────────────────────────────────────────────────────
+```
+
+**If multiple reasonable next actions exist** (2-3 alternatives), use the **action-routing** pattern (see `skills/shared/gate-prompts.md`):
+
+Use AskUserQuestion:
+  question: "What would you like to do next?"
+  header: "Next Step"
+  options:
+    - label: "{primary action}"    description: "{brief explanation}"
+    - label: "{alternative 1}"     description: "{brief explanation}"
+    - label: "{alternative 2}"     description: "{brief explanation}"
+    - label: "Something else"      description: "Enter a different command"
+  multiSelect: false
+
+Build options dynamically from the decision tree results. Always include "Something else" as the last option. Generate 1-3 real options based on the state analysis.
+
+**After user selects an option:**
+- If they selected a real action: display "Run: `/dev:{action} {args}`" so they can execute it
+- If they selected "Something else": ask what they'd like to do (freeform text)
+- This skill remains read-only — display the command, do not execute it
+
+---
+
+## Edge Cases
+
+### No `.planning/` directory at all
+- Display: "No Plan-Build-Run project found."
+- Suggest: `/pbr:begin` to start a new project
+- Also mention: `/pbr:scan` if there's an existing codebase to analyze first
+
+### STATE.md exists but is outdated
+- STATE.md may not reflect the actual file system state
+- Always verify by scanning phase directories
+- If STATE.md disagrees with the file system, note the discrepancy:
+  "Note: STATE.md says Phase 2 is in progress, but all plans have summaries. Status may need updating."
+
+### All phases complete
+- Celebrate briefly: "All phases complete!"
+- Suggest: `/pbr:milestone audit` to verify cross-phase integration (recommended first)
+- Then: `/pbr:milestone complete` to archive the milestone and tag it
+- Or: `/pbr:milestone new` to start the next set of features
+
+### ROADMAP.md has phases but no phase directories
+- This is normal for future phases
+- Show them as "Not started" with no plan counts
+
+### Multiple milestones
+- If PROJECT.md shows multiple milestones, display the current one
+- Show completed milestones as collapsed summary
+
+### Large project (many phases)
+- If more than 8 phases, consider grouping:
+  - Completed phases: collapsed summary
+  - Current phase: full detail
+  - Upcoming phases: brief list
+
+---
+
+## Performance
+
+This skill should be fast. It's a status check, not an analysis.
+
+**DO:**
+- Read files quickly (frontmatter only where possible)
+- Use Glob to find files efficiently
+- Cache nothing (always read fresh state)
+
+**DO NOT:**
+- Read full SUMMARY.md contents (frontmatter is enough)
+- Read plan file contents (just check existence)
+- Run any Bash commands
+- Modify any files
+- Spawn any Task agents
+
+---
+
+## Anti-Patterns
+
+1. **DO NOT** modify any files — this is read-only
+2. **DO NOT** run Bash commands — use Read and Glob only
+3. **DO NOT** show overwhelming detail — keep it scannable
+4. **DO NOT** hide problems — surface blockers, gaps, and warnings prominently
+5. **DO NOT** suggest multiple actions without prioritizing — the primary suggestion should be clear
+6. **DO NOT** re-read full file contents when frontmatter is sufficient
+7. **DO NOT** show completed phases in full detail unless specifically relevant
+8. **DO NOT** execute the suggested action — present it for the user to run manually. Use /pbr:continue for auto-execution.