# Review & the court round (CRT)

> **Conformance:** L2 (every federation sibling and consumer app that opens a gate — release, wave close, published surface)
> **Audience:** AI agents chairing or answering a review round; human maintainers who convene one; anyone reading a round's findings afterwards.
> **Propagation (DOC-18):** when a CRT-* rule changes, also update → README *Index of MUSTs* + [`templates/findings-schema.json`](../../templates/findings-schema.json) (the machine form of CRT-03, pinned against this document by `tests/unit/test_findings_schema.py`) + [`../recipes/court-round.md`](../recipes/court-round.md) (the operational recipe). See DOCUMENTATION.md §10.4.

> **Scope.** A **court round** is an adversarial review run by a reviewer with a
> **fresh context**, against a **committed pin**, that returns **schema'd findings**
> the implementer answers **by ID**. It is the federation's answer to the failure the
> four gates cannot see: *a green suite that is green about the wrong thing.* Every
> defect the CRT family exists to catch — a false broker-death state machine, a stale
> device rendered as current, a decorative tab-order test, a vacuous perf bound, a
> config error misattributed to the user — passed a full green pipeline first.
>
> This standard binds the **protocol**. It does not bind any particular round's
> attack list, report layout, or finding-id scheme — those stay review-time material
> (**CRT-12**).

---

## Rules box (read this first)

| ID | Rule |
|---|---|
| <a id="CRT-01"></a>**CRT-01** | **A court round MUST be chaired by a reviewer with a fresh context, and MUST NOT edit its target.** "Fresh context" means the chair did not write, plan, or supervise the work under review and holds no conversational memory of it — independence comes from the separate context, not a separate machine. The court produces findings on its own surface; the implementer implements; the founder enacts; adoption is a separate supervised step. A reviewer who edits the target has stopped reviewing and started implementing, and nobody is left to catch the edit. |
| <a id="CRT-02"></a>**CRT-02** | **A court round MUST run against a clean committed pin — never a dirty tree.** The round records the exact SHA it reviewed (a fresh clone, a `git worktree`, or a verified-clean `HEAD`); a round whose pin cannot be named did not happen. The convening brief MUST lead with the riskiest change and give the exact re-execute commands (gate invocations, repro steps, seed values) so every claim is independently runnable. A working tree is shared mutable state that lies: it holds edits nobody committed, and the round's conclusions cannot be re-derived from it later. |
| <a id="CRT-03"></a>**CRT-03** | **Every finding MUST carry the full findings grammar:** `finding_id` (stable, unique within the round) · `rule` (the standards anchor measured against, or `null` for a court note) · `severity` (`CRITICAL`/`HIGH`/`MEDIUM`/`LOW`) · `claim` (the one-line assertion under attack) · `failure_scenario` (the concrete sequence that breaks it) · `verdict` (`CONFIRMED`/`PLAUSIBLE`) · `lane` (`implementer`/`founder`/`court`) · `status` (`final`/`provisional:<reason>`/`blocked:<reason>`) · `required_action` · `done_when` (a runnable assertion — a test id, a command, a digest — or a plain statement of why it cannot be mechanized) · `evidence` (the pointer(s): `file:line` at the pin, a command, a ledger anchor) · `evidence_level` · `confidence` (`HIGH`/`MEDIUM`/`LOW`, recorded **independent of severity**). `verdict=CONFIRMED` MUST be backed by `evidence_level=VERIFIED_BY_EXECUTION` — a finding the reviewer reasoned to but did not reproduce is `PLAUSIBLE`, and saying so is conformant. The machine form is [`templates/findings-schema.json`](../../templates/findings-schema.json). |
| <a id="CRT-04"></a>**CRT-04** | **Findings MUST rank evidence, and every finding MUST state its `evidence_level`.** The ranking, strongest first: **hashes** (a digest that either matches or does not) → **executions** (a command run at the pin, exit code read) → **readings** (`file:line` in the pinned tree) → **inferences** (reasoning about code not run). The recorded levels are `VERIFIED_BY_EXECUTION` / `VERIFIED_AGAINST_CODE` / `VERIFIED_AGAINST_DOCS` / `INFERRED`. An exit code read **through a pipe is not an execution** — a tail, a `head`, or a `grep` between the gate and the reviewer replaces the process's status with the pipeline's, and has silently converted a 10–20 % SIGSEGV into `exit 0` in this federation's own history. Gates cited as evidence MUST be run unpiped with the exit code read explicitly. **When the review target is a document corpus**, `VERIFIED_BY_EXECUTION` means the claim was checked either by running the corpus's own gates or by **byte-level comparison of the pinned text against the cited primary source** — a primary-source read *at the pin* is an execution for prose. Without this, every finding against a doc target collapses to `PLAUSIBLE` and the verdict axis stops discriminating. |
| <a id="CRT-05"></a>**CRT-05** | **`could_not_verify` MUST be a mandatory, non-empty-by-default block of every round, and naming a leg there MUST NOT be penalized.** The chair enumerates every claim it could not execute — no hardware, no credential, no reachable log, insufficient time — and marks everything downstream of it `INFERRED`. An **empty `could_not_verify` list reads as an overclaim** and MUST carry a one-line justification that the round genuinely executed everything in scope. Rewarding the admission is the whole mechanism: a chair that fears the list writes `VERIFIED_BY_EXECUTION` next to something it read, and the round's evidence ranking becomes decorative. |
| <a id="CRT-06"></a>**CRT-06** | **`lane` MUST fail closed.** A finding whose `lane` is missing, misspelled, or outside `{implementer, founder, court}` MUST be treated as **`founder` — not implementer-actionable — and escalated**, never silently applied. "I never auto-enact a governance change" is a guarantee only when a mistagged row fails *closed*; default-deny converts a tagging slip into an escalation instead of an unauthorized enactment. |
| <a id="CRT-07"></a>**CRT-07** | **Every prior finding MUST be answered BY ID before the round closes.** The fold report walks the round's finding ids in order and records, per id, what was done and the `done_when` result. **Decline-with-rationale is a conformant answer** (per [`non-adoption-is-valid`](principles/non-adoption-is-valid.md)); a partial fix stated as partial is a conformant answer; **silence is not**. A round with an unanswered id is open, whatever the implementer's summary says. |
| <a id="CRT-08"></a>**CRT-08** | **A fold that claims a regression pin MUST prove the pin bites, by seeded sabotage.** Seed the fix back out (revert the line, restore the old behaviour, plant the defect the court described) — the pin MUST go **red**; restore the fix — the pin MUST go **green**; record both in the fold report. An unproven pin is a test that passes, not a test that catches. The proof MUST be **re-run after any structural change to the code it bites on**: a refactor can dissolve the failure mode a regression test was biting, leaving a green test guarding nothing (this federation lost a teardown pin exactly that way, and had to transfer its bite). |
| <a id="CRT-09"></a>**CRT-09** | **A round MUST end in exactly one holistic verdict, and "reviewed; sound" is a first-class outcome — but only when the round lists what it tried to kill.** The verdicts: *reviewed; sound* · *upheld-with-findings* · *could-not-verify* · *rejected*. A round returning no findings MUST enumerate its **kill attempts** — the specific attacks run and the evidence each produced — because "sound" and "I didn't look hard" are indistinguishable from the outside, and only the attack list separates them. A chair is never obliged to manufacture a finding to look diligent; it is obliged to show the attacks. |
| <a id="CRT-10"></a>**CRT-10** | **Every finding MUST reconcile into exactly one durable home before the round closes.** The homes are the federation's existing ones — a tracker row in `docs/inprogress/`, a `FEEDBACK.md` paper (AG-04/AG-11), the `MGF_STANDARDS_CONFORMANCE.md` ledger row, `LESSON_LEARNED.md` (DOC-19), or a code change with its pin. Exactly one: a finding recorded in two places drifts; **a finding that lives only in the round report does not exist yet** — the report is a work-product, not a queue. |
| <a id="CRT-11"></a>**CRT-11** | **A round MUST be chaired at the tier [SEAT-07](SEATS.md#SEAT-07) assigns it.** SEAT-07 owns the grading norm (*the chair is graded by the cost of a wrong CONCUR, not the prestige of the artifact*) **and** the single list of classes where a mistaken approval outcosts a mistaken finding; this rule neither restates nor extends that list (**DP-14**, derive-never-restate). CRT-11 owns only the binding of a *court round* to it: for the classes SEAT-07 enumerates, the **scarce** tier sits the chair; routine rounds are the executor's. A gate-opening round chaired by the cheap seat without a recorded rationale is the violation. |
| <a id="CRT-12"></a>**CRT-12** | **Review methodology MUST NOT compile into binding rules.** This family binds the court **protocol** — the grammar's fields, the pin, the answer-by-ID loop, the evidence ranking. A specific round's finding-id scheme, its attack list, its report layout, and the per-project standing prompts built from them are **review-time material** and MUST NOT become `docs/standards/` rules. The distinction is load-bearing in both directions: without it, every project's round shape ossifies into law; without CRT-01..11, every project reinvents the protocol. |

---

## 1. Why this family exists — the gap the gates cannot see

The federation's four gates (`ruff` / `mypy --strict` / `pytest --cov` /
`lint-imports`) plus the test supervisor answer one question well: *does the
code do what its tests say?* They cannot answer the question that actually
ships defects: *do the tests say the right thing?*

Every defect listed below was found by a court round in the 2026-07-29/30
`hrb-app` release arc, and **every one of them passed a fully green pipeline
first**:

| What the round found | Why green missed it |
|---|---|
| A global failure counter turning one broken verb into "the broker is dead" — plus a retry livelock | Every unit test exercised one verb at a time; the cross-verb interaction had no test to be wrong in |
| An inspect pane rendering a device that had vanished from the broker as current | The pane's tests asserted rendering, not *honesty* — nothing encoded "shown ⇒ still true" |
| A tab-order test that walked the raw focus chain, so a keyboard-dead table passed | The test was green *and decorative*; its assertion could not fail |
| A shutdown-budget test whose bound was ~33.5 s while the doc claimed ~1.5 s | The assertion was satisfiable by any behaviour — a vacuous bound |
| A config **read** error reported as a config **write** error, blaming the operator | Both paths raised; no test pinned which message the user saw |

The common shape: **a claim nobody attacked.** A court round is an
institution for attacking claims, and the CRT rules are what make its output
comparable across rounds, projects, and models.

## 2. The two halves of a round

A round has an **outbound** leg (the court's findings) and a **return** leg
(the implementer's fold). Both are governed, because a one-directional channel
degrades: findings are read, agreed with in prose, and quietly half-applied.

```
  implementer                        court (fresh context, CRT-01)
      │                                       │
      │  brief: pin SHA + riskiest change     │
      │  + exact re-execute commands ────────▶│  CRT-02
      │                                       │
      │                                       │  attack; execute at the pin
      │                                       │  rank evidence (CRT-04)
      │                                       │  name what it could not run (CRT-05)
      │                                       │
      │◀──── findings (CRT-03 grammar) ───────│  + ONE holistic verdict (CRT-09)
      │                                       │
      │  answer EVERY id (CRT-07)             │
      │  seeded-sabotage each pin (CRT-08)    │
      │  reconcile to one home each (CRT-10)  │
      │                                       │
      │──── fold report, keyed by id ────────▶│  round closes
```

The chair never applies its own findings (CRT-01). The implementer never
decides which findings are worth answering (CRT-07). The founder enacts
anything in the `founder` lane (CRT-06).

## 3. The findings grammar (CRT-03) — field by field

| Field | Required | Values / shape |
|---|---|---|
| `finding_id` | yes | Stable, unique within the round (`F1`, `C-3`, `W4-F2`). The id is the handle everything else uses — the fold answers it, the tracker cites it, the next round checks it closed. |
| `rule` | yes (nullable) | The standards anchor the finding is measured against (`GUI-04`, `TS-14`, `CF-02`), or `null` for a court note that maps to no single rule. |
| `severity` | yes | `CRITICAL` · `HIGH` · `MEDIUM` · `LOW` — the cost if true. |
| `claim` | yes | The one-line assertion under attack, stated as the *target's* claim: "the pane shows a device only while the broker still lists it." |
| `failure_scenario` | yes | The concrete sequence that breaks the claim. Not "the state machine is fragile" — "poll N lists the device, poll N+1 drops it, the pane keeps rendering poll N's detail." |
| `verdict` | yes | `CONFIRMED` (reproduced at the pin) · `PLAUSIBLE` (reasoned, not reproduced). |
| `lane` | yes | Who enacts. `implementer` = code/docs in the target the implementer applies. `founder` = a governance or standards change, never self-enacted. **`court` = owned by review practice itself — round-meta, grammar-usability, and chair-conduct findings; closed by the round or by the next grammar revision, never routed to the target's implementer.** Fails closed (CRT-06). |
| `status` | yes | `final` · `provisional:<reason>` · `blocked:<reason>`. Orthogonal to `lane`: a finding can be `lane=founder, status=provisional:awaiting-pin-bump`. |
| `required_action` | yes | What closes it. |
| `done_when` | yes | A runnable assertion — a registered test id, a command + expected exit, a digest equality — **or** a plain statement of why it cannot be mechanized. `pytest -k test_inspect_pane_clears_on_vanish` is checkable; "fix the honesty problem" is not. |
| `evidence` | yes | Pointer(s): `file:line` at the pin, a command, a ledger anchor. One string or a non-empty array. |
| `evidence_level` | yes | `VERIFIED_BY_EXECUTION` · `VERIFIED_AGAINST_CODE` · `VERIFIED_AGAINST_DOCS` · `INFERRED` (CRT-04). |
| `confidence` | yes | `HIGH` · `MEDIUM` · `LOW`, **independent of `severity`** — a `CRITICAL` finding at `LOW` confidence needs urgent *verification*, not urgent action. |

`severity` × `confidence` is the pair that makes triage possible, and it is
the same enrichment [`principles/audit-outcomes.md`](principles/audit-outcomes.md)
offers audit rows *optionally*. **In a court round it is mandatory** — an audit
row's outcome is checkable against the code later, but a court finding is a
claim about a moment, and an unqualified claim about a moment cannot be
re-graded.

### 3.1 Relationship to the six-flag audit vocabulary

CRT-03's `verdict` is **not** a replacement for the six audit flags
(`✅ ❌ ⚪ 🚫 N/A ⏳`). They answer different questions:

- The **six flags** answer *"does this project conform to this rule?"* — the
  conformance-ledger question, owned by [`audit-outcomes`](principles/audit-outcomes.md).
- **`verdict`** answers *"did the attack land?"* — `CONFIRMED` means the
  reviewer made the failure happen; `PLAUSIBLE` means it did not.

A round that is *also* a per-rule conformance audit records the flag in the
finding's `required_action`/`evidence` and reconciles it into the project's
`MGF_STANDARDS_CONFORMANCE.md` per CRT-10 — it does not invent a parallel
conformance vocabulary. One ledger, one flag set.

## 4. Evidence ranking (CRT-04) in practice

> hashes **>** executions **>** readings **>** inferences

The ranking is not a style preference; each step down is a step further from
the running system:

- **A hash** cannot be argued with. If the wheel's digest at the pin equals the
  digest on the index, the artifact question is closed.
- **An execution** is the system's own state, not a tool's summary of it — and
  it must be *the* system: run at the pin, with the exit code read, **unpiped**.
- **A reading** is `file:line` in the pinned tree. It proves the code says
  something, never that the code *does* something.
- **An inference** is reasoning about code that was not run. Legitimate, often
  necessary, and it MUST be labelled `INFERRED` so the next reader can price it.

**The unpiped rule has a scar behind it.** A gate whose output ran through a
tail reported `exit 0` while the test process was dying with SIGSEGV on 10–20 %
of runs — and had been failing fleet CI probabilistically for weeks, invisible,
because the pipeline's status replaced the process's. Cite gates by their own
exit code or do not cite them.

### 4.1 Execution when the target is prose

A document corpus has no runtime, and a naive reading of the ranking would put
**every** finding against a standards doc, a recipe, or a ledger at `INFERRED`
or `VERIFIED_AGAINST_DOCS` — collapsing the `CONFIRMED`/`PLAUSIBLE` axis to a
single value and making the whole grammar decorative for exactly the reviews
this corpus does most. So CRT-04 defines execution for prose targets. Either of
these counts as `VERIFIED_BY_EXECUTION`:

- **Running the corpus's own gates** at the pin — `gen_rules_index.py --check`,
  `check_headline_coherence.py`, the doc↔code pin tests, a schema validation.
  A count claim that the coherence gate accepts *has been executed*.
- **Byte-level comparison of the pinned text against the cited primary source.**
  If the doc claims a ledger records ten rounds, open that ledger **at the pin**
  and count them. The read is the execution; the primary source is the system.

What does **not** count: reading the doc's own summary of itself, trusting a
number because another doc in the same corpus repeats it (that is the drift
class `check_headline_coherence.py` exists to kill), or reasoning that a claim
"must be" true from surrounding text. Those are `VERIFIED_AGAINST_DOCS` and
`INFERRED` respectively, and saying so is conformant.

This definition is itself a court finding — returned by the round that reviewed
this family, against this family. The recursion is the point: a grammar that
could not grade a review of itself would not have been ready to bind anyone.

## 5. `could_not_verify` (CRT-05) — the rewarded admission

The block is mandatory and its incentive is deliberately inverted: a chair is
**never** graded down for a long `could_not_verify` list, and **is** graded
down for a short one that turns out to be false. Typical honest entries:

- *"The real-hardware path: no device attached in this environment. The
  `hw:/usb` fixtures are fakes; everything downstream is `INFERRED`."*
- *"The remote index publish: no credential in this context. Verified the
  local-index leg only."*
- *"The 30-minute soak: not run. The 5-run integration loop is what I have."*

An empty list is permitted only with a one-line justification that the round's
whole scope was genuinely executed. Where a reviewer needed a log, artifact, or
dashboard it could not reach, **that unreachability is itself worth filing** —
guessing in its place is the violation, not the gap.

## 6. Seeded sabotage (CRT-08) — proving the pin bites

A fold that adds a regression test has claimed something specific: *this test
would have caught the defect.* CRT-08 makes the claim checkable.

```
1. Land the fix + the pin.                        pin GREEN
2. Seed the defect back out (revert the line,
   plant the exact behaviour the court described). pin RED     ← the proof
3. Restore the fix.                                pin GREEN
4. Record steps 2–3 in the fold report, by
   finding id.
```

Step 2 is the entire rule. A pin that stays green under the seeded defect is
guarding nothing, and the round has bought false confidence — strictly worse
than no pin, because it closes the question.

**Re-run the proof after structural change.** A refactor can dissolve the
failure mode a pin was biting on: the code path that produced the defect stops
existing, the test keeps passing, and the pin now guards a scenario that cannot
occur while the *new* scenario is unguarded. This federation lost a teardown
pin exactly that way and had to move its bite to a new assertion. The seeded
sabotage is cheap to re-run; a silently-dead pin is not cheap to discover.

## 7. Who chairs (CRT-11) — one norm, cited not restated

The grading norm and the list of classes it applies to are **[SEAT-07](SEATS.md#SEAT-07)'s**,
in one Rules-box row. Read it there; this section does not copy it, and a
future change to the trigger list happens in exactly one place.

What CRT-11 adds is the binding of a *court round* to that norm: **for the
classes SEAT-07 enumerates, the scarce tier sits the chair; routine rounds are
the executor's.** A gate-opening round chaired by the cheap seat, with no
recorded rationale, is the violation the reviewer prompt looks for.

The reason the norm exists is worth carrying here, because it is what makes
CRT-09's "reviewed; sound" safe to accept:

| The chair is wrong by… | Who pays | Cost |
|---|---|---|
| Raising a finding that turns out not to hold | The implementer | One round-trip: answer by ID, decline with rationale, close |
| **CONCURring on a change that is broken** | Every downstream consumer of the gate the round opened | The defect ships; it is found in production, by a user, or by the next round that should not have had to |

Grading on findings *raised* rewards noise, and noise is how a court loses the
standing that makes its CONCUR mean anything.

## 8. What this family does NOT bind (CRT-12)

The federation already draws this line for its three golden review recipes
(`architecture-review` / `ui-review` / `doc-review`), in
[`../recipes/README.md`](../recipes/README.md) §"Review methodologies vs binding
rules". CRT-12 preserves it, and sharpens where it falls:

| Bound by CRT-01..11 (protocol) | NOT bound — review-time material |
|---|---|
| The grammar's *fields* and their meanings | A round's finding-id *scheme* (`F1` vs `C-3` vs `F-M4`) |
| Committed-pin-only; the answer-by-ID loop | A round's report layout, section order, prose style |
| The evidence ranking and its levels | A project's standing attack list (its "court prompt") |
| One holistic verdict; one durable home per finding | Which attacks a given project's prompt happens to name |
| Chair allocation by cost of a wrong CONCUR | Which model or seat a project uses for its cheap chair |

A project's standing court prompt — the per-project attack list a round is
convened with — is the clearest example. `hrb-app`'s
`docs/gui/GUI_ACCEPTANCE.md` names nine GUI attack lines (unverifiable claim,
frozen-UI path, abstention-shown-as-error, dead control, silent stale view,
leaked internal, teardown crash, keyboard trap, misleading confirm). Those nine
are *right for a Qt operator console* and would be nonsense for a headless
library. They belong in the project, not in this corpus.
[`../recipes/court-round.md`](../recipes/court-round.md) §2 gives the pattern
for writing one.

## 9. Adoption posture (why nothing here fails today)

**CRT-01..04 and CRT-06..12 bind the conduct of a round.** They are in force
for every round convened after enactment and need no file to exist anywhere: a
repo that has never held a court is conformant by construction, and a repo that
holds one is held to the protocol from the first round. There is nothing to
install, nothing to propagate, and no per-repo act.

**One rule is staged, and it is CRT-05.** `could_not_verify` is a *required*
block in [`templates/findings-schema.json`](../../templates/findings-schema.json),
so any `findings.json` written anywhere in this federation carries it. What
this repo does not yet have is a **committed per-round artifact convention** —
the S1..S5 rounds of the Sooth→mgf adoption initiative recorded their
could-not-verify prose in
[`../inprogress/SOOTH_ADOPTION.md`](../inprogress/SOOTH_ADOPTION.md) §5 rather
than in a `findings.json` in the tree. So the obligation is met in substance and
unattestable mechanically, and it carries a `⏳` row in this repo's DOC-15
ledger. It attaches — for this repo and for any other — **the first time a
round's findings land as the schema'd artifact in-tree**; that is one commit by
whoever convenes it, not a federation mechanism, and no library has to ship
anything first.

Nothing in this family is behind a cross-repo mechanism, which is why the list
above is short: unlike [SEAT-08](SEATS.md#SEAT-08)'s dispatch block or the
[SHP](SESSION_HOOKS.md) hook layer, a review protocol has no installable half.
The staging that does exist is the federation's standing warn-then-enforce
order — the same *GATED* class [`LOCK.md`](../../LOCK.md) §1 defines — and it
keeps the family gateable on day one instead of holding every repo to an
artifact convention no repo has yet written.

*(Section added 2026-07-31 by adoption wave S5. It was
`scripts/check_adoption_posture.py`'s first catch on its first run — the gate
derives the staged set from the DOC-15 ledger's `⏳` rows, found CRT-05's, and
reported that the owning doc explained nothing. Convention + template:
[`../recipes/adoption-posture.md`](../recipes/adoption-posture.md).)*

## 10. Mechanical enforcement matrix

| Rule | Enforcement |
|---|---|
| CRT-01 | Review-enforced. The convening record names the chair and its context origin; a chair that edits the target leaves the edit in `git log` under its own authorship. |
| CRT-02 | Mechanically checkable per round: the recorded pin SHA MUST exist and `git status --porcelain` at the pin MUST be empty. Projects SHOULD assert it in the round's own header rather than trusting prose. |
| CRT-03 | **Mechanized.** [`templates/findings-schema.json`](../../templates/findings-schema.json) is the binding machine form (required fields, enums, the `CONFIRMED ⇒ VERIFIED_BY_EXECUTION` coupling); `tests/unit/test_findings_schema.py` pins the schema against this document's Rules box so the two cannot drift. |
| CRT-04 | Schema-enforced for the *presence* of `evidence_level`; the ranking itself is review-enforced. The unpiped-gate clause is checkable by reading the round's cited commands for `\|`. |
| CRT-05 | Review-enforced. An absent `could_not_verify` block returns the round; an empty one without justification is the reviewer prompt. |
| CRT-06 | **Mechanized** by the schema's `lane` enum — but the fail-*closed* behaviour lives in the consumer: any tool that routes findings MUST map missing/unknown → `founder`, and MUST NOT reject the file outright (rejecting loses the finding). |
| CRT-07 | Checkable: the set of `finding_id`s in the round ⊆ the set of ids answered in the fold report. A project with a round-artifact convention SHOULD assert the subset. |
| CRT-08 | Review-enforced by artifact: the fold report records the red run and the restored green run. No red recorded ⇒ no proof ⇒ the finding is not closed. |
| CRT-09 | Review-enforced. Exactly one holistic verdict; a "sound" verdict with no kill-attempt list is the reviewer prompt. |
| CRT-10 | Review-enforced, backed by the existing homes' own gates (FB-01..04 for papers, DOC-15/CFM-03 for the conformance ledger, DOC-19 for lessons). |
| CRT-11 | Review-enforced (a governance allocation, not a checkable artifact). The trigger for a reviewer prompt: a gate-opening round chaired by the cheap seat with no recorded rationale. |
| CRT-12 | Review-enforced, and gated in one direction by `gen_rules_index.py --check` — a per-round id grammar that leaked into a Rules box would appear as an unaccounted anchored rule. |

## 11. Self-review checklist

Before closing a round, the chair confirms:

- [ ] The pin SHA is recorded and the tree at it was clean (CRT-02).
- [ ] Every finding carries all thirteen fields (CRT-03) and validates against the schema.
- [ ] Every `CONFIRMED` finding has `VERIFIED_BY_EXECUTION` evidence (CRT-03).
- [ ] Every cited gate was run unpiped, exit code read (CRT-04).
- [ ] `could_not_verify` is present, and honest (CRT-05).
- [ ] Exactly one holistic verdict; if "sound", the kill attempts are listed (CRT-09).
- [ ] Nothing in the target was edited by the chair (CRT-01).

Before closing the fold, the implementer confirms:

- [ ] Every finding id has an answer — fixed, declined-with-rationale, or partial-and-stated (CRT-07).
- [ ] Every new pin was shown red under seeded sabotage and green after restore (CRT-08).
- [ ] Every finding landed in exactly one durable home (CRT-10).
- [ ] Nothing in the `founder` lane was self-enacted (CRT-06).

---

## Provenance

This family is a **copy-with-attribution** port of the
[`sooth-standard`](https://codeberg.org/magogi-admin/sooth-standard) **CRT
family** (`docs/standards/REVIEW.md`, CRT-01..16, whose own authority is the
soothfast Plasma Court Round Procedure + Judgment & Audit Grammar + OPS-018),
together with `PROVENANCE.md` **PRV-02** (`could_not_verify` is rewarded) and
the court→implementer return format's lane/status split and default-deny rule.
**MGF does not depend on Sooth**: nothing here is an import edge, a submodule,
or a runtime reference — the practices travelled, the code did not, and each
family evolves on its own side. The shared-philosophy clause of
[`LOCK.md`](../../LOCK.md) §5 applies: a semantic change to this family's
honesty bar should trigger a cross-family feedback paper, as it does for the
principles trio.

**The rule IDs do not map 1:1.** `CRT-*` here and `CRT-*` in `sooth-standard`
are different numbering spaces over overlapping content — twelve rules against
sixteen — so the same obligation sits on different numbers: their **CRT-13**
(answer every finding by ID) is our **CRT-07**; their **CRT-14**
(committed-pin-only) is our **CRT-02**; their **CRT-03** (evidence ranking) is
our **CRT-04**. A sibling ledger, round, or handoff dated **before 2026-07-30**
that cites `CRT-nn` is citing Sooth's numbering, not this document's — resolve
the anchor against the corpus the citation came from, never by number alone.

**Adapted, not transcribed.** The Sooth family carries 16 rules against a
different substrate (an `ops/rounds/v{N}/` artifact tree, an 8-block
`handoff.json`, a per-family verifier pair). MGF has none of those and needs
none of them, so the port is **twelve rules**, re-cut to what this federation
actually runs:

- **Added** (mgf-native, from the field evidence below): `severity` + `claim` +
  `failure_scenario` in the grammar; the `CONFIRMED`/`PLAUSIBLE` verdict axis;
  the seeded-sabotage proof (**CRT-08**); the kill-attempt requirement on a
  "sound" verdict (**CRT-09**); the chair-allocation-by-cost-of-wrong-CONCUR
  rule (**CRT-11**); the unpiped-gate clause of **CRT-04**.
- **Dropped** (no mgf surface): the 8-block handoff intake gate, the
  `ops/rounds/` file layout, the patch-shipping channel, the sibling-tree pin
  requirement, the six-licenses restatement (mgf carries it once, in
  [AG-15](AGENTS.md#AG-15) + the [Agent Empowerment Charter](principles/agent-empowerment-charter.md)),
  and the never-block/STOPPERS protocol (same — already AG-15's).
- **Re-homed**: the six audit flags stay with
  [`audit-outcomes`](principles/audit-outcomes.md) (§3.1); decline-with-rationale
  stays with [`non-adoption-is-valid`](principles/non-adoption-is-valid.md).

**Field-proven before codification.** This is not a proposal. The protocol ran
end-to-end across the `hrb-app` v0.2.0 release arc (2026-07-29/30, **14 merged
PRs, #10–#23**; PR #24, the ledger row, merged 2026-07-30 after this branch was
cut): **ten court rounds enumerable by name** in that project's
`docs/inprogress/RELEASE_MASTERPLAN.md` §5 append-only ledger — W2 ×2, W3 ×5,
W4 ×1, the closing wave court, and the sibling consumer court (the basis is
stated in [`SEATS.md`](SEATS.md)'s provenance; the arc's own summary line says
11, and the traced enumeration is the number to cite). Verdicts and folds are
recorded there, with `LESSON_LEARNED.md` carrying the dated lessons. The rounds caught, among others,
the false-broker-death state machine (reproduced), the vanished-device
product-honesty defect, the decorative tab-order test, the vacuous shutdown
budget, and a config-error misattribution in the final wave — **none of them
visible to a green suite**. Three of those are written up as case studies in
[`../recipes/court-round.md`](../recipes/court-round.md) §4.
