@sienklogic/plan-build-run 2.0.0

package/plugins/pbr/skills/milestone/templates/audit-report.md.tmpl

@@ -0,0 +1,48 @@
+# Template: Milestone Audit Report
+# Used by: milestone/SKILL.md (audit subcommand, Step 5)
+# Variables: {version}, {status}, {date}, {phase entries}, {integration results}, {requirements}, {tech debt}
+
+---
+milestone: "{version}"
+status: "{passed | gaps_found | tech_debt}"
+date: "{ISO date}"
+---
+
+# Milestone Audit: {version}
+
+## Overall Status: {PASSED / GAPS FOUND / TECH DEBT}
+
+## Phase Verification Summary
+
+| Phase | Verified | Gaps | Integration |
+|-------|----------|------|-------------|
+| {N}. {name} | {yes/no} | {count} | {ok/issues} |
+
+## Integration Check Results
+
+### Dependency Graph
+{Mermaid or ASCII representation of phase dependencies}
+
+### Integration Issues
+{List of integration problems found, or "None"}
+
+- **{Issue}**: {description}
+  - Affected phases: {list}
+  - Severity: {critical/high/medium/low}
+  - Suggested fix: {brief suggestion}
+
+## Requirements Coverage
+
+| Requirement | Status | Verified By |
+|-------------|--------|-------------|
+| {req} | {covered/uncovered} | {phase/plan or "N/A"} |
+
+## Tech Debt Identified
+
+{Issues that don't block the milestone but should be addressed}
+
+- {debt item}: {description}
+
+## Recommendations
+
+{Summary of what needs to be done, if anything}

package/plugins/pbr/skills/milestone/templates/stats-file.md.tmpl

@@ -0,0 +1,30 @@
+# Template: Milestone Stats File
+# Used by: milestone/SKILL.md (complete subcommand, Step 5)
+# Variables: {version}, {name}, {date}, {days}, {counts}, {accomplishments}, {decisions}, {tech stack}, {patterns}
+
+# Milestone {version} Stats
+
+**Name:** {milestone name}
+**Completed:** {ISO date}
+**Duration:** {days}
+
+## Metrics
+- Phases: {count}
+- Plans executed: {count}
+- Quick tasks: {count}
+- Total commits: {count}
+- Files changed: {count}
+- Lines added: {count}
+- Lines removed: {count}
+
+## Accomplishments
+{bulleted list of key features/capabilities built}
+
+## Key Decisions
+{bulleted list of important decisions made}
+
+## Technology Stack
+{list of technologies used}
+
+## Patterns Established
+{list of patterns applied}

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

@@ -0,0 +1,212 @@
+---
+name: note
+description: "Zero-friction idea capture. Append, list, or promote notes to todos."
+allowed-tools: Read, Write, Glob, Grep
+argument-hint: "<text> | list | promote <index> [--global]"
+---
+
+# /pbr:note — Quick Note Capture
+
+You are running the **note** skill. Your job is zero-friction idea capture. One Write call, one confirmation line. No questions, no prompts.
+
+This skill runs **inline** — no Task, no AskUserQuestion, no Bash.
+
+---
+
+## Scope Detection
+
+Two scopes exist. Auto-detect which to use:
+
+1. **Project scope**: `.planning/NOTES.md` — used when `.planning/` directory exists in cwd
+2. **Global scope**: `~/.claude/notes.md` — used as fallback when no `.planning/`, or when `--global` flag is present
+
+**`--global` flag**: Strip `--global` from anywhere in `$ARGUMENTS` before parsing. When present, force global scope regardless of whether `.planning/` exists.
+
+**Important**: Do NOT create `.planning/` if it doesn't exist. If there's no `.planning/` directory, fall back to global scope silently.
+
+---
+
+## Subcommand Parsing
+
+Parse `$ARGUMENTS` after stripping `--global`:
+
+| Condition | Subcommand |
+|-----------|------------|
+| Arguments are exactly `list` (case-insensitive) | **list** |
+| Arguments are exactly `promote <N>` where N is a number | **promote** |
+| Arguments are empty (no text at all) | **list** |
+| Anything else | **append** (the text IS the note) |
+
+**Critical**: `list` is only a subcommand when it's the ENTIRE argument. `/pbr:note list of groceries` saves a note with text "list of groceries". Same for `promote` — only a subcommand when followed by exactly one number.
+
+---
+
+## Subcommand: append
+
+Append a timestamped note to the target file.
+
+### Steps
+
+1. Determine scope (project or global) per Scope Detection above
+2. Read the target file if it exists
+3. If the file doesn't exist, create it with this header:
+
+```markdown
+# Notes
+
+Quick captures from `/pbr:note`. Ideas worth remembering.
+
+---
+
+```
+
+4. Ensure the file content ends with a newline before appending
+5. Append: `- [YYYY-MM-DD HH:mm] {note text verbatim}`
+6. Write the file
+7. Confirm with exactly one line: `Noted ({scope}): {note text}`
+   - Where `{scope}` is "project" or "global"
+
+### Constraints
+
+- **Never modify the note text** — capture verbatim, including typos
+- **Never ask questions** — just write and confirm
+- **Timestamp format**: Use local time, `YYYY-MM-DD HH:mm` (24-hour, no seconds)
+
+---
+
+## Subcommand: list
+
+Show notes from both project and global scopes.
+
+### Steps
+
+1. Read `.planning/NOTES.md` (if exists) — these are "project" notes
+2. Read `~/.claude/notes.md` (if exists) — these are "global" notes
+3. Parse entries: lines matching `^- \[` are notes
+4. Exclude lines containing `[promoted]` from active counts (but still show them, dimmed)
+5. Number all active entries sequentially starting at 1 (across both scopes)
+6. If total active entries > 20, show only the last 10 with a note about how many were omitted
+
+### Display Format
+
+```
+Notes:
+
+Project (.planning/NOTES.md):
+  1. [2026-02-08 14:32] refactor the hook system to support async validators
+  2. [promoted] [2026-02-08 14:40] add rate limiting to the API endpoints
+  3. [2026-02-08 15:10] consider adding a --dry-run flag to build
+
+Global (~/.claude/notes.md):
+  4. [2026-02-08 10:00] cross-project idea about shared config
+
+{count} active note(s). Use `/pbr:note promote <N>` to convert to a todo.
+```
+
+If a scope has no file or no entries, show: `(no notes)`
+
+---
+
+## Subcommand: promote
+
+Convert a note into a todo file.
+
+### Steps
+
+1. Run the **list** logic to build the numbered index (both scopes)
+2. Find entry N from the numbered list
+3. If N is invalid or refers to an already-promoted note, tell the user and stop
+4. **Requires `.planning/` directory** — if it doesn't exist, warn: "Todos require a Plan-Build-Run project. Run `/pbr:begin` to initialize one, or use `/pbr:todo add` in an existing project."
+5. Ensure `.planning/todos/pending/` directory exists
+6. Generate todo ID: `{YYYYMMDD}-{NNN}` where NNN is sequential within the day (check existing files)
+7. Extract the note text (everything after the timestamp)
+8. Create `.planning/todos/pending/{id}.md`:
+
+```yaml
+---
+id: {id}
+area: general
+priority: normal
+created: {ISO-timestamp}
+source: "promoted from /pbr:note"
+---
+
+# {note text}
+
+## Context
+Promoted from quick note captured on {original date}.
+
+## Notes
+(empty)
+```
+
+9. Mark the original note as promoted: replace `- [` with `- [promoted] [` on that line
+10. Confirm: `Promoted note {N} to todo {id}: {note text}`
+
+---
+
+## NOTES.md Format Reference
+
+```markdown
+# Notes
+
+Quick captures from `/pbr:note`. Ideas worth remembering.
+
+---
+
+- [2026-02-08 14:32] refactor the hook system to support async validators
+- [promoted] [2026-02-08 14:40] add rate limiting to the API endpoints
+- [2026-02-08 15:10] consider adding a --dry-run flag to build
+```
+
+---
+
+## Edge Cases
+
+1. **"list" as note text**: `/pbr:note list of things` → saves note "list of things" (subcommand only when `list` is the entire arg)
+2. **No `.planning/`**: Falls back to global `~/.claude/notes.md` — works in any directory
+3. **Promote without project**: Warns that todos require `.planning/`, suggests `/pbr:begin`
+4. **Large files**: `list` shows last 10 when >20 active entries
+5. **Missing newline**: Always ensure trailing newline before appending
+6. **`--global` position**: Stripped from anywhere — `--global my idea` and `my idea --global` both save "my idea" globally
+7. **Promote already-promoted**: Tell user "Note {N} is already promoted" and stop
+8. **Empty note text after stripping flags**: Treat as `list` subcommand
+
+---
+
+## Error Handling
+
+### Write failure
+If the Write tool fails (permissions, disk full, etc.), display:
+```
+╔══════════════════════════════════════════════════════════════╗
+║  ERROR                                                       ║
+╚══════════════════════════════════════════════════════════════╝
+
+Failed to write note to {target_file}.
+
+**To fix:** Check file permissions or disk space.
+```
+
+### Promote target not found
+If the specified note index is invalid, display:
+```
+╔══════════════════════════════════════════════════════════════╗
+║  ERROR                                                       ║
+╚══════════════════════════════════════════════════════════════╝
+
+Note {N} not found. Valid range: 1-{max}.
+
+**To fix:** Run `/pbr:note list` to see available notes.
+```
+
+---
+
+## Anti-Patterns
+
+1. **DO NOT** ask questions on append — just write and confirm
+2. **DO NOT** modify note text — capture verbatim
+3. **DO NOT** use Task, AskUserQuestion, or Bash
+4. **DO NOT** create `.planning/` if it doesn't exist — fall back to global
+5. **DO NOT** number promoted notes in the active count (but still display them)
+6. **DO NOT** over-format the confirmation — one line is enough

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

@@ -0,0 +1,235 @@
+---
+name: pause
+description: "Save your current session state for later resumption."
+allowed-tools: Read, Write, Bash, Glob
+---
+
+# /pbr:pause — Save Session State
+
+You are running the **pause** skill. Your job is to capture the current session state so the user can resume exactly where they left off in a future conversation. This creates a `.continue-here.md` handoff file with everything the next session needs.
+
+This skill runs **inline** (no Task delegation).
+
+---
+
+## Core Principle
+
+**Capture everything the next session needs to hit the ground running.** The resume skill will read this file cold, with zero prior context. Write it as if you're handing off to a colleague who has never seen this project.
+
+---
+
+## Flow
+
+### Step 1: Read Current State
+
+**Flag: `--checkpoint`**
+
+If `$ARGUMENTS` contains `--checkpoint`:
+- Perform a lightweight state dump without full session analysis
+- Write a minimal .continue-here.md with just: Position, git status, and suggested next action
+- Skip the detailed "Completed This Session" analysis (saves time)
+- Useful for quick manual checkpoints at any point
+
+Read the following files to understand where things stand:
+
+1. **`.planning/STATE.md`** — Current position
+   - Extract: current phase, current plan, progress, blockers
+   - If STATE.md doesn't exist, display:
+     ```
+     ╔══════════════════════════════════════════════════════════════╗
+     ║  ERROR                                                       ║
+     ╚══════════════════════════════════════════════════════════════╝
+
+     No Plan-Build-Run project state found. Nothing to pause.
+
+     **To fix:** Run `/pbr:begin` to initialize a project first.
+     ```
+
+2. **`.planning/config.json`** — Project settings
+   - Extract: project name, feature toggles
+
+3. **`.planning/ROADMAP.md`** — Phase overview
+   - Extract: current phase name, total phases
+
+### Step 2: Determine Current Phase Directory
+
+From STATE.md, get the current phase number and find its directory:
+1. List directories in `.planning/phases/`
+2. Match the current phase number to a directory
+3. If no match: use the most recently modified phase directory
+
+### Step 3: Gather Session State
+
+Collect the following information:
+
+#### Current Position
+- Phase number and name
+- Plan number (if mid-phase) or "between plans"
+- Status: in-progress, between-plans, between-phases, planning, reviewing
+
+#### Work Completed This Session
+Scan the current phase directory for SUMMARY.md files:
+- Read each SUMMARY.md frontmatter
+- Note which ones were created/modified recently (check timestamps or git log)
+- For recently completed plans: extract the plan name and brief status
+
+Also check git log for recent commits:
+```bash
+git log --oneline -20 --since="8 hours ago"
+```
+This gives a reasonable window for "this session's work."
+
+#### Remaining Work
+Scan for plan files without corresponding SUMMARY.md files:
+- These are plans that haven't been executed yet
+- List them with brief descriptions from their frontmatter
+
+#### Key Decisions Made
+Check for:
+- Recent CONTEXT.md files (from `/pbr:discuss`)
+- Key decisions in recent SUMMARY.md files
+- Any deviations noted in summaries
+
+#### Blockers or Concerns
+From STATE.md blockers section and any:
+- Failed verifications
+- Checkpoint stops
+- Active debug sessions
+- Unresolved issues noted in summaries
+
+#### What to Do Next
+Determine the logical next action (same routing logic as `/pbr:status`):
+- If mid-plan execution: "Continue building phase N"
+- If between plans in a phase: "Execute next plan (plan M)"
+- If phase complete, not reviewed: "Review phase N"
+- If phase reviewed, has gaps: "Fix gaps in phase N"
+- If phase complete: "Plan phase N+1"
+
+### Step 4: Write .continue-here.md
+
+Write the handoff file to the current phase directory:
+
+**Path:** `.planning/phases/{NN}-{phase-name}/.continue-here.md`
+
+**Content:**
+
+Read `skills/pause/templates/continue-here.md.tmpl` for the handoff file format. Fill in all `{variable}` placeholders with actual session data gathered in Steps 1-3.
+
+### Step 5: Update STATE.md
+
+Update the Session Continuity section of STATE.md:
+
+```markdown
+### Session Continuity
+
+**Last paused:** {ISO datetime}
+**Position:** Phase {N}, Plan {M}
+**Continue file:** .planning/phases/{NN}-{phase-name}/.continue-here.md
+**Next action:** {suggested command}
+```
+
+If the Session Continuity section doesn't exist, create it at the end of STATE.md.
+
+### Step 6: Commit as WIP
+
+Reference: `skills/shared/commit-planning-docs.md` for the standard commit pattern.
+
+If `planning.commit_docs: true` in config.json:
+
+```bash
+git add .planning/phases/{NN}-{phase-name}/.continue-here.md
+git add .planning/STATE.md
+git commit -m "wip: pause at phase {N} plan {M}"
+```
+
+**Commit rules:**
+- Always use `wip:` prefix for pause commits
+- Include phase and plan numbers
+- Stage only the continue-here and STATE.md files
+- Do NOT stage any code changes (those should already be committed by the executor)
+
+### Step 7: Confirm to User
+
+Display branded confirmation:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ PLAN-BUILD-RUN ► SESSION SAVED ✓
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Position: Phase {N} — {phase name}, Plan {M}
+Completed: {count} plans this session
+Remaining: {count} plans in this phase
+
+───────────────────────────────────────────────────────────────
+
+## ▶ Next Up
+
+**Resume in your next session**
+
+`/pbr:resume`
+
+<sub>`/clear` first → fresh context window</sub>
+
+───────────────────────────────────────────────────────────────
+```
+
+---
+
+## What Gets Captured
+
+| Information | Source | Why It Matters |
+|-------------|--------|---------------|
+| Phase + plan position | STATE.md | Know where to start |
+| Completed work | SUMMARY.md files, git log | Know what's already done |
+| Remaining work | Plan files without summaries | Know what's left |
+| Decisions | CONTEXT.md, SUMMARY.md | Preserve user preferences |
+| Blockers | STATE.md, verification files | Don't repeat failed approaches |
+| Next steps | Routing logic | Immediate action on resume |
+
+---
+
+## Edge Cases
+
+### No work was done this session
+- Still write the continue-here file
+- "Completed This Session" section says: "No plans completed (discussion/planning only)"
+- Capture any decisions or context from the conversation
+
+### Multiple phases were worked on
+- Write .continue-here.md in the MOST RECENT phase directory
+- Reference the other phases in the "Completed This Session" section
+- Next steps should focus on the current position
+
+### Mid-task pause (executor was interrupted)
+- Note which task was in progress
+- Warn: "Task {name} was in progress when paused. It may need to be re-executed."
+- Check git log to see if any partial commits exist
+
+### .continue-here.md already exists
+- **Always REPLACE** the existing file entirely — never append
+- Appending causes stale data from previous sessions to persist, which confuses resume
+- The old .continue-here.md content is superseded by the current state
+- No need to ask the user — the current session state is always more accurate
+
+### STATE.md doesn't exist
+- Warn: "No STATE.md found. Creating a minimal pause file."
+- Write .continue-here.md based on git log and file system scan only
+- Don't try to update STATE.md
+
+### No git history (fresh project)
+- Skip the git log step
+- Estimate session work from file modification times
+- Still write the continue-here file
+
+---
+
+## Anti-Patterns
+
+1. **DO NOT** include full file contents in .continue-here.md — keep it concise
+2. **DO NOT** stage code files in the WIP commit — only planning docs
+3. **DO NOT** skip the commit — the WIP commit is how `/pbr:resume` finds the pause point
+4. **DO NOT** write multiple .continue-here.md files — one per pause
+5. **DO NOT** include sensitive information (API keys, passwords) in the handoff
+6. **DO NOT** modify any code files — this skill only writes planning docs
+7. **DO NOT** skip the "Next Steps" section — it's the most important part for resumption

package/plugins/pbr/skills/pause/templates/continue-here.md.tmpl

@@ -0,0 +1,71 @@
+# Template: Continue Here Handoff File
+# Used by: pause/SKILL.md (Step 4)
+# Output path: .planning/phases/{NN}-{phase-name}/.continue-here.md
+# Variables: {datetime}, {hours}, {phase}, {plan}, {status}, {session work}, {remaining}, {decisions}, {blockers}, {context}, {next steps}
+
+# Continue Here
+
+**Paused:** {ISO datetime}
+**Session duration:** ~{estimated hours} (based on git log timestamps)
+
+## Position
+
+Phase: {N} -- {name}
+Plan: {M} of {total} (or "between plans" / "phase complete")
+Status: {in-progress / between-plans / reviewing / planning}
+
+## Completed This Session
+
+{List of work done, with commit references where available}
+
+- Plan {A}: {summary} (commit: {short hash})
+- Plan {B}: {summary} (commit: {short hash})
+- Quick task: {description} (commit: {short hash})
+
+{If nothing was completed:}
+- No plans completed this session (discussion/planning only)
+
+## Remaining
+
+{What still needs to be done in this phase}
+
+- Plan {C}: {brief description from plan frontmatter}
+- Plan {D}: {brief description from plan frontmatter}
+
+{If phase is complete:}
+- Phase {N} is complete. Next: {review or next phase}
+
+## Decisions Made
+
+{Key decisions from this session that affect future work}
+
+- {decision 1}: {brief description}
+- {decision 2}: {brief description}
+
+{If no notable decisions:}
+- No major decisions this session
+
+## Blockers
+
+{Any issues preventing progress}
+
+- {blocker description}
+
+{If no blockers:}
+- None
+
+## Context Notes
+
+{Any additional context that would help the next session}
+
+- {note about something tricky}
+- {note about something to watch out for}
+- {note about user preferences expressed during this session}
+
+## Next Steps
+
+{Ordered list of what to do when resuming}
+
+1. {Specific first action with command}
+2. {Following action}
+3. {And so on}