@sienklogic/plan-build-run 2.16.0 → 2.17.1

package/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to Plan-Build-Run will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.17.1](https://github.com/SienkLogic/plan-build-run/compare/plan-build-run-v2.17.0...plan-build-run-v2.17.1) (2026-02-22)
+
+
+### Bug Fixes
+
+* **dashboard:** plan count regex and mermaid rendering ([204838b](https://github.com/SienkLogic/plan-build-run/commit/204838b8be197cfa0835005e79a288f1d7d3d646))
+
+## [2.17.0](https://github.com/SienkLogic/plan-build-run/compare/plan-build-run-v2.16.0...plan-build-run-v2.17.0) (2026-02-22)
+
+
+### Features
+
+* **tools:** add /pbr:audit skill for session compliance and UX review ([ea9920e](https://github.com/SienkLogic/plan-build-run/commit/ea9920e3ce9d982d222644e8898569b2dbfa71f8))
+
 ## [2.16.0](https://github.com/SienkLogic/plan-build-run/compare/plan-build-run-v2.15.0...plan-build-run-v2.16.0) (2026-02-22)
 
 

package/CLAUDE.md

@@ -43,12 +43,12 @@ All plugin code lives under `plugins/pbr/`. Three layers:
 ### Skills (`skills/{name}/SKILL.md`)
 Markdown files with YAML frontmatter defining slash commands (`/pbr:begin`, `/pbr:plan`, etc.). Each SKILL.md is a complete prompt that tells the orchestrator what to do. Skills read state, interact with the user, and spawn agents.
 
-21 skills: begin, build, config, continue, debug, discuss, explore, health, help, import, milestone, note, pause, plan, quick, resume, review, scan, setup, status, todo.
+25 skills: audit, begin, build, config, continue, dashboard, debug, discuss, do, explore, health, help, import, milestone, note, pause, plan, quick, resume, review, scan, setup, status, statusline, todo.
 
 ### Agents (`agents/{name}.md`)
 Markdown files with YAML frontmatter defining specialized subagent prompts. Agents run in fresh `Task()` contexts with clean 200k token windows. Spawned via `subagent_type: "pbr:{name}"` — auto-loaded by Claude Code.
 
-10 agents: researcher, planner, plan-checker, executor, verifier, integration-checker, debugger, codebase-mapper, synthesizer, general.
+11 agents: audit, codebase-mapper, debugger, executor, general, integration-checker, plan-checker, planner, researcher, synthesizer, verifier.
 
 ### Scripts (`scripts/*.js`)
 28 Node.js hook scripts that fire on Claude Code lifecycle events. Configured in `hooks/hooks.json`. All use CommonJS, must be cross-platform (`path.join()`, not hardcoded separators), and log via `logHook()` from `hook-logger.js`.

package/dashboard/src/services/milestone.service.js

@@ -88,13 +88,35 @@ export async function listArchivedMilestones(projectDir) {
 
     if (statsPath) {
       try {
-        const { frontmatter, html } = await readMarkdownFile(statsPath);
+        const { frontmatter, html, rawContent } = await readMarkdownFile(statsPath);
         milestone.name = frontmatter.milestone || frontmatter.name || `v${version}`;
         milestone.date = frontmatter.completed || frontmatter.date || '';
         milestone.duration = frontmatter.duration || '';
         milestone.stats.phaseCount = frontmatter.phases_completed || frontmatter.phase_count || 0;
         milestone.stats.commitCount = frontmatter.total_commits || frontmatter.commit_count || 0;
         milestone.stats.statsHtml = html || '';
+
+        // Fallback: parse markdown content if frontmatter is empty
+        if (milestone.name === `v${version}` && rawContent) {
+          const nameMatch = rawContent.match(/\*\*Name:\*\*\s*(.+)/);
+          if (nameMatch) milestone.name = nameMatch[1].trim();
+          else {
+            const titleMatch = rawContent.match(/^#\s+.*?:\s*(.+?)(?:\s*\(v[\d.]+\))?$/m);
+            if (titleMatch) milestone.name = titleMatch[1].trim();
+          }
+        }
+        if (!milestone.date && rawContent) {
+          const dateMatch = rawContent.match(/\*\*Completed:\*\*\s*(.+)/);
+          if (dateMatch) milestone.date = dateMatch[1].trim();
+        }
+        if (!milestone.duration && rawContent) {
+          const durMatch = rawContent.match(/\*\*Duration:\*\*\s*(.+)/);
+          if (durMatch) milestone.duration = durMatch[1].trim();
+        }
+        if (!milestone.stats.commitCount && rawContent) {
+          const commitMatch = rawContent.match(/Total commits:\s*(\d+)/i) || rawContent.match(/\*\*Plans\*\*:\s*(\d+)/);
+          if (commitMatch) milestone.stats.commitCount = parseInt(commitMatch[1], 10);
+        }
       } catch (_e) {
         milestone.name = `v${version}`;
       }

package/dashboard/src/services/phase.service.js

@@ -112,7 +112,7 @@ export async function getPhaseDetail(projectDir, phaseId) {
   // Supports both naming conventions:
   //   - NN-NN-PLAN.md (plan ID embedded in filename)
   //   - PLAN.md (single plan per phase, ID derived from phase directory)
-  const planRegex = /^(?:\d{2}-\d{2}-)?PLAN\.md$/;
+  const planRegex = /^(?:(?:\d{2}-\d{2})-)?PLAN(?:-\d{2})?\.md$/;
   const planFiles = phaseFiles
     .filter(f => planRegex.test(f))
     .sort();
@@ -120,8 +120,9 @@ export async function getPhaseDetail(projectDir, phaseId) {
   // Build summary paths and read them in parallel
   // Derive planId from filename (NN-NN-PLAN.md) or phase directory (PLAN.md -> NN-01)
   const summaryPaths = planFiles.map((planFile, index) => {
-    const idMatch = planFile.match(/^(\d{2}-\d{2})-PLAN\.md$/);
-    const planId = idMatch ? idMatch[1] : `${phaseId.padStart(2, '0')}-${String(index + 1).padStart(2, '0')}`;
+    const oldMatch = planFile.match(/^(\d{2}-\d{2})-PLAN\.md$/);
+    const newMatch = planFile.match(/^PLAN-(\d{2})\.md$/);
+    const planId = oldMatch ? oldMatch[1] : newMatch ? `${phaseId.padStart(2, '0')}-${newMatch[1]}` : `${phaseId.padStart(2, '0')}-${String(index + 1).padStart(2, '0')}`;
     return { planId, planFile, summaryPath: join(phaseFullPath, `SUMMARY-${planId}.md`) };
   });
 

package/dashboard/src/services/roadmap.service.js

@@ -35,7 +35,7 @@ async function countPlansForPhase(projectDir, phaseId) {
     if (!phaseDir) return 0;
 
     const phaseFiles = await readdir(join(phasesDir, phaseDir.name));
-    return phaseFiles.filter(f => /^(?:\d{2}-\d{2}-)?PLAN\.md$/.test(f)).length;
+    return phaseFiles.filter(f => /^(?:(?:\d{2}-\d{2})-)?PLAN(?:-\d{2})?\.md$/.test(f)).length;
   } catch (err) {
     if (err.code === 'ENOENT') return 0;
     throw err;

package/dashboard/src/views/partials/dependencies-content.ejs

@@ -10,7 +10,7 @@
 <%- include('empty-state', { icon: '🔗', title: 'No dependency data available', action: '' }) %>
 <% } %>
 
-<script type="module">
-  import mermaid from 'https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs';
+<script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>
+<script>
   mermaid.initialize({ startOnLoad: true, theme: 'default', securityLevel: 'loose' });
 </script>

package/dashboard/src/views/partials/phase-content.ejs

@@ -11,10 +11,10 @@
   </header>
   <%
     // Map verification status to CSS status-badge data-status values
-    var vStatus = verification.status || verification.verdict || 'unknown';
+    var vStatus = verification.result || verification.status || verification.verdict || 'unknown';
     var verificationCssStatus = 'not-started';
-    if (vStatus === 'passed') verificationCssStatus = 'complete';
-    else if (vStatus === 'failed') verificationCssStatus = 'blocked';
+    if (vStatus === 'pass' || vStatus === 'passed') verificationCssStatus = 'complete';
+    else if (vStatus === 'fail' || vStatus === 'failed') verificationCssStatus = 'blocked';
     else if (vStatus === 'partial') verificationCssStatus = 'in-progress';
   %>
   <p>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sienklogic/plan-build-run",
-  "version": "2.16.0",
+  "version": "2.17.1",
   "description": "Plan it, Build it, Run it — structured development workflow for Claude Code",
   "keywords": [
     "claude-code",

package/plugins/copilot-pbr/README.md

@@ -52,10 +52,11 @@ The core workflow follows four steps per phase:
 
 Repeat `plan` / `build` / `review` for each phase in your roadmap.
 
-## Skills (22)
+## 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. |
@@ -78,12 +79,14 @@ 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. |
 
-## 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/copilot-pbr/agents/audit.agent.md

@@ -0,0 +1,113 @@
+---
+name: audit
+description: "Analyzes Claude Code session logs for PBR workflow compliance, hook firing, state file hygiene, and user experience quality."
+tools: ["read", "search"]
+infer: true
+target: "github-copilot"
+---
+
+# 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?
+- 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?
+
+### 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?
+
+### 5. Hook Evidence
+- Are there `hook_progress` entries in the log?
+- Which hooks fired and how many times?
+- If NO hook evidence exists, flag as HIGH severity
+
+### 6. Commit Format
+- Verify format: `{type}({scope}): {description}`
+- Check for forbidden `Co-Authored-By` lines
+
+### 7. Subagent Delegation
+- Was implementation work delegated to executor agents?
+- Or was it done directly in main context (anti-pattern)?
+
+---
+
+## UX Audit Checklist
+
+### 1. User Intent vs Assistant Behavior
+- Did the assistant deliver what was asked?
+- Did the user have to repeat instructions?
+
+### 2. Flow Choice Quality
+- Was the chosen PBR command the best fit?
+- Was ceremony proportionate to task scope?
+
+### 3. Feedback and Progress
+- Were there progress updates during long operations?
+
+### 4. Context Efficiency
+- Did the session hit context limits?
+- Was work delegated appropriately?
+
+---
+
+## Context Budget
+
+- **Maximum**: 50% of context for reading logs, 50% for analysis
+- Large JSONL files: sample strategically, don't read entirely
+- Focus on user messages, tool calls, and hook progress entries
+
+---
+
+## Anti-Patterns
+
+1. DO NOT guess what hooks did — only report evidence
+2. DO NOT read the entire JSONL if it exceeds 2000 lines
+3. DO NOT judge explore sessions for missing STATE.md updates
+4. DO NOT fabricate timestamps or session IDs
+5. DO NOT include raw JSONL content in output

package/plugins/copilot-pbr/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "pbr",
   "displayName": "Plan-Build-Run",
-  "version": "2.16.0",
+  "version": "2.17.1",
   "description": "Plan-Build-Run — Structured development workflow for GitHub Copilot CLI. Solves context rot through disciplined agent delegation, structured planning, atomic execution, and goal-backward verification.",
   "author": {
     "name": "SienkLogic",

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

@@ -0,0 +1,330 @@
+---
+name: audit
+description: "Review past Claude Code sessions for PBR workflow compliance and UX quality."
+---
+
+**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/copilot-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/cursor-pbr/.cursor-plugin/plugin.json

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