@sienklogic/plan-build-run 2.26.2 → 2.27.0

package/CHANGELOG.md

@@ -5,6 +5,13 @@ 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.27.0](https://github.com/SienkLogic/plan-build-run/compare/plan-build-run-v2.26.2...plan-build-run-v2.27.0) (2026-02-24)
+
+
+### Features
+
+* **tools:** add local LLM skill-level fallbacks and platform compatibility docs ([d6d1242](https://github.com/SienkLogic/plan-build-run/commit/d6d1242d79eb924525761e0bc6ac65e1a2d51375))
+
 ## [2.26.2](https://github.com/SienkLogic/plan-build-run/compare/plan-build-run-v2.26.1...plan-build-run-v2.26.2) (2026-02-24)
 
 

package/README.md

@@ -304,6 +304,35 @@ Requires a GPU with 6+ GB VRAM for best performance. CPU-only works but adds lat
 
 ---
 
+## Platform Compatibility
+
+Plan-Build-Run works across three platforms with varying levels of hook support. Hooks are the mechanism that fires validation scripts on every tool call — they power local LLM offloading, commit format enforcement, context budget tracking, and workflow gates.
+
+| Feature | Claude Code | Copilot CLI | Cursor IDE |
+|---------|:-----------:|:-----------:|:----------:|
+| Skills (slash commands) | All 26 | All 26 | All 26 |
+| Agents (subagent delegation) | All 12 | All 12 | All 12 |
+| `.planning/` state management | Full | Full | Full |
+| **Hook support** | **Full (14 events)** | **Partial (4 events)** | **Unverified** |
+| Commit format enforcement | Hook-enforced | Hook-enforced | Manual |
+| PLAN/SUMMARY quality classification | Hook + skill fallback | Hook + skill fallback | Skill fallback only |
+| Test failure triage | Automatic (hook) | Automatic (hook) | Not available |
+| Context budget tracking | Automatic (hook) | Not available | Not available |
+| Auto-continue between skills | Automatic (hook) | Not available | Not available |
+| Subagent lifecycle logging | Automatic (hook) | Not available | Not available |
+| **Local LLM offloading** | **Full (8 operations)** | **Mostly (6-7 operations)** | **CLI only** |
+| `pbr-tools.js llm` CLI commands | Full | Full | Full |
+
+**Key differences:**
+
+- **Claude Code** has full hook support — all local LLM operations fire automatically on every tool call
+- **Copilot CLI** supports `sessionStart`, `preToolUse`, `postToolUse`, and `sessionEnd` — covers most validation hooks but misses lifecycle events (`SubagentStop`, `PreCompact`, `Stop`)
+- **Cursor IDE** hook support is unverified — hooks.json is configured but whether Cursor actually fires them is unknown. Skills include `pbr-tools.js llm` fallback calls for key operations (plan quality, verification quality) so local LLM classification is available even without hooks
+
+All platforms share the same scripts via relative paths — no code duplication. See the [Copilot CLI](plugins/copilot-pbr/README.md) and [Cursor IDE](plugins/cursor-pbr/README.md) READMEs for platform-specific details.
+
+---
+
 ## Local Development
 
 ```bash

package/package.json

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

package/plugins/copilot-pbr/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "pbr",
   "displayName": "Plan-Build-Run",
-  "version": "2.26.2",
+  "version": "2.27.0",
   "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/build/SKILL.md

@@ -242,6 +242,18 @@ For each wave, in order (Wave 1, then Wave 2, etc.):
 
 For each plan in the current wave (excluding skipped plans):
 
+**Local LLM plan quality check (optional, advisory):**
+
+Before spawning executors for this wave, if `config.local_llm.enabled` is `true`, run a quick classification on each plan to catch stubs before wasting an executor spawn:
+
+```bash
+node ${PLUGIN_ROOT}/scripts/pbr-tools.js llm classify PLAN ".planning/phases/{NN}-{slug}/{plan_id}-PLAN.md"
+```
+
+- If classification is `"stub"` or `"partial"` with confidence >= 0.7: warn the user before spawning: `"⚠ Plan {plan_id} classified as {classification} (confidence {conf}) — consider refining before building."`
+- If the command fails or returns null: skip silently (local LLM unavailable — not an error)
+- This is advisory only — never block on the result
+
 **Present plan narrative before spawning:**
 
 Display to the user before spawning:

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

@@ -147,6 +147,18 @@ Before proceeding to Step 7, confirm these exist on disk:
 
 If either check fails, you have skipped steps. Go back and complete Steps 4-6. Do NOT proceed to spawning an executor.
 
+### Step 6b: Local LLM Task Validation (optional, advisory)
+
+If `config.local_llm.enabled` is `true`, run a quick scope validation before spawning:
+
+```bash
+node ${PLUGIN_ROOT}/scripts/pbr-tools.js llm classify PLAN ".planning/quick/{NNN}-{slug}/PLAN.md"
+```
+
+- If classification is `"stub"` with confidence >= 0.7: warn `"⚠ Plan looks like a stub — executor may struggle. Consider adding more detail to task descriptions."`
+- If the command fails or returns null: skip silently (local LLM unavailable)
+- This is advisory only — never block on the result
+
 ### Step 7: Spawn Executor
 
 **Pre-spawn check** — Verify `.planning/quick/{NNN}-{slug}/PLAN.md` exists and contains at least one `<task>` block. If missing, STOP and complete Steps 4-6 first.

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

@@ -182,6 +182,20 @@ Then display the overall verdict (`PASSED`, `GAPS FOUND`, or `HUMAN NEEDED`) bef
 
 ---
 
+### Step 3b: Local LLM Verification Quality Check (optional, advisory)
+
+After the verifier completes and writes VERIFICATION.md, if `config.local_llm.enabled` is `true`, run a quality classification:
+
+```bash
+node ${PLUGIN_ROOT}/scripts/pbr-tools.js llm classify SUMMARY ".planning/phases/{NN}-{slug}/VERIFICATION.md"
+```
+
+- If classification is `"thin"` with confidence >= 0.7: warn `"⚠ Verification report appears thin on details — UAT may not catch all gaps. Consider re-running with /pbr:review {N}."`
+- If the command fails or returns null: skip silently (local LLM unavailable)
+- This is advisory only — never block on the result
+
+---
+
 ### Step 4: Present Verification Results (inline)
 
 Read the VERIFICATION.md frontmatter. Check the `attempt` counter.

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

@@ -1,7 +1,7 @@
 {
   "name": "pbr",
   "displayName": "Plan-Build-Run",
-  "version": "2.26.2",
+  "version": "2.27.0",
   "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",

package/plugins/cursor-pbr/README.md

@@ -113,6 +113,26 @@ Plan-Build-Run stores all state in a `.planning/` directory at your project root
 
 Run `/pbr:config` to interactively adjust settings like depth, model profiles, and gate behavior.
 
+## Hook Compatibility
+
+Cursor's plugin hooks.json is configured with all 14 hook events matching Claude Code. However, **whether Cursor IDE actually fires these hooks is unverified** — no integration testing has confirmed hook execution in real Cursor sessions.
+
+**If hooks DO fire**, Cursor gets the full hook experience identical to Claude Code:
+- Commit format enforcement (PreToolUse)
+- PLAN/SUMMARY quality classification via local LLM (PostToolUse)
+- Test failure triage (PostToolUse)
+- Context budget tracking (PostToolUse)
+- Auto-continue between skills (Stop)
+
+**If hooks do NOT fire**, the following are unavailable:
+- Commit format enforcement — commits won't be validated automatically
+- Automatic local LLM classification on writes — but skills include explicit `pbr-tools.js llm` fallback calls for plan quality (build Step 6a), task validation (quick Step 6b), and verification quality (review Step 3b)
+- Context budget tracking — no automatic warnings when context is filling up
+- Auto-continue — you must manually run the next command
+- Subagent lifecycle logging — agent spawn/completion events aren't tracked
+
+**Local LLM via CLI (always works):** Regardless of hook support, skills and agents can call `pbr-tools.js llm` commands directly via Bash. The `/pbr:status` skill displays local LLM metrics, and agents (debugger, researcher, synthesizer) use CLI commands for error classification, source scoring, and summarization.
+
 ## Cross-Plugin Compatibility
 
 This plugin works alongside the Claude Code version of Plan-Build-Run. Both plugins share the same `.planning/` directory and file formats, so you can switch between Cursor and Claude Code without losing state. Hook scripts under `plugins/pbr/scripts/` are shared between both plugins via relative paths.

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

@@ -243,6 +243,18 @@ For each wave, in order (Wave 1, then Wave 2, etc.):
 
 For each plan in the current wave (excluding skipped plans):
 
+**Local LLM plan quality check (optional, advisory):**
+
+Before spawning executors for this wave, if `config.local_llm.enabled` is `true`, run a quick classification on each plan to catch stubs before wasting an executor spawn:
+
+```bash
+node ${PLUGIN_ROOT}/scripts/pbr-tools.js llm classify PLAN ".planning/phases/{NN}-{slug}/{plan_id}-PLAN.md"
+```
+
+- If classification is `"stub"` or `"partial"` with confidence >= 0.7: warn the user before spawning: `"⚠ Plan {plan_id} classified as {classification} (confidence {conf}) — consider refining before building."`
+- If the command fails or returns null: skip silently (local LLM unavailable — not an error)
+- This is advisory only — never block on the result
+
 **Present plan narrative before spawning:**
 
 Display to the user before spawning:

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

@@ -147,6 +147,18 @@ Before proceeding to Step 7, confirm these exist on disk:
 
 If either check fails, you have skipped steps. Go back and complete Steps 4-6. Do NOT proceed to spawning an executor.
 
+### Step 6b: Local LLM Task Validation (optional, advisory)
+
+If `config.local_llm.enabled` is `true`, run a quick scope validation before spawning:
+
+```bash
+node ${PLUGIN_ROOT}/scripts/pbr-tools.js llm classify PLAN ".planning/quick/{NNN}-{slug}/PLAN.md"
+```
+
+- If classification is `"stub"` with confidence >= 0.7: warn `"⚠ Plan looks like a stub — executor may struggle. Consider adding more detail to task descriptions."`
+- If the command fails or returns null: skip silently (local LLM unavailable)
+- This is advisory only — never block on the result
+
 ### Step 7: Spawn Executor
 
 **Pre-spawn check** — Verify `.planning/quick/{NNN}-{slug}/PLAN.md` exists and contains at least one `<task>` block. If missing, STOP and complete Steps 4-6 first.

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

@@ -183,6 +183,20 @@ Then display the overall verdict (`PASSED`, `GAPS FOUND`, or `HUMAN NEEDED`) bef
 
 ---
 
+### Step 3b: Local LLM Verification Quality Check (optional, advisory)
+
+After the verifier completes and writes VERIFICATION.md, if `config.local_llm.enabled` is `true`, run a quality classification:
+
+```bash
+node ${PLUGIN_ROOT}/scripts/pbr-tools.js llm classify SUMMARY ".planning/phases/{NN}-{slug}/VERIFICATION.md"
+```
+
+- If classification is `"thin"` with confidence >= 0.7: warn `"⚠ Verification report appears thin on details — UAT may not catch all gaps. Consider re-running with /pbr:review {N}."`
+- If the command fails or returns null: skip silently (local LLM unavailable)
+- This is advisory only — never block on the result
+
+---
+
 ### Step 4: Present Verification Results (inline)
 
 Read the VERIFICATION.md frontmatter. Check the `attempt` counter.

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

@@ -1,6 +1,6 @@
 {
   "name": "pbr",
-  "version": "2.26.2",
+  "version": "2.27.0",
   "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",

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

@@ -244,6 +244,18 @@ For each wave, in order (Wave 1, then Wave 2, etc.):
 
 For each plan in the current wave (excluding skipped plans):
 
+**Local LLM plan quality check (optional, advisory):**
+
+Before spawning executors for this wave, if `config.local_llm.enabled` is `true`, run a quick classification on each plan to catch stubs before wasting an executor spawn:
+
+```bash
+node ${CLAUDE_PLUGIN_ROOT}/scripts/pbr-tools.js llm classify PLAN ".planning/phases/{NN}-{slug}/{plan_id}-PLAN.md"
+```
+
+- If classification is `"stub"` or `"partial"` with confidence >= 0.7: warn the user before spawning: `"⚠ Plan {plan_id} classified as {classification} (confidence {conf}) — consider refining before building."`
+- If the command fails or returns null: skip silently (local LLM unavailable — not an error)
+- This is advisory only — never block on the result
+
 **Present plan narrative before spawning:**
 
 Display to the user before spawning:

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

@@ -148,6 +148,18 @@ Before proceeding to Step 7, confirm these exist on disk:
 
 If either check fails, you have skipped steps. Go back and complete Steps 4-6. Do NOT proceed to spawning an executor.
 
+### Step 6b: Local LLM Task Validation (optional, advisory)
+
+If `config.local_llm.enabled` is `true`, run a quick scope validation before spawning:
+
+```bash
+node ${CLAUDE_PLUGIN_ROOT}/scripts/pbr-tools.js llm classify PLAN ".planning/quick/{NNN}-{slug}/PLAN.md"
+```
+
+- If classification is `"stub"` with confidence >= 0.7: warn `"⚠ Plan looks like a stub — executor may struggle. Consider adding more detail to task descriptions."`
+- If the command fails or returns null: skip silently (local LLM unavailable)
+- This is advisory only — never block on the result
+
 ### Step 7: Spawn Executor
 
 **Pre-spawn check** — Verify `.planning/quick/{NNN}-{slug}/PLAN.md` exists and contains at least one `<task>` block. If missing, STOP and complete Steps 4-6 first.

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

@@ -202,6 +202,20 @@ Then display the overall verdict (`PASSED`, `GAPS FOUND`, or `HUMAN NEEDED`) bef
 
 ---
 
+### Step 3b: Local LLM Verification Quality Check (optional, advisory)
+
+After the verifier completes and writes VERIFICATION.md, if `config.local_llm.enabled` is `true`, run a quality classification:
+
+```bash
+node ${CLAUDE_PLUGIN_ROOT}/scripts/pbr-tools.js llm classify SUMMARY ".planning/phases/{NN}-{slug}/VERIFICATION.md"
+```
+
+- If classification is `"thin"` with confidence >= 0.7: warn `"⚠ Verification report appears thin on details — UAT may not catch all gaps. Consider re-running with /pbr:review {N}."`
+- If the command fails or returns null: skip silently (local LLM unavailable)
+- This is advisory only — never block on the result
+
+---
+
 ### Step 4: Present Verification Results (inline)
 
 Read the VERIFICATION.md frontmatter. Check the `attempt` counter.