@pieerry/harness-kit 3.0.0

package/.claude/agents/product-manager.md

@@ -0,0 +1,20 @@
+---
+name: product-manager
+description: PM orchestrator. Runs the full PRD then PRP pipeline. Use via Task tool for delegation. For direct invocation, prefer /product-manager:run.
+tools: Bash, Read, Edit, Write, Grep, Glob, Skill
+model: opus
+---
+
+Product Manager.
+
+When invoked, run /product-manager:run end to end. Follow .claude/plugins/product-manager/guides/pipeline.md.
+
+Ask once if missing: team or squad, problem in 1-2 sentences, customers, hypothesis, bet link.
+
+Operating rules:
+- English by default. Domain terms stay native if the team uses them.
+- Never invent. Mark gaps with `NOT FOUND - NEEDS REVIEW: {detail}`.
+- Voice: read .claude/plugins/product-manager/guides/writing-style.md. No em-dashes. Mermaid not ASCII.
+- Specific over generic. Real numbers, real names, real quotes.
+
+Return format: see .claude/commands/product-manager/run.md. Include paths, scores, attempts, publish status, blockers.

package/.claude/agents/staff-software-engineer.md

@@ -0,0 +1,25 @@
+---
+name: staff-software-engineer
+description: Engineering orchestrator. Runs the full pipeline (plan, dev, test, pr) for a feature, picking the right area skill (backend, web, mobile, devops). Use via Task tool for delegation, or /sse:run for direct invocation.
+tools: Bash, Read, Edit, Write, Grep, Glob, Skill, WebFetch
+model: opus
+---
+
+Staff Software Engineer.
+
+When invoked, run /sse:run end to end. Follow .claude/plugins/staff-software-engineer/guides/pipeline.md.
+
+Ask once if missing:
+- source PRP path (or read latest from .claude/plugins/product-manager/outputs/prp/)
+- target repo path
+- area: backend, web, mobile, or devops (auto-detect from repo files if possible)
+
+Operating rules:
+- English by default. Domain terms stay native if the team uses them.
+- Read project conventions first. The repo's .claude/conventions/{area}.md (if present) overrides this plugin's defaults. See .claude/plugins/staff-software-engineer/guides/conventions-override.md.
+- Match repo style. Read 3+ similar files before writing.
+- Never invent class names, file paths, helpers. If unknown, `TBD - verify with tech lead`.
+- Voice: read .claude/plugins/staff-software-engineer/guides/coding-style.md and .claude/plugins/staff-software-engineer/guides/commit-style.md. No em-dashes. Mermaid not ASCII.
+- Tests for every feature/bugfix.
+
+Return format: see .claude/commands/sse/run.md. Include paths, scores, gates, PR url, blockers.

package/.claude/commands/product-manager/prd.md

@@ -0,0 +1,31 @@
+---
+description: Generate a Product Requirements Document for an team squad. Business-facing artifact. Sensors and evals gate.
+---
+
+Generate a PRD. Follow .claude/plugins/product-manager/guides/pipeline.md for retry, approval, and publish.
+
+Ask once if missing: squad, problem in 1-2 sentences, customers, hypothesis, bet link, stage.
+
+Compute feature_id = {YYYY-MM-DD}-{squad}-{slug}. Before generating, write the phase start marker:
+
+```
+.claude/plugins/product-manager/outputs/.markers/{feature_id}.prd-generate.start
+```
+
+Content: `{"timestamp": "<ISO-8601 UTC now>", "session_id": ""}`
+
+Read:
+- .claude/plugins/product-manager/guides/product-guidelines.md
+- .claude/plugins/product-manager/guides/prd-guidelines.md
+- .claude/plugins/product-manager/guides/writing-style.md
+- .claude/plugins/product-manager/guides/templates/prd.md
+- .claude/plugins/product-manager/guides/pipeline.md
+- .claude/plugins/product-manager/guides/examples/good-prd-example.md
+
+Save to .claude/plugins/product-manager/outputs/prd/{feature_id}.md.
+
+Sensors: .claude/plugins/product-manager/sensors/prd-structure.md, .claude/plugins/product-manager/sensors/prd-acceptance-criteria.md.
+
+Evals: .claude/plugins/product-manager/evals/prd-quality.md, .claude/plugins/product-manager/evals/prd-readiness.md.
+
+After save reply: PRD saved at {path}. Score: {N}/10.

package/.claude/commands/product-manager/prp.md

@@ -0,0 +1,35 @@
+---
+description: Generate a Product Requirements Prompt for engineering handoff. Needs an approved PRD. Sensors, link validation, and eval gates.
+---
+
+Generate a PRP. Follow .claude/plugins/product-manager/guides/pipeline.md for retry, approval, and publish.
+
+Source PRD: if user passes a path, use it. Else pick the most recent in .claude/plugins/product-manager/outputs/prd/. None found, abort. Tell user to run /product-manager:prd first. .claude/plugins/product-manager/hooks/pre-prp-check.sh blocks if the PRD lacks the approved marker.
+
+Compute feature_id from the source PRD filename (basename without .md). Save the PRP to .claude/plugins/product-manager/outputs/prp/{feature_id}.md so it matches.
+
+Before generating, write the phase start marker:
+
+```
+.claude/plugins/product-manager/outputs/.markers/{feature_id}.prp-generate.start
+```
+
+Content: `{"timestamp": "<ISO-8601 UTC now>", "session_id": ""}`
+
+Read:
+- the source PRD
+- .claude/plugins/product-manager/guides/prp-guidelines.md
+- .claude/plugins/product-manager/guides/writing-style.md
+- .claude/plugins/product-manager/guides/templates/prp.md
+- .claude/plugins/product-manager/guides/pipeline.md
+- .claude/plugins/product-manager/guides/examples/good-prp-example.md
+
+Explore target repos. Ask user for repo paths if not provided. Use Grep and Read to map files. Capture file:line. Never invent paths.
+
+Save to .claude/plugins/product-manager/outputs/prp/{feature_id}.md.
+
+Sensors: .claude/plugins/product-manager/sensors/prp-structure.md, .claude/plugins/product-manager/sensors/prp-context-quality.md, .claude/plugins/product-manager/sensors/prp-links.md.
+
+Evals: .claude/plugins/product-manager/evals/prp-quality.md, .claude/plugins/product-manager/evals/prp-context-readiness.md.
+
+After save reply: PRP saved at {path}. Score: {N}/10. Ready for handoff.

package/.claude/commands/product-manager/run.md

@@ -0,0 +1,31 @@
+---
+description: Run the full PM pipeline. PRD then PRP, with sensor and eval gates between each.
+---
+
+Run end to end.
+
+1. Invoke /product-manager:prd. Wait for the approval marker.
+2. .claude/plugins/product-manager/hooks/pre-prp-check.sh validates the PRD.
+3. Invoke /product-manager:prp using the just-approved PRD.
+4. Return summary.
+
+Follow .claude/plugins/product-manager/guides/pipeline.md. Read .claude/agents/product-manager.md for inputs and rules.
+
+Return format:
+
+```
+Pipeline complete.
+
+PRD: .claude/plugins/product-manager/outputs/prd/{path}
+  sensors: passed (attempts: N)
+  eval: {score}/10
+
+PRP: .claude/plugins/product-manager/outputs/prp/{path}
+  sensors: passed (attempts: N)
+  eval: {score}/10
+
+Confluence: {published | skipped, reason}
+
+Blockers:
+- {file:line, issue, fix}
+```

package/.claude/commands/sse/dev.md

@@ -0,0 +1,47 @@
+---
+description: Implement the approved plan in code. Writes commits, runs gates, returns diff summary.
+---
+
+Implement the plan. Follow .claude/plugins/staff-software-engineer/guides/pipeline.md.
+
+Source plan: latest in .claude/plugins/staff-software-engineer/outputs/plan/ with approved marker. If none, abort and ask user to run /sse:plan first.
+
+Before coding, write the phase start marker:
+
+```
+.claude/plugins/staff-software-engineer/outputs/.markers/{feature_id}.dev.start
+```
+
+Read:
+- the source plan
+- the area skill: .claude/plugins/staff-software-engineer/skills/{area}/SKILL.md
+- .claude/plugins/staff-software-engineer/guides/coding-style.md
+- .claude/plugins/staff-software-engineer/guides/commit-style.md
+- project conventions: {repo}/.claude/conventions/{area}.md if present
+
+Read 3+ similar files in the target repo before writing. Match conventions:
+- framework version (Spring 4.3 no-Boot vs Spring Boot, Vue 2 vs 3)
+- build tool (Maven, Gradle, npm)
+- package layout, test framework, helpers
+
+Write code in small commits (1-4 files, < 100 lines ideal). Conventional Commits format.
+
+Gates (run after each implementation step):
+- .claude/plugins/staff-software-engineer/sensors/code-conventions.md (lint, formatting, banned patterns)
+- .claude/plugins/staff-software-engineer/sensors/test-coverage.md (every feature/bugfix has tests)
+
+If any gate fails, fix and retry. Max 3 attempts. Hard stop after 3.
+
+After done, write `.claude/plugins/staff-software-engineer/outputs/dev/{feature_id}.md` with summary:
+- files changed
+- commits
+- gate results
+- blockers if any
+
+Append approval marker when all gates pass:
+
+```
+<!-- approved: {YYYY-MM-DD} -->
+```
+
+Reply: Dev complete. {N} files changed, {M} commits. Next /sse:test.

package/.claude/commands/sse/plan.md

@@ -0,0 +1,33 @@
+---
+description: Generate an implementation plan from an approved PRP. Sensors and evals gate.
+---
+
+Generate a technical plan. Follow .claude/plugins/staff-software-engineer/guides/pipeline.md for retry, approval, and publish.
+
+Source PRP: if user passes a path, use it. Else pick the most recent in .claude/plugins/product-manager/outputs/prp/. None found, abort. Tell user to run /product-manager:prp first.
+
+Compute feature_id from the source PRP filename (basename without .md). Save the plan to .claude/plugins/staff-software-engineer/outputs/plan/{feature_id}.md so it matches.
+
+Before generating, write the phase start marker:
+
+```
+.claude/plugins/staff-software-engineer/outputs/.markers/{feature_id}.plan-generate.start
+```
+
+Content: `{"timestamp": "<ISO-8601 UTC now>", "session_id": ""}`
+
+Read:
+- the source PRP
+- .claude/plugins/staff-software-engineer/guides/pipeline.md
+- .claude/plugins/staff-software-engineer/guides/coding-style.md
+- .claude/plugins/staff-software-engineer/guides/examples/good-plan-example.md
+- the area-specific skill: .claude/plugins/staff-software-engineer/skills/{area}/SKILL.md (where area = backend, web, mobile, devops)
+- project conventions if present: {repo}/.claude/conventions/{area}.md (see .claude/plugins/staff-software-engineer/guides/conventions-override.md)
+
+Save to .claude/plugins/staff-software-engineer/outputs/plan/{feature_id}.md.
+
+Sensors: .claude/plugins/staff-software-engineer/sensors/plan-structure.md.
+
+Evals: .claude/plugins/staff-software-engineer/evals/plan-quality.md.
+
+After save reply: Plan saved at {path}. Score: {N}/10.

package/.claude/commands/sse/pr.md

@@ -0,0 +1,43 @@
+---
+description: Open a Pull Request on GitHub following team conventions. Draft by default.
+---
+
+Open a Pull Request.
+
+Prerequisites:
+- All previous gates passed (plan approved, dev approved, test approved).
+- Branch pushed to origin with current changes.
+
+Before opening, write the phase start marker:
+
+```
+.claude/plugins/staff-software-engineer/outputs/.markers/{feature_id}.pr.start
+```
+
+Read:
+- .claude/plugins/staff-software-engineer/guides/pr-template.md
+- .claude/plugins/staff-software-engineer/guides/commit-style.md
+- the latest plan and dev outputs (for the body content)
+
+Detect ticket id from branch name (e.g., `feat/PROJ-123-foo` -> `PROJ-123`). If branch has none, ask the user once. Never call Jira API.
+
+Compose:
+- Title: conventional commit prefix + short description (e.g., `feat(PROJ-123): add timezone-aware deadline check`)
+- Body: links to PRD/PRP, summary, test plan checklist
+- Draft: yes by default unless user passes `--ready`
+
+Open via `gh pr create --draft --title "..." --body "..."`.
+
+Save .claude/plugins/staff-software-engineer/outputs/pr/{feature_id}.md with:
+- pr url
+- title
+- draft status
+- summary
+
+Append approval marker:
+
+```
+<!-- approved: {YYYY-MM-DD} ready-for-handoff: true -->
+```
+
+Reply: PR opened: {url}.

package/.claude/commands/sse/run.md

@@ -0,0 +1,39 @@
+---
+description: Run the full engineering pipeline. Plan, dev, test, pr in sequence.
+---
+
+Run end to end.
+
+1. Invoke /sse:plan. Wait for the approval marker on the plan.
+2. Invoke /sse:dev. Implements the plan in code.
+3. Invoke /sse:test. Runs the project test suite.
+4. Invoke /sse:pr. Opens the pull request.
+5. Return summary.
+
+Follow .claude/plugins/staff-software-engineer/guides/pipeline.md for retry, approval markers, token accounting, and publish behavior.
+
+Return format:
+
+```
+Engineering pipeline complete.
+
+Plan: .claude/plugins/staff-software-engineer/outputs/plan/{path}
+  sensors: passed (attempts: N)
+  eval: {score}/10
+
+Dev: branch {branch}
+  files changed: N
+  commits: N
+  gates: code-style ok, conventions ok
+
+Test: .claude/plugins/staff-software-engineer/outputs/test/{path}
+  passed: N, failed: M
+
+PR: {url}
+  draft: yes|no
+
+Confluence: {published | skipped, reason}
+
+Blockers:
+- {file:line, issue, fix}
+```

package/.claude/commands/sse/test.md

@@ -0,0 +1,38 @@
+---
+description: Run the project test suite. Reports results to .claude/plugins/staff-software-engineer/outputs/test/.
+---
+
+Run the test suite for the current repo.
+
+Detect the project test command (in order):
+1. Check README.md or CONTRIBUTING.md for explicit test instructions.
+2. Maven (pom.xml present): `./mvnw test` or `mvn test`
+3. Gradle (build.gradle present): `./gradlew test`
+4. npm (package.json with "test" script): `npm test`
+5. pytest (pyproject.toml or pytest.ini): `pytest`
+6. Other: ask the user.
+
+Before running, write the phase start marker:
+
+```
+.claude/plugins/staff-software-engineer/outputs/.markers/{feature_id}.test.start
+```
+
+Run the test command. Capture stdout and stderr.
+
+Save .claude/plugins/staff-software-engineer/outputs/test/{feature_id}.md with:
+- command run
+- exit code
+- passed, failed counts
+- failing test names (if any)
+- duration
+
+Append approval marker when exit code is 0:
+
+```
+<!-- approved: {YYYY-MM-DD} -->
+```
+
+If tests fail, return a blocker with the failing test names and a snippet of the failure output. Do not retry automatically; let the user decide.
+
+Reply: Tests {passed/failed}. {summary}.

package/.claude/hooks/status-line.sh

@@ -0,0 +1,103 @@
+#!/bin/sh
+# Status line for the PM and SSE plugin pipelines.
+#
+# Shows the current stage of the active feature. Stages, in order:
+#   prd   (product-manager plugin)
+#   prp   (product-manager plugin)
+#   plan  (staff-software-engineer plugin)
+#   dev   (staff-software-engineer plugin)
+#   test  (staff-software-engineer plugin)
+#   pr    (staff-software-engineer plugin)
+#
+# State per stage is "pending" (no file), "drafting" (file exists, no approval
+# marker), or "approved" (approval marker present). The bar shows the previous
+# approved stage plus the current stage, with the next command to run.
+#
+# A feature is "active" when any of its artifact files was modified in the last
+# hour. With no active feature, the bar shows an idle prompt.
+
+PM_DIR=".claude/plugins/product-manager"
+SSE_DIR=".claude/plugins/staff-software-engineer"
+
+render() {
+  LATEST=""
+  for f in "$PM_DIR/outputs/prd/"*.md "$PM_DIR/outputs/prp/"*.md \
+           "$SSE_DIR/outputs/plan/"*.md "$SSE_DIR/outputs/dev/"*.md \
+           "$SSE_DIR/outputs/test/"*.md "$SSE_DIR/outputs/pr/"*.md; do
+    [ -f "$f" ] || continue
+    if [ -z "$LATEST" ] || [ "$f" -nt "$LATEST" ]; then
+      LATEST="$f"
+    fi
+  done
+
+  if [ -z "$LATEST" ]; then
+    printf "idle · start /product-manager:run or /sse:run"
+    return 0
+  fi
+
+  NOW=$(date +%s)
+  MTIME=$(stat -f %m "$LATEST" 2>/dev/null || stat -c %Y "$LATEST" 2>/dev/null || echo 0)
+  AGE=$((NOW - MTIME))
+  if [ "$AGE" -ge 3600 ]; then
+    printf "idle · start /product-manager:run or /sse:run"
+    return 0
+  fi
+
+  FID=$(basename "$LATEST" .md)
+  # Strip leading YYYY-MM-DD-. Optional team prefix accepted (any kebab-case slug).
+  SLUG=$(echo "$FID" | sed -E 's/^[0-9]{4}-[0-9]{2}-[0-9]{2}-//')
+
+  check_state() {
+    [ -f "$1" ] || { echo "pending"; return; }
+    if grep -q "<!-- approved:" "$1" 2>/dev/null; then
+      echo "approved"
+    else
+      echo "drafting"
+    fi
+  }
+
+  prev_approved=""
+  current_stage=""
+  current_state=""
+  for stage in prd prp plan dev test pr; do
+    case $stage in
+      prd)  f="$PM_DIR/outputs/prd/${FID}.md"  ;;
+      prp)  f="$PM_DIR/outputs/prp/${FID}.md"  ;;
+      plan) f="$SSE_DIR/outputs/plan/${FID}.md" ;;
+      dev)  f="$SSE_DIR/outputs/dev/${FID}.md"  ;;
+      test) f="$SSE_DIR/outputs/test/${FID}.md" ;;
+      pr)   f="$SSE_DIR/outputs/pr/${FID}.md"   ;;
+    esac
+    s=$(check_state "$f")
+    if [ "$s" = "approved" ]; then
+      prev_approved=$stage
+    else
+      current_stage=$stage
+      current_state=$s
+      break
+    fi
+  done
+
+  if [ -z "$current_stage" ]; then
+    printf "%s · complete" "$SLUG"
+    return 0
+  fi
+
+  case $current_stage in
+    prd|prp) next="/product-manager:$current_stage" ;;
+    *)       next="/sse:$current_stage" ;;
+  esac
+
+  if [ -z "$prev_approved" ]; then
+    printf "%s · %s %s · next %s" "$SLUG" "$current_stage" "$current_state" "$next"
+  else
+    printf "%s · %s approved · %s %s · next %s" "$SLUG" "$prev_approved" "$current_stage" "$current_state" "$next"
+  fi
+}
+
+OUT=$(render 2>/dev/null)
+if [ -z "$OUT" ]; then
+  printf "idle"
+else
+  printf '%s' "$OUT"
+fi

package/.claude/plugins/product-manager/README.md

@@ -0,0 +1,120 @@
+# Product Manager Plugin
+
+Native Claude Code plugin for the product team. Drafts PRDs and PRPs with sensor + eval gates, retry loop, token accounting per phase, and optional Confluence publish via hooks.
+
+## Slash commands
+
+- `/product-manager:prd`: generate a PRD (skills/prd/SKILL.md)
+- `/product-manager:prp`: generate a PRP, needs an approved PRD (skills/prp/SKILL.md)
+- `/product-manager:run`: full pipeline, PRD then PRP (commands/run.md)
+
+Also invokable as sub-agent via Task tool with `subagent_type: "product-manager"`.
+
+## Tree
+
+```
+.claude/plugins/product-manager/
+├── .claude-plugin/plugin.json
+├── agents/product-manager.md sub-agent
+├── commands/run.md orchestrator (calls the two skills)
+├── skills/
+│ ├── prd/SKILL.md workflow PRD
+│ └── prp/SKILL.md workflow PRP
+├── hooks/ 5 .sh, registered in .claude/settings.json
+├── scripts/ 4 .py, called by hooks
+├── guides/
+│ ├── pipeline.md retry, approval marker, publish, token accounting
+│ ├── product-guidelines.md team product rules
+│ ├── prd-guidelines.md PRD-specific rules
+│ ├── prp-guidelines.md PRP-specific rules
+│ ├── writing-style.md voice, banned words
+│ ├── templates/{prd,prp}.md artifact templates
+│ └── examples/ reference PRDs and PRPs
+├── sensors/ deterministic checks (markdown)
+├── evals/ LLM-judge rubrics (markdown)
+└── outputs/
+ ├── prd/ generated PRDs
+ ├── prp/ generated PRPs
+ ├── tokens/ per-feature phase tokens JSON
+ └── .markers/ phase start/end markers (transient)
+```
+
+## Where to edit
+
+| Change | File |
+|--------|------|
+| Retry count | guides/pipeline.md (Max attempts) |
+| Eval threshold | evals/{prd|prp}-quality.md (Threshold) |
+| What the skill asks | skills/{prd|prp}/SKILL.md |
+| Artifact template | guides/templates/{prd|prp}.md |
+| Artifact rules | guides/{prd|prp}-guidelines.md |
+| Voice and style | guides/writing-style.md |
+| Deterministic checks | sensors/*.md + scripts/sensor-runner.py |
+| Rubric dimensions | evals/*.md |
+| Publish behavior | guides/pipeline.md + hooks/post-eval-{prd|prp}.sh |
+| Confluence target | scripts/confluence-publish.py (parent IDs, space) |
+| Token phase logic | scripts/token-phase.py + guides/pipeline.md |
+
+## How it runs
+
+1. User invokes a slash command.
+2. Skill writes a `prd-generate.start` marker (timestamp + session_id).
+3. Claude reads guides, generates the artifact, saves to outputs/.
+4. PostToolUse hook fires sensor-runner.py with real regex. Blocks on failure, returns feedback. On pass, writes `prd-generate.end` and `prd-validate.start` markers.
+5. Claude applies eval rubric. Retry up to 3 times if score below threshold (rules in guides/pipeline.md).
+6. On pass, Claude appends approval marker. Hook fires: writes `prd-validate.end`, calls token-phase.py for both phases, then confluence-publish.py if creds set.
+7. Token data lands in outputs/tokens/{feature_id}.json. Inline summary comment is appended to the artifact.
+
+## Token accounting
+
+Per phase: prd-generate, prd-validate, prp-generate, prp-validate.
+
+Per feature, a single file `outputs/tokens/{feature_id}.json` collects all phase entries, with `totals` aggregated. Future workflows (dev, code review) can append their own phases to the same file by reusing feature_id.
+
+Query examples:
+
+```
+# total tokens across all features
+jq -s 'map(.totals.input + .totals.output) | add' outputs/tokens/*.json
+
+# tokens for one feature, by phase
+jq '.phases[] | {phase, tokens}' outputs/tokens/2026-05-12-billing-tz-fix.json
+
+# features touched by dispatch squad
+jq -s '.[] | select(.feature_id | contains("dispatch"))' outputs/tokens/*.json
+```
+
+## Engineering handoff
+
+After a PRP is approved, engineering picks it up via the [staff-software-engineer plugin](../staff-software-engineer/README.md). The SSE plugin reads `outputs/prp/{feature_id}.md` and runs plan → dev → test → pr stages, all writing to the same `outputs/tokens/{feature_id}.json` file. Full feature lifecycle in one token log.
+
+## Status bar
+
+The repo's status-line (`.claude/hooks/status-line.sh`) detects PM activity automatically. If any PRD or PRP file under this plugin was modified in the last hour, it switches the status bar to pipeline mode and falls back to the engineering picker otherwise.
+
+The status bar tracks the active feature across both plugins (PM and SSE). Seven stages in order: prd, prp, plan, dev, test, pr. State per stage: pending, drafting, approved.
+
+Examples (PM portion):
+
+```
+idle · start /product-manager:run or /sse:run (no active feature)
+tz-fix · prd drafting · next /product-manager:prd (PRD in progress)
+tz-fix · prd approved · prp pending · next /product-manager:prp (PRD ok, PRP not started)
+tz-fix · prd approved · prp drafting · next /product-manager:prp (PRP in progress)
+tz-fix · prp approved · plan pending · next /sse:plan (PRP ok, SSE turn)
+```
+
+After PRP approval the bar transitions naturally into the SSE stages. State is derived from file presence and the `<!-- approved: -->` marker. No extra config needed.
+
+## Setup
+
+Hooks are registered in `.claude/settings.json` under PreToolUse and PostToolUse.
+
+Confluence publish needs:
+
+```
+export JIRA_USERNAME=...
+export JIRA_API_TOKEN=...
+```
+
+Without them, the hook skips Confluence and keeps the local file.

package/.claude/plugins/product-manager/evals/prd-quality.md

@@ -0,0 +1,88 @@
+# Eval: PRD Quality
+
+Type: LLM-judge
+Mode: quality gate
+Threshold: weighted total >= 8.0
+
+Score each dimension 0-10. Cite line numbers when scoring below 7. Weighted total = sum(score x weight%) / 100.
+
+## Rubric
+
+### Clarity (weight 20%)
+Is the problem stated in 1-2 sentences? Names who suffers, how often, what it costs?
+
+- 10: crisp, specific, evidence-backed
+- 5: present but generic
+- 0: missing or vague
+
+### Hypothesis (weight 15%)
+Is there an "If we X, then Y will Z, because W" hypothesis with numeric target?
+
+- 10: falsifiable, numeric, evidence-tied
+- 5: directional but missing target or evidence
+- 0: aspirational, no measurable claim
+
+### Customer specificity (weight 10%)
+Real customers named with reasons each one matters?
+
+- 10: concrete, differentiated
+- 5: segments named but thin
+- 0: "users" with no segmentation
+
+### Metric completeness (weight 20%)
+Every metric has baseline, target, horizon? Guardrails listed? Kill criteria numeric?
+
+- 10: all filled, guardrails present, kill criteria with thresholds
+- 5: targets present but missing horizon or guardrails
+- 0: missing fields or vague targets
+
+### Scope discipline (weight 10%)
+Non-goals listed (1-3) with reasons? Trade-offs explicit?
+
+- 10: scope tight, trade-offs named
+- 5: non-goals present, reasons thin
+- 0: no non-goals
+
+### Rollout realism (weight 10%)
+Phased rollout with audience, duration, pass criteria per phase? Rollback plan?
+
+- 10: phased with gates and rollback
+- 5: phases present, criteria vague
+- 0: "ship it" with no plan
+
+### Evidence (weight 10%)
+Claims backed by quotes, ticket counts, dashboard data, research?
+
+- 10: at least 3 grounded pieces
+- 5: 1-2 grounded
+- 0: unsupported assertions
+
+### Voice (weight 5%)
+No banned words. No em-dashes. Mermaid not ASCII.
+
+- 10: clean
+- 5: 1-2 violations
+- 0: 3+ violations
+
+## On failure (total below 8.0)
+
+Retry. Identify lowest-scoring dimensions, regenerate those sections only. Max 3 attempts.
+
+## Output format
+
+```json
+{
+  "scores": {
+    "clarity": 0,
+    "hypothesis": 0,
+    "customer_specificity": 0,
+    "metric_completeness": 0,
+    "scope_discipline": 0,
+    "rollout_realism": 0,
+    "evidence": 0,
+    "voice": 0
+  },
+  "weighted_total": 0.0,
+  "feedback": ["dimension: specific issue with line ref"]
+}
+```