@sienklogic/plan-build-run 2.0.0

package/CHANGELOG.md

@@ -0,0 +1,56 @@
+# Changelog
+
+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).
+
+## [Unreleased]
+
+## [2.0.0] - 2026-02-17
+
+### Added
+- Token-saving CLI: 6 new commands in `towline-tools.js` — `frontmatter`, `must-haves`, `phase-info`, `state update`, `roadmap update-status`, `roadmap update-plans`
+- Companion web dashboard (Express 5.x, EJS, Pico.css v2, HTMX 2.0) with overview, phase detail, roadmap, todos, and SSE live updates
+- `/dev:import` skill — Import external plan documents into Towline format
+- `/dev:note` skill — Zero-friction idea capture with promote-to-todo support
+- `/dev:setup` skill — Interactive onboarding wizard for new installations
+- `/dev:explore` skill — Socratic conversation for idea exploration
+- `/dev:continue` skill — Execute the next logical step automatically
+- `/dev:health` skill — Validate `.planning/` directory integrity
+- General agent — Lightweight Towline-aware agent for ad-hoc tasks
+- `/dev:build <N> --team` variant — Agent Teams for complex inter-agent coordination
+- `/dev:review <N> --auto-fix` variant — Auto-diagnose and fix verification failures
+- Hook spawn tests for all lifecycle hooks
+- Iterative retrieval protocol for researcher agent
+- Behavioral contexts for agent prompt refinement
+- Published to npm with OIDC trusted publishing
+
+### Changed
+- Skill count increased from 15 to 21
+- Agent count increased from 9 to 10 (added General agent)
+- Hook scripts consolidated: Write/Edit dispatch reduced from 4 spawns to 2
+- All hook scripts now use `logHook()` from `hook-logger.js` for unified logging
+- Agents reference new CLI tooling shortcuts instead of manual YAML parsing
+- README rewritten with badges, comparison table, and acknowledgments
+- Package tarball trimmed from 1.9MB to 305KB via explicit `files` field
+
+### Fixed
+- Windows CI: `parseMustHaves` now trims CRLF line endings
+- Context budget: main orchestrator no longer reads agent definitions (saves ~15% context)
+- Hook logger rotation: `.hook-log` now caps at 200 entries with JSONL format
+- Status line ANSI rendering on Windows terminals
+
+## [1.0.0] - 2025-02-07
+
+### Added
+- Initial release of Plan-Build-Run plugin for Claude Code
+- 15 skills: begin, plan, build, review, discuss, quick, debug, status, pause, resume, milestone, scan, todo, config, help
+- 9 specialized agents: researcher, planner, plan-checker, executor, verifier, integration-checker, debugger, codebase-mapper, synthesizer
+- Hook-enforced quality gates: commit validation, plan format checking, session state injection, pre-compact preservation
+- Wave-based parallel execution via Task() subagents
+- Goal-backward verification at phase and milestone levels
+- Persistent file-based state management (.planning/ directory)
+- Configurable workflow: depth, models, gates, parallelization, git branching
+- Cross-platform Node.js hook scripts (Windows + macOS + Linux)
+- Plugin distribution via npm

package/CLAUDE.md

@@ -0,0 +1,149 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What This Is
+
+Plan-Build-Run is a **Claude Code plugin** that provides a structured development workflow. It solves context rot — quality degradation as Claude's context window fills up — through disciplined subagent delegation, file-based state, and goal-backward verification. Users invoke `/pbr:*` slash commands (skills) that orchestrate specialized agents via `Task()`.
+
+## Critical Rules
+
+- **NEVER add AI co-author lines** to git commits or PRs. No `Co-Authored-By: Claude` or similar. Only add co-author lines referencing actual human contributors.
+- **NEVER inline agent definitions** into skill prompts. Use `subagent_type: "pbr:{name}"` — Claude Code auto-loads agent definitions from `agents/`. Reading agent `.md` files wastes main context.
+
+## Commands
+
+```bash
+npm test                                    # Run all Jest tests (~780 tests, 36 suites)
+npm run lint                                # ESLint on plugins/pbr/scripts/ and tests/
+npm run validate                            # Validate plugin directory structure
+npx jest tests/validate-commit.test.js      # Run a single test file
+npx jest --coverage                         # Run with coverage report
+```
+
+Coverage thresholds (enforced in `package.json`): 65% statements, 58% branches, 70% functions, 65% lines.
+
+Dashboard (separate dependency tree):
+```bash
+npm run dashboard:install                   # One-time install of dashboard deps
+npm run dashboard -- --dir /path/to/project # Launch dashboard for a project
+```
+
+Load the plugin locally for manual testing:
+```bash
+claude --plugin-dir .
+```
+
+CI runs on Node 18/20/22 across Windows, macOS, and Linux. All three platforms must pass.
+
+## Architecture
+
+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.
+
+### 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.
+
+### 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`.
+
+**Dispatch pattern**: Several hooks use dispatch scripts that fan out to sub-scripts based on the file being written/read:
+
+| Hook Event | Entry Script | Delegates To |
+|------------|-------------|-------------|
+| SessionStart | progress-tracker.js | — (injects project state) |
+| PostToolUse (Write\|Edit) | post-write-dispatch.js | check-plan-format.js, check-roadmap-sync.js, check-state-sync.js |
+| PostToolUse (Write\|Edit) | post-write-quality.js | check-doc-sprawl.js, check-skill-workflow.js |
+| PostToolUse (Task) | check-subagent-output.js | — (validates agent output) |
+| PostToolUse (Write\|Edit) | suggest-compact.js | — (context budget warnings) |
+| PostToolUse (Read) | track-context-budget.js | — (tracks reads for budget) |
+| PostToolUseFailure | log-tool-failure.js | — (logs failures) |
+| PreToolUse (Bash) | pre-bash-dispatch.js | validate-commit.js, check-dangerous-commands.js, check-phase-boundary.js |
+| PreToolUse (Write\|Edit) | pre-write-dispatch.js | — (write guards) |
+| PreCompact | context-budget-check.js | — (preserves STATE.md) |
+| Stop | auto-continue.js | — (chains next command) |
+| SubagentStart/Stop | log-subagent.js | — (tracks lifecycle) |
+| SubagentStop | event-handler.js | — (auto-verification trigger) |
+| TaskCompleted | task-completed.js | — (processes task completion) |
+| SessionEnd | session-cleanup.js | — (cleanup) |
+
+**Hook exit codes**: 0 = success, 2 = block (PreToolUse hooks that reject a tool call).
+
+**`${CLAUDE_PLUGIN_ROOT}`**: Used in hooks.json to reference script paths. Claude Code expands this internally — works on all platforms without shell expansion.
+
+### Supporting directories
+
+- **`references/`** — Shared reference docs loaded by skills (plan format, commit conventions, UI formatting, deviation rules)
+- **`templates/`** — EJS-style `.tmpl` files for generated markdown (VERIFICATION.md, SUMMARY.md, etc.)
+- **`commands/`** — Command registration files (one `.md` per command mapping to its skill)
+- **`skills/shared/`** — 14 shared skill fragments extracted from repeated patterns across skills (config-loading, digest-select, revision-loop, context-loader-task, universal-anti-patterns, phase-argument-parsing, gate-prompts, state-loading, state-update, commit-planning-docs, context-budget, domain-probes, progress-display, error-reporting)
+
+## Key Conventions
+
+**Commit format**: `{type}({scope}): {description}` — enforced by PreToolUse hook. Types: feat, fix, refactor, test, docs, chore, wip. Scopes: `{NN}-{MM}` (phase-plan), `quick-{NNN}`, `planning`, `tools`, or descriptive word.
+
+**Skill frontmatter** (SKILL.md):
+```yaml
+---
+name: skill-name
+description: "What this skill does"
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Task
+argument-hint: "<N> [--flag]"
+---
+```
+
+**Agent frontmatter** ({name}.md):
+```yaml
+---
+name: agent-name
+description: "What this agent does"
+model: sonnet|inherit|haiku
+memory: none|user|project
+tools:
+  - Read
+  - Write
+  - Bash
+---
+```
+
+## Data Flow
+
+Skills and agents communicate through files on disk, not messages:
+
+```
+.planning/STATE.md      ← source of truth for current position
+.planning/ROADMAP.md    ← phase structure, goals, dependencies
+.planning/config.json   ← workflow settings (~62 properties across 12 top-level keys)
+.planning/phases/NN-slug/
+  PLAN.md               ← written by planner, read by executor
+  SUMMARY.md            ← written by executor, read by orchestrator
+  VERIFICATION.md       ← written by verifier, read by review skill
+```
+
+The orchestrator stays lean (~15% context) by delegating heavy work to agents. Each agent gets a fresh context window.
+
+**Utility library**: `pbr-tools.js` is a shared Node.js library (stateLoad, configLoad, frontmatterParse, mustHavesCollect, etc.) used by multiple hook scripts. It provides CLI subcommands that agents call to avoid wasting tokens on file parsing.
+
+## Testing
+
+Tests live in `tests/` using Jest. Test files mirror script names: `validate-commit.test.js` tests `validate-commit.js`.
+
+**Fixture project**: `tests/fixtures/fake-project/.planning/` provides read-only fixture data for tests.
+
+**Mutation tests**: Use `fs.mkdtempSync()` to create temporary directories — never mutate the fixture project.
+
+**`pbr-tools.js` tests** span both `pbr-tools.test.js` and `integration.test.js`.
+
+When adding a new hook script, create a corresponding test file. Tests must pass on Windows, macOS, and Linux.
+
+## Dashboard
+
+The dashboard (`dashboard/`) is a separate Express.js application with its own dependency tree (`dashboard/package.json`). It provides a web UI for browsing `.planning/` state. Tech: Express 5.x, EJS, Pico.css, HTMX 2.0, chokidar for file watching, SSE for live updates.
+
+Dashboard tests use Vitest (not Jest) and live in `dashboard/tests/`. Run with `npm --prefix dashboard test`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Towline Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,247 @@
+<p align="center">
+  <img src="./assets/pbr_banner_logo.png" alt="Plan-Build-Run Logo" width="550" />
+</p>
+
+<p align="center">
+  <strong>Context-engineered development workflow for Claude Code.</strong>
+  <br />
+  Build ambitious multi-phase software without quality degradation.
+  <br />
+  Works with any Claude Code plan. Shines on Max.
+  <br />
+  <br />
+  <a href="#why-plan-build-run">Why Plan-Build-Run?</a> &bull;
+  <a href="#getting-started">Getting Started</a> &bull;
+  <a href="#commands">Commands</a> &bull;
+  <a href="#how-it-works">How It Works</a> &bull;
+  <a href="https://github.com/SienkLogic/plan-build-run/wiki">Wiki</a> &bull;
+  <a href=".github/CONTRIBUTING.md">Contributing</a>
+</p>
+
+<p align="center">
+  <a href="https://github.com/SienkLogic/plan-build-run/actions"><img src="https://img.shields.io/github/actions/workflow/status/SienkLogic/plan-build-run/ci.yml?style=for-the-badge&label=CI&logo=github" alt="CI Status" /></a>
+  <img src="https://img.shields.io/badge/Claude_Code-Plugin-7C3AED?style=for-the-badge&logo=anthropic&logoColor=white" alt="Claude Code Plugin" />
+  <img src="https://img.shields.io/badge/Node.js-18%2B-339933?style=for-the-badge&logo=node.js&logoColor=white" alt="Node.js 18+" />
+  <a href="LICENSE"><img src="https://img.shields.io/github/license/SienkLogic/plan-build-run?style=for-the-badge" alt="License" /></a>
+  <a href="https://www.npmjs.com/package/@sienklogic/plan-build-run"><img src="https://img.shields.io/npm/v/@sienklogic/plan-build-run?style=for-the-badge&logo=npm&logoColor=white" alt="npm" /></a>
+  <img src="https://img.shields.io/badge/Tests-780_passing-brightgreen?style=for-the-badge" alt="780 Tests" />
+</p>
+
+---
+
+## The Problem
+
+Claude Code is remarkably capable...until your context window fills up. As tokens accumulate during a long session, reasoning quality degrades, hallucinations increase, and the model starts losing track of earlier decisions. This is **context rot**, and it's the primary failure mode when building anything beyond a single-session project.
+
+**Plan-Build-Run solves this.** It keeps your main orchestrator under ~15% context usage by delegating heavy work to fresh subagent contexts, each getting a clean 200k token window. All state lives on disk. Sessions are killable at any second without data loss. Whether you're on a free tier or Max 5x, wasted context means wasted budget, and context rot is the biggest source of waste.
+
+## Why Plan-Build-Run?
+
+Most AI coding tools treat context as infinite. They index your codebase, track your edits, and hope the model keeps up. That works for single-file changes. It falls apart when you're building something that takes days, spans dozens of files, and requires decisions made on Monday to still hold on Friday.
+
+Plan-Build-Run takes a different approach: **structured context isolation**. Instead of stuffing everything into one session, it delegates each operation to a fresh subagent with a clean 200k token window and coordinates through files on disk.
+
+<p align="center">
+  <img src="./assets/pbr-demo.gif" alt="Plan-Build-Run workflow: begin → plan → build → review" width="800" />
+</p>
+
+Goal-backward verification, lifecycle hooks, wave-based parallelism, kill-safe state, and more. See **[What Sets It Apart](https://github.com/SienkLogic/plan-build-run/wiki/What-Sets-It-Apart)** for the full comparison and differentiators.
+
+> **When to use Plan-Build-Run:** Multi-phase projects where quality matters. New features spanning 5+ files, large refactors, greenfield builds, anything that would take more than one Claude Code session to complete. Use `depth: quick` or `depth: standard` to control agent spawn count per phase.
+>
+> **When to skip it:** Single-file fixes, quick questions, one-off scripts. Use `/pbr:quick` for atomic commits without full workflow overhead: single executor spawn, no research or verification agents.
+
+Works on every Claude Code plan. Use `depth: quick` on Free/Pro, `depth: standard` on Max, `depth: comprehensive` on Max 5x. See **[What Sets It Apart](https://github.com/SienkLogic/plan-build-run/wiki/What-Sets-It-Apart#plan-build-run-on-different-claude-code-plans)** for tier-specific guidance.
+
+---
+
+## Getting Started
+
+### Prerequisites
+
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code) 2.1.45+ &nbsp;(`claude --version`)
+- Node.js 18+
+
+### Install
+
+```bash
+# From your terminal
+claude plugin marketplace add SienkLogic/plan-build-run
+claude plugin install pbr@plan-build-run
+
+# Or from inside a Claude Code session
+/plugin marketplace add SienkLogic/plan-build-run
+/plugin install pbr@plan-build-run
+```
+
+All `/pbr:*` commands are now available globally.
+
+<details>
+<summary><strong>Install scopes</strong></summary>
+
+| Scope | Command | Effect |
+|-------|---------|--------|
+| **Global** (default) | `claude plugin install pbr@plan-build-run` | Available in all projects |
+| **Project only** | `claude plugin install pbr@plan-build-run --scope local` | This project only, gitignored |
+| **Team project** | `claude plugin install pbr@plan-build-run --scope project` | Shared via git, teammates get prompted |
+
+</details>
+
+### Dashboard (Optional)
+
+Plan-Build-Run ships with a companion web dashboard for browsing your project's planning state in a browser. To set it up:
+
+```bash
+# One-time install of dashboard dependencies
+npm run dashboard:install
+
+# Launch the dashboard for any project with a .planning/ directory
+npm run dashboard -- --dir /path/to/your/project
+# Opens at http://127.0.0.1:3000
+```
+
+Or run directly:
+
+```bash
+node dashboard/bin/cli.js --dir /path/to/your/project --port 3000
+```
+
+### Quick Start (Max / Max 5x)
+
+Full pipeline with parallel research and multi-agent builds. Best experience.
+
+```bash
+cd your-project && claude
+```
+```
+/pbr:begin                # Plan-Build-Run asks about your project, researches the domain,
+                          # scopes requirements, and generates a phased roadmap
+
+/pbr:plan 1               # Research + plan the first phase
+/pbr:build 1              # Build it with parallel agents, atomic commits
+/pbr:review 1             # Verify the codebase matches requirements
+/pbr:plan 2               # Repeat for next phase
+```
+
+That's the whole cycle. Everything lands in a `.planning/` directory. Kill your terminal anytime, `/pbr:resume` picks up where you left off.
+
+### Quick Start (Pro / Free)
+
+Lighter workflow that still gives you structured state tracking and clean commits.
+
+```bash
+cd your-project && claude
+```
+```
+/pbr:setup                # Create .planning/ structure without the heavy research step
+/pbr:plan 1 --skip-research   # Plan without spawning a research agent
+/pbr:build 1              # Build it
+/pbr:quick                # For one-off tasks: single agent, atomic commit, lowest cost
+```
+
+Set `depth: quick` in `/pbr:config` to reduce agent spawns across all workflows.
+
+### Quick Reference
+
+| What you want | Command |
+|---------------|---------|
+| Start a new project | `/pbr:begin` (or `/pbr:setup` for lightweight init) |
+| Plan a phase | `/pbr:plan 1` |
+| Build a phase | `/pbr:build 1` |
+| Verify a phase | `/pbr:review 1` |
+| Do something quick | `/pbr:quick` |
+| See where you are | `/pbr:status` |
+| Resume after restart | `/pbr:resume` |
+| Auto-advance | `/pbr:continue` |
+| Change settings | `/pbr:config` |
+
+---
+
+## Commands
+
+### Core Workflow
+
+| Command | Description | Agents |
+|---------|-------------|--------|
+| `/pbr:begin` | Start a new project: questioning, research, requirements, roadmap | 4-6 (quick: 2-3) |
+| `/pbr:plan <N>` | Plan a phase: research, plan creation, verification loop | 2-3 (quick: 1-2) |
+| `/pbr:build <N>` | Build a phase: parallel execution in waves, atomic commits | 2-4 (quick: 1-2) |
+| `/pbr:review <N>` | Verify a phase: automated 3-layer checks + conversational UAT | 1 |
+
+See **[Commands](https://github.com/SienkLogic/plan-build-run/wiki/Commands)** for all 21 commands with flags, cost-by-depth tables, and detailed descriptions.
+
+---
+
+## How It Works
+
+Plan-Build-Run is a **thin orchestrator** that delegates heavy work to fresh subagent contexts via `Task()`. Data flows through files on disk, not through messages.
+
+```
+Main Session (~15% context)
+  │
+  ├── Task(researcher)  ──▶  writes .planning/research/
+  ├── Task(planner)     ──▶  writes PLAN.md files
+  ├── Task(executor)    ──▶  builds code, creates commits
+  ├── Task(executor)    ──▶  (parallel, same wave)
+  └── Task(verifier)    ──▶  checks codebase against must-haves
+```
+
+See **[Architecture](https://github.com/SienkLogic/plan-build-run/wiki/Architecture)** for key concepts, the token-saving CLI, data flow details, and supporting directories.
+
+---
+
+## Deep Dive
+
+| Topic | Description |
+|-------|-------------|
+| **[Agents](https://github.com/SienkLogic/plan-build-run/wiki/Agents)** | 10 specialized agents with configurable model profiles and file-based communication |
+| **[Configuration](https://github.com/SienkLogic/plan-build-run/wiki/Configuration)** | 12 config keys, depth/model profiles, 16+ feature toggles |
+| **[Hooks](https://github.com/SienkLogic/plan-build-run/wiki/Hooks)** | 15 lifecycle hooks that enforce discipline at zero token cost |
+| **[Project Structure](https://github.com/SienkLogic/plan-build-run/wiki/Project-Structure)** | The `.planning/` directory layout, key files, and file ownership |
+| **[Dashboard](https://github.com/SienkLogic/plan-build-run/wiki/Dashboard)** | Web UI with live updates for browsing project state |
+| **[Philosophy](https://github.com/SienkLogic/plan-build-run/wiki/Philosophy)** | Design principles and platform alignment strategy |
+| **[What Sets It Apart](https://github.com/SienkLogic/plan-build-run/wiki/What-Sets-It-Apart)** | Feature comparison and key differentiators |
+
+---
+
+## Local Development
+
+```bash
+# Clone and install
+git clone https://github.com/SienkLogic/plan-build-run.git
+cd plan-build-run
+npm install
+
+# Run tests (758 tests, 36 suites)
+npm test
+
+# Lint
+npm run lint
+
+# Validate plugin structure
+npm run validate
+
+# Load locally for manual testing
+claude --plugin-dir .
+```
+
+CI runs on Node 18/20/22 across Windows, macOS, and Linux. See [CONTRIBUTING.md](.github/CONTRIBUTING.md) for guidelines.
+
+---
+
+## Stats
+
+| Metric | Count |
+|--------|-------|
+| Skills (slash commands) | 21 |
+| Specialized agents | 10 |
+| Hook scripts | 28 |
+| Tests | 758 |
+| Test suites | 36 |
+| Config toggles | 12 top-level keys |
+
+---
+
+## License
+
+[MIT](LICENSE)

package/dashboard/bin/cli.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { resolve } from 'path';
+import { startServer } from '../src/server.js';
+
+const program = new Command();
+
+program
+  .name('pbr-dashboard')
+  .description('Start the Plan-Build-Run planning dashboard')
+  .option('-d, --dir <path>', 'Path to Plan-Build-Run project directory', process.cwd())
+  .option('-p, --port <number>', 'Server port', '3000')
+  .parse();
+
+const options = program.opts();
+const projectDir = resolve(options.dir);
+const port = parseInt(options.port, 10);
+
+if (isNaN(port) || port < 1 || port > 65535) {
+  console.error(`Invalid port: ${options.port}`);
+  process.exit(1);
+}
+
+startServer({ projectDir, port });

package/dashboard/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "plan-build-run-dashboard",
+  "version": "0.1.0",
+  "description": "Web dashboard for viewing Plan-Build-Run project planning state",
+  "type": "module",
+  "bin": {
+    "pbr-dashboard": "./bin/cli.js"
+  },
+  "scripts": {
+    "start": "node bin/cli.js",
+    "dev": "node --watch bin/cli.js",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "plan-build-run",
+    "dashboard",
+    "planning"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@rollup/rollup-win32-x64-msvc": "^4.57.1",
+    "chokidar": "^5.0.0",
+    "commander": "^12.1.0",
+    "ejs": "^3.1.10",
+    "express": "^5.1.0",
+    "gray-matter": "^4.0.3",
+    "helmet": "^8.1.0",
+    "marked": "^17.0.1"
+  },
+  "devDependencies": {
+    "memfs": "^4.56.10",
+    "vitest": "^3.1.0"
+  }
+}