create-pmos 0.1.0

package/payload/okf/core/concepts/sdlc-loop.md

@@ -0,0 +1,69 @@
+---
+type: Concept
+title: The SDLC Loop
+description: The closed agent-driven software development lifecycle PMOS orchestrates — spec, contract, build, evaluate, accept, learn — and how it loops.
+tags: [sdlc, loop, orchestration, lifecycle]
+timestamp: 2026-06-28
+---
+
+# The SDLC Loop
+
+**Situating context:** PMOS is a control plane for an AI-driven SDLC, so it needs one shared picture
+of the loop it controls. This concept defines that loop and names each stage, so skills, gates, and
+AGENTS.md all refer to the same lifecycle. It informs how initiatives flow from
+[OKR](/okf/core/concepts/okr-tree.md) to accepted work and back into knowledge.
+
+## The loop
+
+PMOS drives a closed lifecycle. Each turn of the loop moves one initiative through six stages:
+
+```
+            ┌──────────────────────────────────────────────────┐
+            ▼                                                    │
+   1. SPEC ──► 2. CONTRACT ──► 3. BUILD ──► 4. EVALUATE ──► 5. ACCEPT ──► 6. LEARN
+   (PRD)       (pre-run        (agent       (3-tier         (PM,          (OKF +
+               contract)        run)         gate)           Acceptance    discoveries)
+                                                             Gate)
+```
+
+1. **Spec** — the initiative gets a PRD via the [prd skill](/skills/core/prd.skill). The PRD says
+   what to build and why, anchored to a KR in the [OKR tree](/okf/core/concepts/okr-tree.md).
+2. **Contract** — generator and evaluator agree a **pre-run contract**: testable done-criteria,
+   before any work starts. The PM approves it. (P0: temp file + PM approval; P1+:
+   `agent_runs.pre_run_contract`.)
+3. **Build** — the agent executes the run against the contract. One execution = one agent run.
+4. **Evaluate** — output passes through the [three-tier eval gate](/okf/core/concepts/output-eval.md):
+   Quality Gate → Review Gate → Acceptance Gate.
+5. **Accept** — the PM clears the **Acceptance Gate**: is this the *right* thing, strategically?
+   This is a human decision, not a rubric re-check.
+6. **Learn** — outcomes and friction are written back: agent run logged, discoveries captured,
+   durable knowledge promoted into [OKF](/okf/core/concepts/okf-governance.md). The loop closes and
+   the next initiative begins with more context than the last.
+
+## Why it is a loop, not a pipeline
+
+The sixth stage feeds the first. Each turn deposits knowledge (concepts, calibration data, friction
+notes) that sharpens the next spec and tightens the next contract. A pipeline ends; this loop
+compounds. The compounding is the point — it is how the harness gets better without the model
+changing.
+
+## The PM sits on the loop, not inside every step
+
+PMOS automates stages 1–4 and 6 with agents; the PM's irreducible position is **stage 5**, the
+Acceptance Gate. As autonomy rises (L2 → L3), more of the loop runs without per-step PM
+intervention, but acceptance authority never leaves the human. Designing the loop so the PM can
+always re-enter at stage 5 is what keeps autonomy safe.
+
+## Failure mode the loop defends against
+
+A loop that reports green at stages 3–4 while drifting from the stage-1 intent is **silent drift**
+(see [watermelon-flag](/okf/core/concepts/watermelon-flag.md)). The Acceptance Gate and
+[anti-optimism reporting](/okf/core/concepts/okr-anti-optimism.md) are the structural checks that
+keep the loop honest turn over turn.
+
+## Relationship to other concepts
+
+- The loop is what the [control plane](/okf/core/concepts/control-plane.md) controls.
+- Each run executes inside an [agent harness](/okf/core/concepts/agent-harness.md).
+- The whole loop is run in an [eval-driven](/okf/core/concepts/eval-driven-pm.md) style: the eval
+  is written before the build.

package/payload/okf/core/concepts/self-refining-harness.md

@@ -0,0 +1,77 @@
+---
+type: Concept
+title: The Self-Refining Harness
+description: The harness improves from its own run evidence — a detect → draft → PM-gate loop that turns evals, friction, and calibration data into concrete harness edits, bounded at the L3 ceiling so it never becomes L4 self-mutation.
+tags: [harness, self-improvement, evals, friction, autonomy, context-engineering]
+timestamp: 2026-07-01
+---
+
+# The Self-Refining Harness
+
+**Situating context:** PMOS already frames the [agent as model + harness](/okf/core/concepts/agent-harness.md)
+and already *collects* evidence about its own harness (`evals` defects, `v_friction_recurrence`,
+transcripts, `eval-calibration.md`). What it lacked was a named pattern — and a procedure — for turning
+that evidence back into harness improvements. This concept names it. It was extracted from the
+2026-07-01 "Agent = Model + Harness" research (which found the field converging on *harness engineering*
+as its own discipline, and "agents improving their own tools" as its highest-leverage loop) and it
+informs the [harness-refine skill](/build-skills/harness-refine.skill), [D47](/okf/products/pmos/adr/d47-self-refining-harness.md),
+and the [D23](/okf/products/pmos/adr/d23-quarterly-cadence.md) quarterly harness review.
+
+## The pattern
+
+`Agent = Model + Harness`. The model improves on someone else's schedule; **the harness is the part
+PMOS controls**, so the harness is where PMOS's own improvement has to come from. A harness that only
+grows by hand improves as fast as a human notices problems. A **self-refining harness** improves as fast
+as it *runs*: every agent run leaves evidence, and that evidence is the raw material for the next
+harness edit. This is what makes "Agent = Model + Harness" a **compounding** system rather than a static
+wrapper — and it is the direct mechanism behind the north star (fewer repeated corrections, because the
+harness edits away the causes of the last ones).
+
+## The loop: detect → draft → PM-gate
+
+The self-refining harness is the same shape as the OKF upkeep loop
+([D36](/okf/products/pmos/adr/d36-okf-mirror-ci-enforced.md) → [D42](/okf/products/pmos/adr/d42-okf-author-on-demand.md)),
+one level up — applied to the harness itself:
+
+1. **Detect** — a deterministic signal shows a gap: a `v_friction_recurrence` theme with no resolving
+   decision, a recurring `evals` defect class, a persistent `eval-calibration.md` disagreement, a
+   context-budget signal.
+2. **Draft** — the [harness-refine skill](/build-skills/harness-refine.skill) reads that evidence and
+   drafts concrete, **evidence-cited** edits, each mapped to one artifact: an MCP tool description
+   ([ACI](/build-skills/MCP-SPEC.md), D19), a skill body, an OKF concept, or an `AGENTS.md` heuristic.
+   It **prunes** as readily as it adds (D23 / [prune the scaffolding](/PRINCIPLES.md)).
+3. **PM-gate** — the edits land as a **PR under the human [Acceptance Gate](/okf/core/concepts/output-eval.md)**.
+   The agent proposes; the PM disposes.
+
+## Bounded at L3 — why this is not L4
+
+A harness that rewrites itself on a schedule with no human in the loop is precisely the **L4
+[silent-drift](/okf/core/concepts/watermelon-flag.md) failure mode** — a green gate over a quietly
+deviating reality. The self-refining harness stays at the **L3 ceiling** by three bounds, locked in
+[D47](/okf/products/pmos/adr/d47-self-refining-harness.md):
+
+- **On-demand, never scheduled** — it acts when a PM invokes it or a signal fires, not on a clock.
+- **Proposes, never applies** — it opens a PR; it never merges or self-approves.
+- **Every edit traces to evidence** — a proposal with no run/friction/eval behind it is dropped, so the
+  harness cannot drift on the agent's opinion.
+
+Self-improvement and self-mutation are different things: the first proposes to a human, the second
+decides alone. PMOS does the first.
+
+## Relationship to the field
+
+The 2026 literature names this the move from prompt- to context- to **harness engineering**, and credits
+"agents improving their own tools" (refining tool descriptions and instructions from run transcripts)
+with state-of-the-art coding results. PMOS's version is the disciplined one: the improvement is
+*evidence-cited* and *PM-gated*, which avoids the self-evolving-memory risk class (an agent that rewrites
+its own knowledge unbounded). See [harness-knowledge](/planning/research/harness-knowledge.md) for the
+sources.
+
+## Related
+
+- [agent-harness](/okf/core/concepts/agent-harness.md) — what the harness is; the Summary Gate.
+- [control-plane](/okf/core/concepts/control-plane.md) — why PMOS edits the harness, not the app.
+- [output-eval](/okf/core/concepts/output-eval.md) — the Acceptance Gate this loop submits to.
+- [watermelon-flag](/okf/core/concepts/watermelon-flag.md) — the L4 failure mode the L3 bounds prevent.
+- Skill: [harness-refine](/build-skills/harness-refine.skill). Decision:
+  [D47](/okf/products/pmos/adr/d47-self-refining-harness.md).

package/payload/okf/core/concepts/watermelon-flag.md

@@ -0,0 +1,66 @@
+---
+type: Concept
+title: The Watermelon Flag
+description: A status that reads green on automated metrics but is red underneath on strategic alignment — and silent drift, the L4 failure mode it signals.
+tags: [failure-mode, drift, status, evaluation, governance]
+timestamp: 2026-06-28
+---
+
+# The Watermelon Flag
+
+**Situating context:** As PMOS automates more of the [SDLC loop](/okf/core/concepts/sdlc-loop.md),
+the risk shifts from "agents fail loudly" to "agents succeed on the wrong thing, quietly." This
+concept names that risk so PMOS can build structural defenses against it. It informs the
+[output-eval](/okf/core/concepts/output-eval.md) Acceptance Gate and
+[anti-optimism reporting](/okf/core/concepts/okr-anti-optimism.md).
+
+## The flag
+
+A **watermelon flag** is a status indicator that is **green on the outside, red on the inside**:
+green on automated metrics (tests pass, rubric satisfied, KR dashboard up) while red underneath on
+strategic alignment (the work is drifting away from what the product actually needs).
+
+The name is the warning: do not trust the skin. A green automated signal is necessary but not
+sufficient evidence that work is on track.
+
+## Silent drift — the named failure mode
+
+> **Silent drift:** agents continuously generate outputs that pass automated checks while slowly
+> deviating from strategic product goals.
+
+This is the **L4 failure mode** — the characteristic danger of high autonomy. It is *silent* because
+every automated gate stays green: each individual output is locally correct, passes its Quality Gate
+and may even pass its Review Gate, yet the *trajectory* of the work bends away from intent. No single
+run trips an alarm; the drift only shows up when someone compares the accumulated direction against
+the original strategy.
+
+The watermelon flag is the **surface signal** of silent drift: the moment you notice green metrics
+sitting on top of strategic misalignment, you are looking at drift in progress.
+
+## Why automated gates cannot catch it alone
+
+The Quality Gate asks *does it work?* and the Review Gate asks *does it satisfy the rubric?* Neither
+asks *is this still the right thing?* Silent drift lives precisely in that gap: outputs that work and
+satisfy the rubric but should not have been built. By construction, the automated gates are blind to
+it — which is why the defense has to be structural, not another automated check.
+
+## Structural defenses
+
+PMOS defends against silent drift with two structural mechanisms, not with more automation:
+
+1. **The Acceptance Gate** — the human PM's end-of-run strategic judgment
+   ([output-eval](/okf/core/concepts/output-eval.md)). It is the one gate that asks "is this the
+   right thing?", so it is the one gate that can catch drift. This is why acceptance authority never
+   leaves the human, even at the L3 autonomy ceiling.
+2. **Anti-optimism reporting** — agents and status reports are required to surface the red
+   underneath rather than round up to green
+   ([okr-anti-optimism](/okf/core/concepts/okr-anti-optimism.md)). Honest pessimistic reporting is
+   what makes a watermelon visible before it rots.
+
+## How to use the concept
+
+- When a status is green, ask explicitly: *green on what?* Distinguish automated-metric green from
+  strategic-alignment green. If you can only confirm the former, treat the flag as a watermelon
+  until the Acceptance Gate confirms the latter.
+- Treat any initiative whose KRs are all green but whose strategic justification has gone fuzzy as a
+  drift candidate, and re-anchor it to its [OKR](/okf/core/concepts/okr-tree.md) parent.

package/payload/okf/core/templates/design-brief-template.md

@@ -0,0 +1,84 @@
+---
+type: Template
+title: Design Brief Template
+description: The scaffold for a design brief instance — the context handoff from Claude Code to claude.ai/design. Copy into /planning/design/ and fill; presentation-only.
+tags: [template, design, brief, planning]
+timestamp: 2026-07-01
+---
+
+# Design Brief Template
+
+**Situating context:** This template is the canonical scaffold the
+[design-brief skill](/skills/core/design-brief.skill) instantiates — leg 1 of the
+[design loop](/okf/core/concepts/design-loop.md). It is to design what the
+[PRD template](/okf/core/templates/prd-template.md) is to build: the shared definition before work starts.
+Copy the block into `/planning/design/<slug>-design-brief.md` and fill it; the copy is an operational
+instance and does not live in the OKF bundle.
+
+> Usage: replace every `<…>` placeholder; delete guidance comments (`<!-- … -->`). **Behavior is locked —
+> only presentation is in scope.** Every surface must tie to a real data source (that is the anti-watermelon
+> move at brief time). An empty out-of-scope list means the brief is not ready.
+
+---
+
+```markdown
+# Design Brief: <initiative title> (for claude.ai/design)
+
+## Identity
+- initiative_id: <id>
+- product_slug: <product_slug>
+- pm_slug: <pm_slug>
+- parent_KR: <objective.kr reference>
+- date: <YYYY-MM-DD>
+
+## Point of view (so the design has one)
+<!-- What the product is and the aesthetic it should read as. Keep it to the design's job. -->
+<e.g. a dense, dark-mode-first operations dashboard — calm, information-first, fast to scan — not a
+marketing site. Every screen answers one operator question.>
+
+## Surfaces to design
+<!-- One row per surface. Tie each to the REAL data it shows so the design fits the true shape
+     (column counts, empty states, density) — this is where watermelon-UI is prevented up front. -->
+
+| Surface | Job (one operator question) | Real data source (RLS-scoped view/table) | Notable states |
+|---|---|---|---|
+| <surface> | <job> | <view/table> | <empty / loading / error / active> |
+
+## Semantic token system (the heart of it)
+<!-- Named tokens with light + dark values, NOT one-off swatches. The build maps them to CSS variables
+     once; views never touch raw hex again. -->
+- <status tokens, e.g. rag-red / rag-amber / rag-green; pulse-*; eval-*; watermelon>
+- <base tokens: background / foreground / primary / muted / border / destructive>
+
+## Component set (deliverables)
+<!-- Reusable components + their variants — exactly what /design-sync carries back as the library. -->
+1. <component> — <variants / sizes>
+2. ...
+
+## Hard constraints (do not design around these)
+- **Behavior-preserving** — no new views, no new data, no changed flows. Presentation only.
+- **Accessibility** — status must not rely on color alone (glyph + text; contrast; focus states).
+- **Density** — favor information density and scan-ability over whitespace (if an ops console).
+- <deployment / bundle / platform constraints, e.g. static hosting, bundle budget>
+
+## Out of scope (REQUIRED, non-empty)
+<!-- New features, data-model changes, flow changes, secrets/keys in the client. If a design implies a
+     data change, FLAG IT BACK — it is a separate decision, not part of this brief. -->
+- <out-of-scope item>
+
+## Leg-2 prompt (paste into claude.ai/design)
+<!-- A single prompt that reproduces the above for the design agent. -->
+> <prompt>
+```
+
+---
+
+## Authoring checklist
+
+- [ ] `parent_KR` present and real; brief paired to an initiative that passed intake.
+- [ ] Every surface tied to a real data source (no imagined capability).
+- [ ] Token system named with semantic names, not swatches.
+- [ ] Accessibility (not-color-alone) constraint present.
+- [ ] Out-of-scope non-empty; any data-implying idea flagged back as a separate decision.
+- [ ] Component deliverables named; leg-2 prompt included.
+- [ ] Stays presentation-only — no behavior, data, or flow changes proposed.

package/payload/okf/core/templates/eval-rubric-template.md

@@ -0,0 +1,95 @@
+---
+type: Template
+title: Eval Rubric Template
+description: The scaffold for an evaluation rubric instance, including weighted dimensions, partial credit, and the sprint contract. Copy into /planning/evals/ and fill.
+tags: [template, eval, rubric, scoring, planning]
+timestamp: 2026-06-28
+---
+
+# Eval Rubric Template
+
+**Situating context:** This template was authored as the canonical scaffold the
+[eval-rubric skill](/skills/core/eval-rubric.skill) instantiates, so every rubric uses the same
+weighted-scoring math and carries its sprint contract. Copy the block into
+`/planning/evals/<slug>-eval-rubric.md` and fill it; the copy is operational and does not live in the
+OKF bundle.
+
+> Usage: replace every `<…>`. Weights must sum to 1.0. The threshold is pre-committed — set it before
+> any output exists. See [output-eval](/okf/core/concepts/output-eval.md) for the gate model.
+
+---
+
+```markdown
+# Eval Rubric: <initiative title>
+
+## Frontmatter
+- type: Rubric
+- eval_type: capability | regression   <!-- capability = push frontier; regression = guard against backslide -->
+- initiative_id: <id>
+- product_slug: <product_slug>
+- pm_slug: <pm_slug>
+- parent_KR: <reference>
+- pass_threshold: <0.00–1.00>          <!-- pre-committed, before output exists -->
+- date: <YYYY-MM-DD>
+
+## Gate assignment
+<!-- State which gate each criterion serves. Acceptance Gate is PM-only and NOT rubric-graded. -->
+- Quality Gate (deterministic): <compile / lint / tests that must pass>
+- Review Gate (rubric-scored): the weighted dimensions below
+- Acceptance Gate (PM, strategic): NOT graded here — PM decides "is this the right thing?"
+
+## Weighted dimensions (Review Gate)
+<!-- Outcome-only: grade what was produced, not the path/tool-calls. Partial credit required. -->
+
+| Dimension              | Weight | Score (0–1) | Weighted = W×S |
+|------------------------|-------:|------------:|---------------:|
+| <dimension 1>          |  <0.x> |       <0.x> |          <0.x> |
+| <dimension 2>          |  <0.x> |       <0.x> |          <0.x> |
+| <dimension 3>          |  <0.x> |       <0.x> |          <0.x> |
+| **Total**              | **1.0**|             |   **<sum>**    |
+
+**Result:** total `<sum>` vs threshold `<pass_threshold>` → PASS / FAIL.
+
+## Sprint contract (pre-run)
+initiative_id: <id>
+run_id: <id>
+done_criteria:
+  1. <testable criterion>
+  2. <testable criterion>
+test_method:
+  1. <how criterion 1 is verified, and at which gate>
+  2. <how criterion 2 is verified, and at which gate>
+PM_approved: true | false   <!-- must be true before work starts; P0 = temp file + PM sign-off -->
+```
+
+---
+
+## Partial credit / weighted scoring — how to use
+
+The rubric is **not** all-or-nothing. Score each dimension on a continuous 0–1 scale (partial credit
+required), multiply by its weight, and sum:
+
+```
+total = Σ (weight_i × score_i),   with Σ weight_i = 1.0
+PASS iff total ≥ pass_threshold
+```
+
+Rules:
+
+- **Weights sum to 1.0.** If they do not, the rubric is malformed.
+- **Partial credit is mandatory.** A dimension that can only score 0 or 1 hides quality gradients and
+  defeats weighted scoring — split it or define intermediate anchors.
+- **Anchor the scale.** For each dimension, briefly define what 0, 0.5, and 1 look like, so scoring
+  is repeatable across evaluators (and calibratable against
+  [eval-calibration.md](/planning/evals/eval-calibration.md)).
+- **Threshold is pre-committed.** Never tune the threshold after seeing the output.
+- **Outcome-only.** Score the artifact produced, not the tool-call sequence or reasoning path.
+
+## Authoring checklist
+
+- [ ] `eval_type` set.
+- [ ] Weights present and sum to 1.0.
+- [ ] Each dimension supports partial credit with anchored 0/0.5/1.
+- [ ] `pass_threshold` pre-committed.
+- [ ] Gate assignment stated; Acceptance Gate marked PM-only, not graded.
+- [ ] Sprint contract present with `PM_approved`.

package/payload/okf/core/templates/index.md

@@ -0,0 +1,8 @@
+# core/templates — Index
+
+OKF reserved file (no frontmatter). Directory listing for progressive disclosure — read this
+to pick concepts, then fetch the file(s) you need.
+
+- [design-brief-template](design-brief-template.md) — The scaffold for a design brief instance — the context handoff from Claude Code to claude.ai/design (leg 1 of the design loop). Copy into /planning/design/ and fill; presentation-only.
+- [eval-rubric-template](eval-rubric-template.md) — The scaffold for an evaluation rubric instance, including weighted dimensions, partial credit, and the sprint contract. Copy into /planning/evals/ and fill.
+- [prd-template](prd-template.md) — The scaffold for a Product Requirements Document instance. Copy into /planning/prd/ and fill; do not author PRDs from scratch.

package/payload/okf/core/templates/log.md

@@ -0,0 +1,9 @@
+# core/templates — Log
+
+OKF reserved file (no frontmatter). Change history, newest first, ISO 8601 dates.
+
+## 2026-07-01
+- Added `design-brief-template` — the design-brief scaffold (leg 1 of the design loop, D48), instantiated by the [design-brief skill](/skills/core/design-brief.skill). Distilled from the first instance, `planning/design-brief.md`.
+
+## 2026-06-29
+- Creation — per-folder index/log added (OKF recursive progressive disclosure; D29 reversal direction).

package/payload/okf/core/templates/prd-template.md

@@ -0,0 +1,75 @@
+---
+type: Template
+title: PRD Template
+description: The scaffold for a Product Requirements Document instance. Copy into /planning/prd/ and fill; do not author PRDs from scratch.
+tags: [template, prd, planning]
+timestamp: 2026-06-28
+---
+
+# PRD Template
+
+**Situating context:** This template was authored as the canonical scaffold the
+[prd skill](/skills/core/prd.skill) instantiates, so every PRD in PMOS has the same shape and the
+same anchoring discipline. Copy the block below into `/planning/prd/<slug>-prd.md` and fill it; the
+copy is an operational instance and does not live in the OKF bundle.
+
+> Usage: replace every `<…>` placeholder. Delete guidance comments (`<!-- … -->`) once filled.
+> Keep section order. An empty out-of-scope list or a missing parent KR means the PRD is not ready.
+
+---
+
+```markdown
+# PRD: <initiative title>
+
+## Identity
+- initiative_id: <id>
+- product_slug: <product_slug>
+- pm_slug: <pm_slug>
+- parent_KR: <objective.kr reference>   <!-- REQUIRED. No parent KR = unanchored work, do not proceed. -->
+- status: draft | approved
+- date: <YYYY-MM-DD>
+
+## Problem
+<!-- Who has this problem, why it matters, and why now. Problem BEFORE solution. -->
+
+## Goal
+<!-- The change in the world this initiative seeks. One or two sentences. -->
+
+## Non-goals (out of scope)
+<!-- REQUIRED and non-empty. The primary defense against over-building. -->
+- <out-of-scope item>
+- <out-of-scope item>
+
+## Requirements
+<!-- What must be true of the solution: capabilities and constraints. Not implementation steps. -->
+- <requirement>
+- <requirement>
+
+## Success criteria (outcomes, not output)
+<!-- Tied to the parent KR. A change in the world, not a list of artifacts produced. -->
+- <outcome criterion>
+- <outcome criterion>
+
+## Risks & open questions
+<!-- Include anything to escalate to the PM. -->
+- <risk / question>
+
+## Eval rubric
+<!-- The paired rubric is written BEFORE the build (eval-driven PM). -->
+- rubric: <link to /planning/evals/<slug>-eval-rubric.md>
+
+## Links
+- parent KR: <link>
+- relevant OKF concepts: <links>
+```
+
+---
+
+## Authoring checklist
+
+- [ ] `parent_KR` present and real.
+- [ ] Problem stated before solution.
+- [ ] Non-goals non-empty.
+- [ ] Success criteria are outcomes tied to the KR, not output counts.
+- [ ] Paired eval rubric queued to be written first.
+- [ ] Stays at control altitude — specs *what/why*, not application code or the agent's path.

package/payload/planning/evals/agent-run-eval-rubric.md

@@ -0,0 +1,46 @@
+# Eval Rubric: Agent-run capability baseline (kit seed — copy per initiative)
+
+> Kit-seeded generic rubric (D54). Two purposes: (1) it is the TEMPLATE to copy to
+> `<initiative-id>-eval-rubric.md` and specialize per initiative (rewrite the dimensions to the
+> initiative's own outcomes; keep weights summing to 1.0); (2) it keeps the `rubrics` CI check
+> meaningful from day one. It scores a generic agent run outcome-only (D14) with weighted partial
+> credit (D15).
+
+## Frontmatter
+- type: Rubric
+- eval_type: capability
+- initiative_id: (set per initiative)
+- pass_threshold: 0.80
+- canonical_path: pmos/planning/evals/agent-run-eval-rubric.md
+
+## Gate assignment
+- **Quality Gate (deterministic):** repo CI green; `pmos-gate` (anchored + rubrics) green.
+- **Review Gate (adversarial):** the weighted dimensions below — evaluator skill, default-to-refute,
+  outcome-only; verdict appended to `pmos/state/evals.jsonl`; ADVISORY until locally calibrated.
+- **Acceptance Gate (PM):** the human PM merges and disposes — final and non-delegable (D12).
+
+## Weighted dimensions (Review Gate)
+Outcome-only (D14); partial credit (D15); anchors 0 / 0.5 / 1.0.
+
+| Dimension | Weight | Score | Wtd |
+|---|---:|---:|---:|
+| Contract satisfaction — every done_criterion of the pre-run contract is met, verified per its test_method | 0.40 | — | — |
+| Correctness of the produced artifact — behaves/reads as specified; no defect a reviewer can demonstrate | 0.30 | — | — |
+| Scope discipline — nothing out of contract scope changed; state files appended, never rewritten | 0.20 | — | — |
+| Traceability — initiative anchored; run + eval + friction logged to pmos/state/ | 0.10 | — | — |
+| **Total** | **1.00** | | **vs 0.80** |
+
+### Anchors (0 / 0.5 / 1)
+- **Contract:** 0 = a criterion unmet; 0.5 = met but a test_method not actually exercised; 1 = all met and exercised.
+- **Correctness:** 0 = demonstrable defect; 0.5 = works with a material caveat; 1 = defect-free under the rubric's probes.
+- **Scope:** 0 = out-of-scope change or state rewrite; 0.5 = minor drift, flagged; 1 = clean.
+- **Traceability:** 0 = unanchored or unlogged; 0.5 = partial logging; 1 = complete.
+
+## Sprint contract (pre-run)
+initiative_id: (set)
+run_id: (set)
+done_criteria:
+  1. (numbered, testable — agreed BEFORE work starts)
+test_method:
+  1. (one per criterion; name the gate that checks it)
+PM_approved: false  <!-- flip to true only on the PM's explicit word -->

package/payload/planning/evals/check_rubrics.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""Rubric well-formedness gate: fail CI when an eval rubric is malformed BEFORE it grades anything.
+
+This is the deterministic, repo-only half of P6 (Review Gate as CI). The Review Gate itself is an LLM
+judgment and cannot run reproducibly in CI — but a *malformed rubric* (weights that don't sum to 1.0, a
+missing pass threshold, a missing eval_type) is a deterministic defect we CAN catch. This guards the
+scaffolding the evaluator skill scores against (D14 outcome-only, D15 weighted dimensions + threshold).
+
+Scope: every rubric in planning/evals/ — a file is a rubric iff its frontmatter declares `type: Rubric`
+(tolerates the `- type: Rubric` markdown-list frontmatter the P0/P1 rubrics use). Calibration logs and
+method docs are not rubrics and are skipped. Three assertions per rubric:
+
+  EVAL_TYPE   — eval_type is present and is `capability` or `regression` (D15 frontmatter field).
+  THRESHOLD   — a pre-committed pass threshold in (0,1] exists (`pass_threshold:` or "pass threshold = ").
+  WEIGHTS     — the first Weighted-dimensions table's Weight column sums to 1.0 (±0.011), excluding the
+                explicit Total row. Partial-credit weighting is meaningless if the weights don't sum to 1.
+
+Exit 0 = green. Exit 1 = a malformed rubric; prints which and why. No DB access, no secrets.
+"""
+import os, re, sys, glob
+
+ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+EVALS = os.path.join(ROOT, "planning", "evals")
+fail = []
+checked = 0
+
+
+def read(p):
+    return open(p, encoding="utf-8").read()
+
+
+def num(s):
+    """Parse a possibly-bold/aligned numeric cell like `**0.30**` or `0.35` -> float, else None."""
+    s = s.replace("*", "").replace("`", "").strip()
+    m = re.fullmatch(r"[0-9]*\.?[0-9]+", s)
+    return float(m.group()) if m else None
+
+
+def weight_sum(text):
+    """Sum the Weight column of the FIRST markdown table that has a 'Weight' header, skipping the
+    Total row. Returns (sum, n_rows) or (None, 0) if no weighted table is found."""
+    lines = text.splitlines()
+    for i, line in enumerate(lines):
+        cells = [c.strip() for c in line.strip().strip("|").split("|")]
+        wcol = next((j for j, c in enumerate(cells) if c.lower() == "weight"), None)
+        if wcol is None:
+            continue
+        total, rows = 0.0, 0
+        for row in lines[i + 1:]:
+            if not row.lstrip().startswith("|"):
+                break  # table ended
+            rc = [c.strip() for c in row.strip().strip("|").split("|")]
+            if set("".join(rc)) <= set("-: "):
+                continue  # separator row |---|---|
+            if len(rc) <= wcol:
+                continue
+            # the |Total|1.00| summary row is not a dimension — the "Total" label may sit in any
+            # cell (an empty leading `#` column pushes it right), so scan every cell.
+            if any(c.replace("*", "").strip().lower().startswith("total") for c in rc):
+                continue
+            w = num(rc[wcol])
+            if w is not None:
+                total += w
+                rows += 1
+        return round(total, 4), rows
+    return None, 0
+
+
+for path in sorted(glob.glob(os.path.join(EVALS, "*.md"))):
+    rel = os.path.relpath(path, ROOT)
+    text = read(path)
+    # A rubric declares `type: Rubric` (YAML or `- ` markdown-list frontmatter). Skip everything else.
+    if not re.search(r"^[-\s]*type:\s*Rubric\b", text, re.M | re.I):
+        continue
+    checked += 1
+
+    m = re.search(r"^[-\s]*eval_type:\s*(\w+)", text, re.M | re.I)
+    if not m:
+        fail.append(f"{rel}: missing `eval_type` (must be capability|regression — D15)")
+    elif m.group(1).lower() not in ("capability", "regression"):
+        fail.append(f"{rel}: eval_type `{m.group(1)}` invalid (must be capability|regression)")
+
+    t = re.search(r"pass_threshold:\s*([0-9]*\.?[0-9]+)", text, re.I) or \
+        re.search(r"pass threshold\s*=?\s*([0-9]*\.?[0-9]+)", text, re.I)
+    if not t:
+        fail.append(f"{rel}: no pre-committed pass threshold (`pass_threshold:` or 'pass threshold = ')")
+    elif not (0 < float(t.group(1)) <= 1):
+        fail.append(f"{rel}: pass threshold {t.group(1)} out of range (0,1]")
+
+    s, rows = weight_sum(text)
+    if s is None:
+        fail.append(f"{rel}: no weighted-dimensions table with a `Weight` column (D15)")
+    elif rows < 2:
+        fail.append(f"{rel}: weighted table has {rows} dimension(s) — needs >=2 for partial credit")
+    elif abs(s - 1.0) > 0.011:
+        fail.append(f"{rel}: dimension weights sum to {s}, not 1.0 (D15 partial-credit weighting)")
+
+print(f"Rubric gate: {checked} rubric(s) checked in planning/evals/.")
+if fail:
+    print(f"\n✗ {len(fail)} malformed rubric issue(s):")
+    for f in fail:
+        print("  -", f)
+    print("\nFix: weights must sum to 1.0, set a pass_threshold in (0,1], and an eval_type (D15).")
+    sys.exit(1)
+if checked == 0:
+    print("✗ no rubrics found — expected at least one `type: Rubric` doc in planning/evals/")
+    sys.exit(1)
+print("✓ every rubric is well-formed (weights sum to 1.0, threshold + eval_type present).")

package/payload/planning/evals/eval-calibration.md

@@ -0,0 +1,4 @@
+# Eval calibration log (append-only — every PM override of an evaluator verdict)
+
+| date | initiative_id | run_id | evaluator_verdict | pm_decision | reason |
+|---|---|---|---|---|---|