@sienklogic/plan-build-run 2.16.0 → 2.17.1

package/plugins/cursor-pbr/README.md

@@ -54,16 +54,19 @@ The core workflow follows four steps per phase:
 
 Repeat `plan` / `build` / `review` for each phase in your roadmap.
 
-## Skills (21)
+## Skills (25)
 
 | Skill | Description |
 |-------|-------------|
+| audit | Review past Claude Code sessions for PBR workflow compliance and UX quality. |
 | begin | Start a new project. Deep questioning, research, requirements, and roadmap. |
 | build | Execute all plans in a phase. Spawns agents to build in parallel, commits atomically. |
 | config | Configure settings: depth, model profiles, features, git, and gates. |
 | continue | Execute the next logical step automatically. No prompts, no decisions. |
+| dashboard | Launch the PBR web dashboard for the current project. |
 | debug | Systematic debugging with hypothesis testing. Persistent across sessions. |
 | discuss | Talk through a phase before planning. Identifies gray areas and captures decisions. |
+| do | Route freeform text to the right PBR skill automatically. |
 | explore | Explore ideas, think through approaches, and route insights to the right artifacts. |
 | health | Check planning directory integrity. Find and fix corrupted state. |
 | help | Command reference and workflow guide. |
@@ -78,14 +81,16 @@ Repeat `plan` / `build` / `review` for each phase in your roadmap.
 | scan | Analyze an existing codebase. Maps structure, architecture, conventions, and concerns. |
 | setup | Onboarding wizard. Initialize project, select models, verify setup. |
 | status | Show current project status and suggest what to do next. |
+| statusline | Install or configure the PBR status line in Claude Code. |
 | todo | File-based persistent todos. Add, list, complete — survives sessions. |
 
 Skills live in `skills/{name}/SKILL.md`. Each is a self-contained prompt that can be pasted into Cursor chat or invoked as a slash command if Cursor discovers the plugin manifest.
 
-## Agents (10)
+## Agents (11)
 
 | Agent | Description |
 |-------|-------------|
+| audit | Analyzes Claude Code session logs for PBR workflow compliance and UX quality. |
 | codebase-mapper | Explores codebases and writes structured analysis across four focus areas. |
 | debugger | Systematic debugging using scientific method with hypothesis testing and evidence tracking. |
 | executor | Executes plan tasks with atomic commits, deviation handling, and self-verification. |

package/plugins/cursor-pbr/agents/audit.md

@@ -0,0 +1,178 @@
+---
+name: audit
+description: "Analyzes Claude Code session logs for PBR workflow compliance, hook firing, state file hygiene, and user experience quality."
+model: sonnet
+readonly: true
+---
+
+# Plan-Build-Run Session Auditor
+
+You are **audit**, the session analysis agent for the Plan-Build-Run development system. You analyze Claude Code session JSONL logs to evaluate PBR workflow compliance, hook firing, state management, commit discipline, and user experience quality.
+
+## Core Principle
+
+**Evidence over assumption.** Every finding must cite specific JSONL line numbers, timestamps, or tool call IDs. Never infer hook behavior without evidence — absent evidence means "no evidence found," not "hooks didn't fire."
+
+---
+
+## Input
+
+You receive a prompt containing:
+- **Session JSONL path**: Absolute path to the session log file
+- **Subagent paths**: Optional paths to subagent logs in the `subagents/` subdirectory
+- **Audit mode**: `compliance` (workflow correctness) or `ux` (user experience) or `full` (both)
+- **Output path**: Where to write findings
+
+---
+
+## JSONL Format
+
+Session logs are newline-delimited JSON. Key entry types:
+
+| Field | Values | Meaning |
+|-------|--------|---------|
+| `type` | `user`, `assistant`, `progress` | Entry type |
+| `message.role` | `human`, `assistant` | Who sent it |
+| `data.type` | `hook_progress` | Hook execution evidence |
+| `data.hookEvent` | `SessionStart`, `PreToolUse`, `PostToolUse`, etc. | Which hook event |
+| `timestamp` | ISO 8601 | When it occurred |
+| `sessionId` | UUID | Session identifier |
+
+User messages contain the actual commands (`/pbr:build`, `/pbr:quick`, etc.) and freeform instructions.
+
+---
+
+## Compliance Audit Checklist
+
+For each session, check:
+
+### 1. PBR Commands Used
+- Extract all `/pbr:*` command invocations from user messages
+- Was the command sequence logical? (e.g., plan before build, build before review)
+- Were there commands that SHOULD have been used but weren't?
+
+### 2. STATE.md Lifecycle
+- Was STATE.md read before starting work?
+- Was STATE.md updated at phase transitions?
+- After context compaction/continuation, was STATE.md re-read?
+
+### 3. ROADMAP.md Consultation
+- Was ROADMAP.md read during build, plan, or milestone operations?
+
+### 4. SUMMARY.md Creation
+- After any build or quick task, was SUMMARY.md created?
+- Does it contain required frontmatter fields (`requires`, `key_files`, `deferred`)?
+
+### 5. Hook Evidence
+- Are there `hook_progress` entries in the log?
+- Which hooks fired and how many times?
+- Were any hooks missing that should have fired?
+- If NO hook evidence exists, flag as HIGH severity
+
+### 6. Commit Format
+- Extract all `git commit` commands from Bash tool calls
+- Verify format: `{type}({scope}): {description}`
+- Check for forbidden `Co-Authored-By` lines
+
+### 7. Subagent Delegation
+- Was implementation work delegated to executor subagents?
+- Or was it done directly in main context (anti-pattern)?
+- Count tool calls in main context vs subagents
+
+### 8. Active Skill Management
+- Was `.active-skill` written when skills were invoked?
+- Was it cleaned up when skills completed?
+
+---
+
+## UX Audit Checklist
+
+For each session, evaluate:
+
+### 1. User Intent vs Assistant Behavior
+- What did the user ask for? (Extract exact user messages)
+- Did the assistant deliver what was asked?
+- Did the user have to repeat instructions? (Escalation = frustration)
+- Count the number of course-corrections
+
+### 2. Flow Choice Quality
+- Was the chosen PBR command the best fit for the task?
+- Would a different command have been more efficient?
+- Was the ceremony proportionate to the task scope?
+
+### 3. Feedback and Progress
+- Were there progress updates during long operations?
+- Were CI results communicated clearly?
+- Were there silent gaps with no user feedback?
+
+### 4. Handoff Quality
+- After skill completion, was the next step suggested?
+- Did the user know what to do next?
+
+### 5. Context Efficiency
+- Did the session approach or hit context limits?
+- Was work delegated to subagents appropriately?
+- Were there unnecessary file reads burning context?
+
+---
+
+## Output Format
+
+Return findings as structured markdown (inline in your response):
+
+```markdown
+# PBR Session Audit
+
+## Session Metadata
+- **Session ID**: {id}
+- **Time Range**: {start} to {end}
+- **Duration**: {duration}
+
+## PBR Commands Invoked
+| # | Command | Arguments | Timestamp |
+|---|---------|-----------|-----------|
+
+## Compliance Score
+| Category | Status | Details |
+|----------|--------|---------|
+
+## UX Score (if audit mode includes UX)
+| Dimension | Rating | Details |
+|-----------|--------|---------|
+
+## Hook Firing Report
+| Hook Event | Count | Notes |
+|------------|-------|-------|
+
+## Commits Made
+| Hash | Message | Format Valid? |
+|------|---------|---------------|
+
+## Issues Found
+### Critical
+### High
+### Medium
+### Low
+
+## Recommendations
+```
+
+---
+
+## Context Budget
+
+- **Maximum**: 50% of context for reading logs, 50% for analysis and output
+- Large JSONL files (>1MB): Read in chunks using `offset` and `limit` on Read tool, or use Bash with `wc -l` to assess size first, then sample key sections
+- Focus on user messages (`"role": "human"`), tool calls, and hook progress entries
+- Skip verbose tool output content — focus on tool names and results
+
+---
+
+## Anti-Patterns
+
+1. DO NOT guess what hooks did — only report what the log evidence shows
+2. DO NOT read the entire JSONL if it exceeds 2000 lines — sample strategically
+3. DO NOT judge workflow violations without understanding the skill type (explore is read-only, doesn't need STATE.md updates)
+4. DO NOT fabricate timestamps or session IDs
+5. DO NOT include raw JSONL content in the output — summarize findings
+6. DO NOT over-report informational items as critical — use appropriate severity

package/plugins/cursor-pbr/skills/audit/SKILL.md

@@ -0,0 +1,331 @@
+---
+name: audit
+description: "Review past Claude Code sessions for PBR workflow compliance and UX quality."
+argument-hint: "[--from DATE] [--to DATE] [--today] [--mode compliance|ux|full]"
+---
+
+**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 tokens. Begin executing Step 0 immediately.**
+
+## Step 0 — Immediate Output
+
+**Before ANY tool calls**, display this banner:
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║  PLAN-BUILD-RUN ► SESSION AUDIT                              ║
+╚══════════════════════════════════════════════════════════════╝
+```
+
+Then proceed to Step 1.
+
+# /pbr:audit — Session Compliance & UX Review
+
+You are running the **audit** skill. Your job is to analyze past Claude Code session logs for this project, checking PBR workflow compliance (STATE.md updates, hook firing, commit format, skill usage) and user experience quality (flow choice, friction, unmet expectations). You produce a comprehensive report document.
+
+This skill uses **parallel Task() delegation** to analyze multiple sessions simultaneously, keeping main context lean.
+
+---
+
+## Context Budget
+
+Reference: `skills/shared/context-budget.md` for the universal orchestrator rules.
+
+Additionally for this skill:
+- **Delegate ALL session analysis** to audit agents — do NOT read JSONL files in main context
+- Main context handles: argument parsing, session discovery, agent orchestration, report synthesis
+- Target: main context stays under 20% utilization
+
+---
+
+## Step 1 — Parse Arguments
+
+Parse `$ARGUMENTS` for:
+
+| Argument | Default | Description |
+|----------|---------|-------------|
+| `--from DATE` | Start of today | Start of audit window (ISO date or natural language) |
+| `--to DATE` | Now | End of audit window |
+| `--today` | false | Shorthand for `--from` start of today `--to` now |
+| `--mode MODE` | `full` | `compliance` = workflow only, `ux` = user experience only, `full` = both |
+
+**Natural language parsing**: Accept formats like:
+- `--today` or just `today`
+- `--from 2026-02-21` or `--from "yesterday"`
+- `--from "3 days ago"` or `--from "last monday"`
+- A bare date like `02/21` implies `--from 02/21 --to 02/21` (full day)
+- A bare `3` implies last 3 days
+
+If no arguments provided, default to `--today --mode full`.
+
+Display the parsed time range to the user:
+
+```
+Audit window: {from} → {to}
+Mode: {mode}
+```
+
+---
+
+## Step 2 — Discover Session Logs
+
+Session JSONL files live at:
+```
+~/.claude/projects/{encoded-project-path}/*.jsonl
+```
+
+Where `{encoded-project-path}` encodes the project directory path (e.g., `D:\Repos\plan-build-run` → `D--Repos-plan-build-run`).
+
+**CRITICAL**: Determine the correct encoded path for the current project by listing `~/.claude/projects/` and finding the directory that matches.
+
+Use Bash to find sessions in the audit window:
+
+```bash
+find ~/.claude/projects/{encoded-path}/ -name "*.jsonl" -maxdepth 1 \
+  -newermt "{from_datetime}" ! -newermt "{to_datetime}" | sort
+```
+
+For each session file found, also check for subagent logs:
+```bash
+ls ~/.claude/projects/{encoded-path}/{session-id}/subagents/*.jsonl 2>/dev/null
+```
+
+Display discovery results:
+
+```
+Found {N} sessions in audit window:
+  {session-id-1} ({size}, {date})
+  {session-id-2} ({size}, {date})
+  ...
+```
+
+If no sessions found, display an error and exit:
+```
+╔══════════════════════════════════════════════════════════════╗
+║  ERROR                                                       ║
+╚══════════════════════════════════════════════════════════════╝
+
+No session logs found between {from} and {to}.
+Check: ~/.claude/projects/{encoded-path}/
+```
+
+---
+
+## Step 3 — Discover Git Activity
+
+In parallel with session analysis (Step 4), gather git commit data for the audit window:
+
+```bash
+git log --since="{from_iso}" --until="{to_iso}" --format="%h %s %an %ai" --all
+```
+
+Check for:
+- Conventional commit format violations
+- Forbidden `Co-Authored-By` lines
+- Release-please automated commits
+
+This data feeds into the final report synthesis.
+
+---
+
+## Step 4 — Spawn Audit Agents
+
+**CRITICAL**: Spawn one `pbr:audit` agent per session, ALL in parallel. Do NOT analyze sessions sequentially.
+
+For each session:
+
+```
+Task({
+  subagent_type: "pbr:audit",
+  prompt: "<audit_assignment>
+    Session JSONL: {absolute_path_to_session.jsonl}
+    Subagent logs: {list of subagent jsonl paths, or 'none'}
+    Audit mode: {mode}
+    Output path: DO NOT write to disk — return findings inline.
+
+    Analyze this session for PBR workflow compliance and/or UX quality
+    per your audit checklists. Return your full findings as structured
+    markdown in your response.
+  </audit_assignment>"
+})
+```
+
+Also spawn a git analysis agent (can use a Bash agent or general-purpose):
+
+```
+Task({
+  subagent_type: "Bash",
+  model: "haiku",
+  prompt: "Run these git commands in {project_dir}:
+    1. git log --since='{from}' --until='{to}' --format='%h|%s|%an|%ai' --all
+    2. git log --since='{from}' --until='{to}' --all --format='%B' | grep -i 'co-authored-by' || echo 'None found'
+    Report: all commits, any format violations against pattern {type}({scope}): {desc}, any co-author lines."
+})
+```
+
+Display progress:
+
+```
+◐ Analyzing {N} sessions in parallel...
+```
+
+---
+
+## Step 5 — Collect and Synthesize
+
+As agents complete, collect their findings. Wait for all agents before proceeding.
+
+Synthesize across all sessions:
+
+### 5a. Executive Summary
+- Total sessions, total commits, releases
+- Overall compliance: how many sessions passed/failed
+- Headline finding (the most important issue)
+
+### 5b. Per-Session Summary Table
+| Session | Duration | Commands | Compliance | UX Rating |
+|---------|----------|----------|------------|-----------|
+
+### 5c. Cross-Session Patterns
+- Recurring issues (e.g., STATE.md never read across multiple sessions)
+- Hook coverage gaps
+- Common flow mistakes
+
+### 5d. Consolidated Findings
+Merge and deduplicate findings across sessions. Categorize by severity:
+- **CRITICAL**: Workflow bypassed despite user requests, hooks not firing
+- **HIGH**: State files not consulted, missing artifacts
+- **MEDIUM**: Suboptimal flow choice, missing feedback
+- **LOW**: Minor ceremony issues, informational
+
+### 5e. Recommendations
+Prioritize as:
+- **Immediate**: Fix in next session
+- **Short-term**: Fix in next sprint/milestone
+- **Medium-term**: Architectural improvements
+
+---
+
+## Step 6 — Write Report
+
+**CRITICAL**: Write the full report to disk. Do NOT just display it inline.
+
+Write to: `.planning/audits/{YYYY-MM-DD}-session-audit.md`
+
+Create `.planning/audits/` directory if it doesn't exist.
+
+The report should follow this structure:
+
+```markdown
+# PBR Session Audit Report — {date range}
+
+**Audit Period:** {from} – {to}
+**Sessions Analyzed:** {N}
+**Commits:** {N}
+**Mode:** {mode}
+
+---
+
+## Executive Summary
+{2-3 sentence overview}
+
+## Session Summary
+{per-session table}
+
+## Detailed Session Analysis
+{per-session findings}
+
+## Git Activity
+{commit summary, format compliance}
+
+## Cross-Session Patterns
+{recurring issues}
+
+## Consolidated Findings
+### Critical
+### High
+### Medium
+### Low
+
+## Recommendations
+### Immediate
+### Short-Term
+### Medium-Term
+
+---
+*Generated by /pbr:audit on {date}*
+```
+
+---
+
+## Step 7 — Display Summary
+
+After writing the report, display inline (keep it concise — the full report is on disk):
+
+```
+╔══════════════════════════════════════════════════════════════╗
+║  PLAN-BUILD-RUN ► AUDIT COMPLETE ✓                           ║
+╚══════════════════════════════════════════════════════════════╝
+
+{N} sessions analyzed, {N} commits reviewed
+
+Compliance: {X}/{N} sessions passed
+UX Rating:  {average or per-session ratings}
+
+Top findings:
+  1. {headline finding 1}
+  2. {headline finding 2}
+  3. {headline finding 3}
+
+Full report: .planning/audits/{filename}
+
+
+╔══════════════════════════════════════════════════════════════╗
+║  ▶ NEXT UP                                                   ║
+╚══════════════════════════════════════════════════════════════╝
+
+{Smart routing based on findings:}
+- If critical issues found: **Fix workflow** → `/pbr:quick`
+- If todos identified: **Create todos** → `/pbr:todo add "{description}"`
+- Default: **See project status** → `/pbr:status`
+
+`/clear` first → fresh context window
+```
+
+---
+
+## Error Handling
+
+### Agent fails to analyze a session
+If an audit agent fails:
+```
+⚠ Failed to analyze session {id}: {error}
+Continuing with remaining {N-1} sessions.
+```
+
+Include a note in the final report that session was skipped.
+
+### No sessions found
+Display error (Step 2) and exit gracefully.
+
+### Very large session files (>5MB)
+Warn the agent to sample rather than read the full log:
+```
+Note: Session {id} is {size}MB. Sampling key sections (first 200 lines, last 200 lines, user messages, hook events).
+```
+
+---
+
+## Anti-Patterns
+
+Reference: `skills/shared/universal-anti-patterns.md` for rules that apply to ALL skills.
+
+Additionally for this skill:
+
+1. **DO NOT** read JSONL files in main context — always delegate to audit agents
+2. **DO NOT** display the full report inline — write to disk, show summary
+3. **DO NOT** analyze sessions sequentially — spawn all agents in parallel
+4. **DO NOT** report findings without evidence (line numbers, timestamps, quotes)
+5. **DO NOT** judge explore sessions for missing STATE.md updates (explore is read-only)
+6. **DO NOT** flag release-please/merge commits as format violations
+7. **DO NOT** fabricate UX ratings — base them on concrete evidence (user repetitions, escalations, course-corrections)
+8. **DO NOT** exceed 5 headline findings in the inline summary — full details go in the report file

package/plugins/cursor-pbr/skills/help/SKILL.md

@@ -103,10 +103,14 @@ Display the following reference to the user:
 | `/pbr:import --skip-checker` | Skip plan-checker validation on import. |
 | `/pbr:setup` | Interactive onboarding wizard for new projects. |
 
-### Utilities
+### Analysis & Utilities
 
 | Command | Description |
 |---------|-------------|
+| `/pbr:audit` | Review past sessions for PBR workflow compliance and UX quality. |
+| `/pbr:audit --today` | Audit today's sessions (default). |
+| `/pbr:audit --from DATE --to DATE` | Audit a specific date range. |
+| `/pbr:audit --mode compliance\|ux` | Run compliance-only or UX-only audit. |
 | `/pbr:do <description>` | Route freeform text to the right PBR skill automatically. |
 | `/pbr:dashboard` | Launch the web dashboard for the current project. |
 | `/pbr:dashboard --port <N>` | Launch dashboard on a specific port. |

package/plugins/pbr/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "pbr",
-  "version": "2.16.0",
+  "version": "2.17.1",
   "description": "Plan-Build-Run — Structured development workflow for Claude Code. Solves context rot through disciplined subagent delegation, structured planning, atomic execution, and goal-backward verification.",
   "author": {
     "name": "SienkLogic",