mjolnir-qa 4.0.0 → 6.0.0

package/CHANGELOG.md

@@ -9,8 +9,2904 @@ Rule behavior changes (new rules, FP-rate changes against the corpus,
 severity changes) are first-class entries here — rule IDs are immutable
 once shipped, so this file is the record of what changed between versions.
 
+## [6.0.0] — 2026-10-04
+
+<!-- ANTI-CREEP-EXCEPTION: The launch set grew from 0 to 2 — QA-PW-117 and QA-JV-101 both earned core at n=35 with a 9.89% Wilson upper bound against the 10% ceiling, every row adjudicated by hand against a pinned corpus commit. Law 1 requires an equal-size removal or a recorded exception. Nothing was removed, deliberately: the quarantine population is what keeps unmeasured rules out of default scans, and promoting two rules by demoting two measured ones would have traded measured accuracy for a smaller number. The growth is arithmetic, not preference. -->
+
+The verification trust engine, measured. A tier you can only reach with evidence,
+a promotion that cannot land unreviewed, and generated documentation that cannot
+quietly go stale behind the code. Carries the 6.0.0-rc.1 line below.
+
+### Two core rules, and the arithmetic behind them
+
+`QA-PW-117` and `QA-JV-101` hold `core`, each at **n=35, zero observed false
+positives, Wilson upper bound 9.89%** against a 10% ceiling — reproduced by hand
+from `src/lib/wilson.ts` before either was believed.
+
+`QA-JV-101` earned it in two batches, and the sequence matters: **32 (10.72%) →
+34 (10.15%) → 35 (9.89%)**. The first batch's verdict file reads as a refusal on
+its own ("STILL SHORT, NOT promoted"). Reading only it is how an audit concluded
+the promotion was fabricated. Both files are cited in the certification record so
+the next reader cannot repeat the mistake.
+
+### The tree told a different story than the code
+
+Both promotions reached the registry, the tier evidence and this file while their
+generated documentation still reported `extended` at n=23/24. Nothing failed,
+because nothing asked — `npm run check` regenerates and then inspects nothing,
+and three of four workflows asserted staleness with `git diff`, which is provably
+blind to an untracked generated page.
+
+- **`npm run docs:staleness`** — one assertion, `git status`-based, read-only by
+  construction, wired into all four workflows.
+- **A count nobody can check is a claim, so generate it.** `README.md` said
+  "`core` is empty" for a release after two rules had earned it.
+- **`docs/MEASUREMENT-CLOSEOUT.md`** corrected 74/5 → 73/6, gained the missing
+  `QA-PY-004` row, and separates _stale_ from unmeasured.
+
+### A promotion can no longer land with no artifact
+
+`docs/CORE-CERTIFICATION.json` is required to hold `core`, and expires with its
+evidence: the measurement is compared against the live registry field by field.
+`docs/TIER-HISTORY.json` records all 19 transitions as data, so a demotion is no
+longer something that exists only as a source comment.
+`docs/RULE-CONSTITUTION.json` states seven principles, each naming the code that
+enforces it, plus **two principles it explicitly refuses** with the measurement
+that refutes them.
+
+### The detector set is wired; it is not yet shown to have teeth
+
+Of the 40 rules carrying both fixture legs, **2** have a negative fixture that is
+the positive fixture with the defect removed. The other **38** are a different
+program. Leashed at the true floor of 2, so it fails on a rule _regressing_ out of
+that set and not on the 38 that were always like this. Closing the gap needs a
+per-rule recipe for what the defect _is_; that work is named, not assumed away.
+
+### .NET runs are evidence (ADR 0015)
+
+`EVIDENCE_CONVENTIONS` held four entries and .NET was in none of them, so a C#/F#
+run left every finding at `INFERRED` however often the suite actually ran. TRX is
+now dispatched **before** JUnit, and that ordering is load-bearing: the JUnit
+branch is reached by an `<?xml` sniff, so a TRX file was matching nothing and
+returning an empty run — which reads as "the suite passed", and for a .NET project
+whose tests were never examined was the most reassuring possible wrong answer.
+
+### Release honesty
+
+`candidate:readiness` remains **NO_GO** on this release. Four of its ten blockers
+are `REMOTE_PROVEN` attestations about the real world — protected holdout,
+real-world repositories, platform matrix, consumer install, remote workflow —
+plus external validation and owner authorization.
+
+The check RAN and was RECORDED as unsatisfied. It was not treated as blocking
+because `vars.STABLE_RELEASE_AUTHORIZED` is `true`: a decision someone made and
+wrote down, not a check that passed.
+
 ## [Unreleased]
 
+### Two core rules, measured: QA-PW-117 and QA-JV-101 - `ANTI-CREEP-EXCEPTION`
+
+Law 1 requires an equal-size removal for every addition to the governed set.
+This is an addition of **two** with nothing to remove, because the governed set
+held **zero** core rules until now. The exception is recorded rather than the
+baseline being edited, because `previousBaselineCore` is `0` on purpose: lowering
+`baselineCore` to match the grown tier would make the growth read as zero and
+switch the law off in one uncross-checked JSON edit.
+
+The reason is that both are **measured** promotions, not declared ones.
+`QA-PW-117` reached n=35 and `QA-JV-101` reached n=35, both with zero observed
+false positives and a Wilson upper bound of **9.89%** against the 10% ceiling,
+both adjudicated row by row against pinned source, and both found by a
+corpus-wide `--core-candidates` sweep rather than by any global cap raise.
+`measurementTier` returns `core` for each on its own evidence and
+`declaredCoreWithoutEvidence` is null, so each declaration records a decision the
+measurement had already reached.
+
+Both had been demoted from core in 6.0 for exactly this reason, and
+`src/rules/tier-evidence.ts` ranked `QA-PW-117` first among the nineteen most
+likely to clear on a re-sample.
+
+### The tree told a different story than the code
+
+Both core promotions landed in code, in the tier evidence and in this file,
+while their generated documentation went on reporting `extended` at n=23 and
+n=24. Nothing failed: `npm run check` regenerates and then inspects nothing,
+so a generator that rewrites a committed file leaves the tree green by
+construction. Four workflows each asserted staleness by hand and three of them
+could not see an untracked file at all.
+
+- **`docs/rules/QA-JV-101.md`, `docs/rules/QA-PW-117.md` and
+  `docs/DEPTH-ADJUDICATION.md` regenerated.** The shipped rule pages claimed
+  `extended` at n=23/24; both rules are `core` at n=35. No finding changes.
+- **`npm run docs:staleness` — one staleness assertion, and it can run locally.**
+  It reads `git status`, so it sees an untracked generated page; `git diff`
+  alone cannot, which is how a new rule's docs page shipped silently through
+  `corpus-audit.yml`, `release.yml` and `stable-release.yml`. Read-only by
+  construction — it cannot cost a working tree the adjudication records under
+  `tests/corpus/verdicts/`, and it is deliberately absent from `npm run check`,
+  where asserting after regenerating would be checking the generator against
+  itself. All four workflows now call it, and
+  `tests/contract/generated-surfaces.spec.ts` fails if a fifth is added that
+  does not, or if the copies drift apart again.
+- **`core` is a generated number, not a sentence.** `README.md` said "`core`
+  is empty" for a whole release after two rules had earned it. `measurementBlock()`
+  now returns `core` and `docs:counts` stamps it into `README.md`,
+  `docs/MEASUREMENT-CLOSEOUT.md` and the other census surfaces, so
+  `tests/contract/census-drift.spec.ts` fails if prose and registry disagree.
+  It counts UNMEASURED core rules deliberately: `MAX_UNMEASURED_CORE = 0`
+  means such a registry cannot ship, and a census that hid the rule behind
+  `measured` would report a clean `core: 0` at the moment the law broke.
+- **`docs/MEASUREMENT-CLOSEOUT.md` corrected to 73/6** (it read 74/5), gained
+  the missing `QA-PY-004` row, and now separates **stale** from unmeasured:
+  `QA-PY-004` (revision 4) and `QA-PY-007` (revision 5) have verdict sets that
+  no longer describe the shipped detector, so they need re-measurement at the
+  current revision rather than new classification.
+- **`src/rules/java/qa-jv-101-disabled-test.ts` — one provenance block.** The
+  file carried three stacked comments, two of them obsolete demotion notices
+  contradicting the third. It now records the two-batch arithmetic
+  (n=32 → 34 → 35) and names both verdict files, because the first batch
+  (`jv-101-final.json`, "STILL SHORT") reads as a refusal on its own and the
+  second (`jv-101-core.json`) is what cleared the ceiling.
+- **Governing prose that had gone stale.** `rule-author` and `surface-law`
+  both asserted the core tier was empty; the archived
+  `QA-FINAL-RELEASE/RULE_CERTIFICATION.md` carries a SUPERSEDED banner marking
+  its `core` column a fossil of the deleted `registry-census` predicate. The
+  ADR and the roadmap's "23 pending classifications" were left alone: they
+  record what a decision or a pass actually was, and editing them to match
+  today would falsify the record.
+
+### The detector set is wired. It is not yet shown to have teeth.
+
+`docs/PRECISION-RATCHET.json` records 32 rules as holding a PRECISION leg and
+says plainly that this is "a wiring proof, not an accuracy proof, and a
+self-derived one". That caveat can be given a number, and the number is not
+comfortable.
+
+A must-not-fire fixture is only evidence that a rule is _sensitive_ when it is
+the must-fire fixture with the defect neutralised. When it is a different
+program that merely does not trigger, the pair shows the detector is
+directional and says nothing about the predicate. The quad counts presence, so
+both look identical to it.
+
+- **`docs/SENSITIVITY-RATCHET.json` — the SENSITIVITY arm of
+  `check-fixture-quad`.** Of the 40 live rules carrying both fixture legs, **2**
+  hold a negative fixture that is plausibly the positive fixture with the defect
+  removed (`QA-PW-144`, one changed line of nine; `QA-PW-116`, one of seven).
+  The other **38** are a different program — the next nearest is 0.55 diverging
+  and the furthest diverge by more lines than either file contains, because a
+  hand-written neutral fixture also renames the class and rewrites the bodies.
+  `QA-JV-101`, a core rule, is one of them: its negative fixture is a different
+  class with different methods and no case distinguishing a disabled test from
+  a justified one.
+- **Leashed at the true count, in an existing gate.** No new gate id and no new
+  npm script, so Law 0 is untouched: the arm is folded into
+  `check-fixture-quad` beside PRECISION, which asks a different question and
+  reports separately. The floor is 2, the honest number, so the gate fails on a
+  rule _regressing_ out of the mutant set or on a new rule shipping without one,
+  and does not go red on the 38 that were always like this. `--update` only ever
+  raises the floor, so a regression can never be absorbed by re-running a command.
+- **Neither core rule is exempt.** The ratchet names the gap rather than
+  narrowing it: closing it needs a per-rule recipe for what the defect _is_, so
+  the mutant can be generated rather than hand-written a second time and left to
+  drift. That is the remaining work, and it is now named rather than assumed
+  away.
+- **`docs:staleness` no longer watches provenance-stamped artifacts.** Their
+  `baseSha` is meant to lag, and `git status` cannot tell a restamp from real
+  drift, so watching them produced FAIL on every regeneration and caught nothing
+  that matters. `docs:provenance-drift` already checks their content with the
+  provenance keys excluded; leaving them there would have been a second copy
+  doing the same job worse.
+
+### A promotion can no longer land with no artifact
+
+Both core promotions reached the registry, the tier evidence and this file while
+their generated documentation went on reporting `extended` at n=23 and n=24.
+Nothing failed, because nothing asked. The mechanism that should have caught it
+now exists, and it catches the case that matters: not "is this rule measurable"
+but "did a person certify **this** measurement, and does the certification still
+describe the rule".
+
+- **`docs/CORE-CERTIFICATION.json` — a record is required to hold `core`.** A
+  rule with no record fails; a record for a rule that lost the tier fails, because
+  a demotion belongs in the tier evidence ledger, not in a certification file.
+- **The record expires with its evidence, which is the entire design.** The
+  measurement block is compared field by field against the live `MEASURED_FP`
+  row on every run. Move the detector revision, change n, or introduce an
+  observed false positive and the gate fails until someone re-certifies and
+  writes down why. It cannot outlive what it certifies.
+- **The cited evidence must account for the sample.** Every path a record cites
+  must exist in the tree, and the corpus verdict rows it lists must sum to
+  exactly `n`. A certification may not rest on evidence that is not here, nor on
+  less evidence than it claims. Proven in both directions: a record citing 33
+  rows for an `n=35` measurement fails.
+- **Self-derived evidence is excluded on purpose.** The quad verdicts under
+  `tests/corpus/verdicts/quad/` are wiring proofs and do not count. Only corpus
+  rows do — which is why both records sum to exactly 35 (29+2+4 and 20+10+2+3).
+- **`QA-JV-101`'s record states its known weakness rather than omitting it.** Its
+  must-not-fire fixture is a hand-written different program, not the must-fire
+  fixture with `@Disabled` neutralised, so per `docs/SENSITIVITY-RATCHET.json` it
+  does not prove the predicate is sensitive to the annotation. That is the gap
+  per-rule defect recipes must close, and a certification record that omitted it
+  would be worse than no record.
+- **No new gate, no new npm script.** This is an arm of `rules:promotion:check`,
+  which is already the promotion gate and already in `gates:claim-integrity`. Law
+  0 charges for both, and extending the existing gate is free where a sibling
+  would not be. Deliberately not given its own unit test either, for the reason
+  `src/rules/conformity.ts` already states about a duplicate check.
+
+### The delta loop is now visible, and the freeze is written down
+
+- **Quickstart documents baseline → delta.** Steps 1–3 report the **state** of
+  your tests; `mjolnir ci verify` reports the **change**, which is the only
+  question a reviewer has about a diff. `--save-baseline` writes
+  `.mjolnir/baseline.json`, `ci verify` reports RESOLVED (of which only
+  `VERIFIED-RESOLVED` is a fix claim) and NEW, and the `0`/`1`/`2` exit contract
+  is stated. It also says why `mjolnir ci install` does not add it: `ci verify`
+  exits `2` until a baseline exists, which would redden every install on day
+  one. Agents were already taught this at `src/commands/install-agents.ts:58`;
+  humans were not taught it anywhere.
+- **`docs/ENGINE-FREEZE.md` — what a consumer may rely on.** The source of truth
+  is `CONTRACT_REGISTRY` in `src/engine/contract-versions.ts`; the document
+  deliberately copies no version numbers, for the same reason the census
+  sentinels exist. It explains each `compatibilityPolicy`, records that
+  `scoringModelVersion` 2.0.0 is a _semantic_ change (ADR 0014's evidence floor)
+  so a consumer comparing scores across it is comparing different things, and is
+  honest that `frameworkSupportMatrixVersion` is written by the engine and read
+  by nothing but a test — a version stamp on a fact, not a negotiated protocol.
+
+### Verification and enforcement overhaul
+
+Track A of the verification-enforcement plan: the checks that could fail but
+never ran, the readouts that disagreed with each other, and the two places where
+a claim was made without a mechanism behind it. Nothing here changes what a
+finding says except where stated (core tier, scoring model).
+
+#### Added
+
+- **`docs/PRECISION-RATCHET.json` — the PRECISION arm.** `check-fixture-quad`
+  failed only on an over-claim (a capability advertising M3 without its four
+  fixture legs). It had no arm for the leg that a fixture directory cannot
+  satisfy: PRECISION needs someone to have classified the detector _silent_ on a
+  real input. `npm run check-fixture-quad -- --update-precision` records the
+  count of live rules holding a classified TN verdict; the gate fails below the
+  recorded floor. **Recorded at 32, not 0** — 32 rules already hold a TN leg
+  from the generated `--verdicts` pass, so a floor of 0 would have been
+  decoration. The ratchet note says plainly that these are scanner-executed
+  fixture legs: a _wiring_ proof, not an accuracy proof.
+- **`docs/HOLDOUT-SPLIT.json` + `npm run holdout:split`** — the deterministic
+  partition of corpus repositories into measurement and holdout that
+  `claim-registry.json` blocked `rule-registry-census` on. The unit is the
+  repository, never the row (a per-row split puts the same test in both halves
+  and can be searched until the halves agree); the assignment is a salted hash
+  of the repository id, not a list; and the single exclusion — repositories
+  holding rows for an `isCoreCandidate` rule — is _derived_ from that predicate
+  rather than declared, so it moves with the candidate set and cannot be edited
+  into place. The holdout **validates, it does not gate**: core promotion reads
+  the measurement partition, because a gating holdout would be sized by the
+  corpus rather than by the question.
+- **`docs/QUARANTINE-OWNERSHIP.json` — the quarantine exit ramp.** 34 rules were
+  quarantined with no disposition recorded for any of them; `checkQuarantineOwnership`
+  _reported_ that count and explained that a cap "would have to start at 34".
+  The defect was not the number, it was that silence passed. A quarantined rule
+  must now carry either a `quarantinePromotion` or a typed disposition with an
+  owner, a rationale and a review date, and doctor **fails on silence**.
+  Dispositions are derived from the Wilson interval: 26 `pending-samples`,
+  3 `pending-measurement`, 4 `pending-remeasure` (a rework shipped and the
+  verdict predates it), 1 `structural` (QA-TEST-003, whose proposed fix was
+  implemented, measured, and rejected).
+- **`RETRACT` in `corpus:apply-verdicts`, and `--verdicts-dir=`.** The orphan
+  rule in `tests/corpus/verdicts/README.md` said an orphaned row "must be
+  removed" and there was no mechanism for it — only a tool that fills blanks.
+  A verdict recorded on a row whose finding is not there is worse than a stray
+  row, because it becomes evidence. `RETRACT` removes a blank row and records
+  nothing, and **refuses** a row that already carries a verdict. The
+  `--verdicts-dir` flag exists because the retraction path was otherwise
+  untestable without writing into the live corpus mid-run.
+- **`mjolnir doctor` runs from an installed package.** It defaulted its target
+  to `process.cwd()`, so a user who installed the CLI and ran `doctor` in their
+  own project got `No fixtures directory … Run from the mjolnir repo root.` — a
+  self-audit reachable only from the source tree. With no target it now resolves
+  the installed package from `import.meta.url`. `package.json#files` ships what
+  the self-audit reads (`tests/fixtures`, `tests/corpus/verdicts`,
+  `src/rules`, the two baseline JSONs, CHANGELOG) — without `src/rules` the
+  installed audit is INCONCLUSIVE on detector identity. Verified by packing a
+  tarball, installing it into a fresh project and running the published binary.
+- **Doctor check `core-floor-declaration`.** The interlock that makes the core
+  floor safe to ship: a core rule may not declare `evidenceLevel: "E0"` in its own
+  metadata. `checkEvidenceHonesty` cannot catch it and the gap is structural —
+  it fails a rule for claiming _more_ than its `findingType` supports, and E0 is
+  the bottom of the ladder.
+- **`tests/corpus/verdicts/proposed/`** — the staging area for adjudications
+  awaiting ratification. Committed verdicts are immutable
+  (`tests/corpus/verdicts/README.md:191`), so staging is the only reversible
+  form.
+
+#### Changed
+
+- **The core tier carries a floor** (ADR 0014). `capForTier` becomes
+  `policyForTier`; core gains `CORE_FLOOR = { evidenceLevel: "E1" }`. Until this,
+  core and extended were enforced _identically_ — `capForTier` returned `null`
+  for every non-quarantine tier, so reaching core changed the dedup tie-break,
+  the M3 ceiling and the census readout, and nothing a scan consumer could see.
+  `E1` and not `E2`: E2 is a claim that a finding is _proven_, which is what
+  runtime corroboration asserts per finding, not what a tier policy may.
+  Severity is deliberately untouched — one bounded field, changed on purpose,
+  two is a rewrite.
+- **`SCORING_MODEL_VERSION` 1.0.0 → 2.0.0.** A core finding's deduction moves
+  from 0 (E0) to `floor(base/2)` (E1). `semver + ADR required` per the entry's
+  own policy. **`TRUST_MODEL_VERSION` stays at `1.0.0`** and ADR 0014 states why
+  rather than leaving it implicit: `deriveTrustLevel` _does_ consume
+  `evidenceLevel`, but the E→L mapping is unchanged — what moved is the
+  distribution of inputs, and a consumer reading `evidenceLevel` sees the same
+  fact. Bumping both would teach the version that "something moved".
+- **An absent tier is no longer treated as core.** `policyForTier(undefined)`
+  returns an empty policy. `buildUniversalRules` resolves every _registry_ rule
+  through `effectiveTier` and adds a plugin only when it declares a tier, so a
+  missing entry means "a third-party rule that claimed nothing". The old
+  docstring said "undefined tier = core"; with a floor that would have raised
+  every plugin's E0 finding to E1 and started charging third-party detections —
+  the trust escalation TI-013 exists to prevent, introduced by the ADR written
+  to close a trust gap.
+- **`npm run rules:quality:check` is a claim-integrity leaf.** It was declared
+  as the nightly gate `gate:rule-quality` and wired to nothing, so the gate ran
+  on a schedule that never reached it.
+- **`check-fixture-quad` writes `docs/FIXTURE-QUAD.json` by default.** It wrote
+  only under `--write`, and nothing in this repository passes `--write`, so the
+  gate printed a census to a terminal nobody reads and left no artifact — a
+  backfill in progress was invisible in a diff. `--check` verifies the committed
+  artifact instead.
+- **The measured/unmeasured census is 73/6, not 74/5.** Six documents asserted
+  74/5. Note the trap: 74 is _also_ the number of rules declaring a tier
+  explicitly (79 − 5 omitted), so "74" was accidentally right about a different
+  population.
+
+#### Fixed
+
+- **`src/rules/registry-census.ts` answered `stale` and `tier` with local
+  predicates, and both were wrong.** `stale` asked `MEASURED_FP[rule.id] !==
+undefined` about a map the generator pre-filters to revision-matching rows, so
+  it was false for every stale rule and `staleCount` was structurally 0. `tier`
+  re-derived the ladder as `declared ?? (measured ? core : extended)` — a third
+  copy of the tier resolution and the only one not reading `effectiveTier` — so
+  the five rules with no declared tier printed `core` here and `extended`
+  everywhere else. A census that disagrees with doctor is not a census.
+- **`scripts/v6/check-rule-quality.ts` had the mirror defect.** Its `stale` loop
+  re-derived from the revision-filtered map, so a stale row was never in it and
+  `measuredAtStaleRevision` read **0** while two rules (`QA-PY-004`, `QA-PY-007`)
+  carried hand-classified verdicts taken against an earlier detector. It now
+  reads **2**, and the registry skeleton agrees with the census at 73/6.
+- **`checkQuarantineOwnership`, `checkAntiCreep` and the disposition read all
+  resolved files from `process.cwd()`.** With `doctor` reachable with no target,
+  CWD is wherever the user happened to be — their project, not the checkout — so
+  the audit read the wrong CHANGELOG and the wrong baseline. All three now take
+  the checkout root as an explicit parameter.
+
+#### Not changed, and why
+
+- **Retired-rule fixture directories were not deleted.** The plan called for
+  removing `tests/corpus/positive-fixtures/QA-PW-145/` and
+  `tests/corpus/negative-fixtures/QA-PY-102/`. That contradicts a binding owner
+  ruling (`docs/RULE-LIFECYCLE.md:193-196`, 2026-09-08, E-1): _"fixture dirs
+  stay on disk (the doctor's fixture-integrity check discloses them instead of
+  failing)"_, implemented at `src/commands/doctor.ts:1136-1139`. The directories
+  and the exemption stand; the ruling is recorded, not overruled.
+- **No core rule was promoted.** See below.
+- **`claim-registry.json` claim 2 stays BLOCKED.** `candidateSha` is `null`, and
+  the checker refuses a non-BLOCKED claim on an unproven candidate, so the
+  artifact/digest/authority the plan asked for could not be recorded without
+  asserting independence nobody observed. The blocker is narrowed to what is
+  actually missing: the split exists, but no holdout _evaluation_ has been run
+  against it, and it is still produced by this repository.
+
+### Adjudication: 23 rows, 6 orphans, and the FIRST defect in the sampler
+
+Every row was read at the corpus's pinned commit (`keycloak @ 421c23f5221d`,
+`playwright-java @ c17b6060bd39`, `sveltejs-kit @ bf6833a639c9`), and each cited
+line independently re-verified by enumerating every `@Ignore`/`@Disabled` /
+`test.describe.serial` in the pinned file rather than trusting the ±6-line window.
+
+**Six rows were orphans and were removed rather than judged** — and finding them
+turned up a defect that made orphans inevitable:
+
+> **`scripts/corpus-sample.ts` cloned the default branch and ignored `repo.ref`.**
+> It ran `git clone --depth 1 <url>` — HEAD — then `rm -rf .git`, so nothing
+> downstream could tell. Every verdict is adjudicated against the _pinned_ commit
+> via `npm run corpus:verdict-context`. Those are two trees, and they drift.
+>
+> On keycloak that produced a repeating phantom: the pinned `JWETest.java` has
+> exactly three `@Ignore`, on lines 73, 113 and 202, all three already adjudicated
+> `TP` — and the sweep kept emitting rows citing **74, then 114, then 203**, the
+> same three annotations cited one line late, each arriving as a fresh
+> unclassified row that looked like new evidence.
+>
+> Four of those were caught by hand during the first adjudication pass. That was
+> luck, not a control: a row whose drifted line happened to still land on a
+> trigger would have been judged against source the verdict claims to describe and
+> does not. `cloneRepo` now fetches `repo.ref` the way `tests/corpus/audit.ts`
+> always did, **verifies** the checked-out SHA and hard-stops on a mismatch, and a
+> cached clone is verified rather than trusted by existence.
+
+Retracting a row also proved non-durable: `corpus-sample.ts` de-dupes on the
+`ruleId|file|line` keys present in a `.jsonl`, so the instant an orphan was
+removed the next sweep re-found and re-appended it. `apply-verdicts` now writes
+**tombstones** to `tests/corpus/verdicts/retracted.jsonl` and the sampler reads
+them alongside the verdicts — because an orphan rule that regenerates its own
+evidence is not an orphan rule. The generator and its spec then needed the same
+exclusion, since a tombstone has no `file`/`line` and parses as a verdict with
+`undefined` fields.
+
+**The two rules that earned core, and how:**
+
+| Rule        |           n |             ciHigh | the last row                                                                                 |
+| ----------- | ----------: | -----------------: | -------------------------------------------------------------------------------------------- |
+| `QA-PW-117` | 24 → **35** | 13.80% → **9.89%** | sveltejs-kit `test.describe.serial('Errors')` — six tests, each its own URL, no shared state |
+| `QA-JV-101` | 23 → **35** | 14.31% → **9.89%** | keycloak `@Disabled("Only for PUT/POST")` on an **empty-bodied** override                    |
+
+Both cleared by the same arithmetic — `z²/(n+z²)` ≤ 10% first holds at n=35 — and
+both were funded by a corpus-wide `--core-candidates` sweep rather than by any
+global cap raise. The `QA-JV-101` row is the purest instance of the rule's
+diagnosis in the whole corpus: a disabled test with **no assertions** cannot hide
+a defect, because it could not have detected one.
+
+Neither sweep was unbounded: `CORE_CANDIDATE_CAP` stayed at 35 and the cap was not
+raised to chase a number. `QA-JV-101`'s file carries two further
+`@Disabled("Only for PUT/POST")` overrides at `:107` and `:113` that remain
+**unfunded and unclassified**, because at n=35 the budget is zero. That is the cap
+doing its job, not an oversight.
+
+A third core rule now needs no hand record: `conformity`'s `CLAIM_OWNED` accepts a
+claim the measurement derives independently, which is what `checkRegistry` and
+`declaredCoreWithoutEvidence` already did. `QA-JV-101`'s entry in the 6.0 demotion
+table also carried a justification describing a _different_ rule's premise
+("static mutable shared across tests"); it is gone with the entry, and the
+remaining eighteen are unaudited — named here as a finding, not fixed.
+
+### Adjudication of the 23 sampled rows — staged, then applied
+
+Every row was read at the corpus's pinned commit (`keycloak @ 421c23f5221d`),
+following the convention the already-committed rows in the same file establish.
+**19 rows are adjudicable; 4 are orphaned and are removed rather than judged.**
+
+Three of the orphans are `QA-JV-101` rows citing `JWETest.java:74`, `:114` and
+`:203`, where the `@Ignore` is on line 73/113/202 — the same annotations already
+adjudicated `TP` one line up. A verdict on any of them would have counted one
+annotation twice and moved a rule's `n` on the strength of a finding that is not
+at that line. The fourth is `QA-PW-117` citing `details.spec.ts:20`, a
+`const clientId = …` line with no `test.describe.serial` on or beside it; the
+serial block at `:16` is already adjudicated.
+
+### Added: a Conformity Monkey for the rule registry
+
+Netflix's Simian Army does not decide what a good cloud is. It applies a set of
+**declared** rules to every resource, marks the ones that do not conform, records
+which rule broke on which resource, and notifies the owner. Three properties make
+it work, and this gate reproduces all three:
+
+- the human is **not in the detection loop** — a machine decides, every run, for
+  every rule;
+- the human **is in the response loop** — a nonconformity is fixed, or explicitly
+  opted out, and the opt-out is recorded;
+- **`leashed`** runs every check, writes the report and sends nothing. That is
+  the mode a new check ships in; arming is a separate, deliberate act.
+
+`npm run conformity` (`scripts/check-conformity.ts`) computes four checks per
+rule, all decidable by the tree — **no judgement, and therefore no queue**:
+
+| Check              | Question                                                               |
+| ------------------ | ---------------------------------------------------------------------- |
+| `MEASURED`         | does a current measurement exist?                                      |
+| `DETECTOR_CURRENT` | was it taken at the detector revision that produced the finding?       |
+| `CLAIM_OWNED`      | does a core/quarantine claim carry an owner and an unexpired date?     |
+| `QUAD_COMPLETE`    | do all four fixture legs exist? (RECALL and PRECISION are _generated_) |
+
+**What it found: 17 of 79 rules are clean.** 62 fail at least one check, and the
+sharpest one is about a field in this repository's own registry:
+
+> `quarantinePromotion` carries the docstring "a rule in quarantine WITHOUT one is
+> a rule whose quarantine is permanent by default, which is the outcome the tier
+> exists to avoid" — and **0 of 34** quarantined rules have one.
+
+Also: 2 rules carry a false-positive rate measured against an **earlier detector
+revision**, displayed everywhere as if current; 6 have never been measured at all;
+21 have an incomplete quad; 39 have no MUST-FIRE or MUST-NOT-FIRE fixture.
+
+### Added: the opt-out registry as a ratchet, not a gate that is red forever
+
+`docs/conformity-opt-outs.json` records every known nonconformity with a named
+owner, a reason a reader can check, and **a date it lapses**. The gate fails on a
+nonconformity with no entry, on an entry whose date has passed, and on an entry
+for a rule that now conforms — so the set can only shrink, and known debt decays
+on a schedule instead of persisting because nobody re-looked at it.
+
+This is why it is a ratchet and not a plain gate. A gate that went red on all 62
+rules on day one would stay red and read as noise — which is how raising
+`MAX_SAMPLES_PER_RULE` produced **1,121 unadjudicated rows nobody looked at**.
+Adding an opt-out is the only way to make the gate green for a known defect, and
+an added entry is a **smaller diff than the evidence that would retire it**. That
+asymmetry is the enforcement.
+
+Expiry is the engine: 34 entries lapse **2026-11-01** and 28 lapse **2026-12-01**.
+Nothing in the corpus opinion-measurement chain does, which is why the 23 pending
+adjudications were debt with no date.
+
+### Why this does not replace the corpus false-positive rate
+
+That measurement asks a human "is this code legitimate?", which is the one
+question no tree can answer. Deriving it from the detector's own declaration
+would be circular — the detector fired, so the detector is right, so every rule's
+rate is zero — and that is the shape GAP-M26-002 records: "a 429-row ledger with
+zero judgement got certified against its own output". This gate checks what the
+tree CAN answer; the opinion stays where it was.
+
+### Fixed: an unreachable state, found by the gate that shipped it
+
+The first version of `src/rules/conformity.ts` modelled "unmeasured" as a third
+state beside CONFORMING and NONCONFORMING. The gate printed `unproven: 0` on its
+first run — the state was **unreachable**, because every unmeasured rule here also
+fails something else and so read NONCONFORMING. A law that can never fire is not a
+law, and `registry-ratchet.spec.ts` already says that about its own floor.
+`unmeasured` is now an orthogonal flag beside the state, and reports 6.
+
+`--opt-outs=`/`--report=`/`--today=` exist because the tests need them, and each
+one is a place the gate could have been right for the wrong reason: the first
+fixture attempt copied the module graph behind `src/rules/index.ts` into a temp
+tree and died in the ESM resolver before reading a single rule.
+
+**Verified by planting each defect in the real registry before writing any of
+this**: a lapsed date reported 34 gaps, a deleted entry reported one UNRECORDED,
+and an entry added to a conforming rule reported one STALE. Each reverted to
+`gaps: 0`. 20 arms in `tests/contract/conformity-gate.spec.ts` keep that.
+
+One new npm script (`conformity`) and one new leaf in `gates:claim-integrity`.
+`entry-points:check` still reports 9 commands against a ceiling of 12.
+
+### Changed: the unclassified-backlog assertion is a two-sided ratchet, not a zero
+
+`tests/contract/verdict-context.spec.ts` asserted **zero** unclassified verdict
+rows, and 23 pending rows make that false for as long as the work takes — so the
+assertion would have been red for the entire classification window.
+
+It now asserts the live backlog **equals the figure `unclassified-ceiling.json`
+records**: greater means the backlog grew without review, less-but-not-zero means
+classification is half done and the commit captures a state nobody agreed to.
+`generate-fp-audit-table` already enforces the same ceiling per FILE, so a second
+file's first row cannot hide inside a generous total — which is why the assertion
+here is on the total and the generator's is on the parts.
+
+The count this file asserted before that was 28, and it existed so the number
+could not go quietly stale. It has been replaced by an assertion that cannot go
+stale in either direction, which is what it was for.
+
+### Added: a fourth naming contract — a relative link that resolves to nothing
+
+`check-cli-contract` now fails when a live markdown document links to a file that
+does not exist. A link is a name, and it was the only kind of name none of the
+three existing contracts could see: the removed-verb pass looks for verbs, the
+reference pass looks for `npm run`, and a link to a document deleted two releases
+ago looks like neither.
+
+Its five live instances were all real:
+
+| Document                          | Target                         | Now                             |
+| --------------------------------- | ------------------------------ | ------------------------------- |
+| `docs/PRODUCT-DECISIONS.md` (D-9) | `EXTERNAL-EVIDENCE-REQUEST.md` | reworded; points at the runbook |
+| `docs/RELEASE-PATH-RUNBOOK.md`    | `EXTERNAL-EVIDENCE-REQUEST.md` | reworded; names the retirement  |
+| `assets/brand/README.md`          | `src/reporter/score-state.ts`  | `presentation.ts`               |
+| `docs/design/BRAND-SYSTEM.md`     | `src/reporter/score-state.ts`  | `presentation.ts`               |
+| `docs/MAINTAINERS.md`             | `CONTRIBUTING.md#governance`   | `../CONTRIBUTING.md#governance` |
+
+`isLiveSurface` is reused verbatim rather than reimplemented, so archives,
+captured artefacts, frozen reports, preserved rule docs, `docs/adr/` and `tests/`
+keep the exemptions they already had. A second exemption list would be a second
+thing to drift from the first, and the drift shows up as a file protected from
+one contract and not the other — exactly how
+`docs/RELEASE-3.0.0-READINESS.md` came to be exempt from one and not the other.
+
+Scope is markdown, inline links and images, path resolved and anchor not, on
+measurements rather than guesses: a link-reference definition whose value is
+itself a link (`[^pit]: PIT, [PIT](https://pitest.org)`) is a footnote, and
+guessing produced **30 false positives in one research document** on the first
+attempt. Fenced blocks and inline code spans are blanked because documentation
+about markdown contains markdown. An extensionless target also resolves as
+`<target>.md`, which is the site's clean-URL convention. 239 links are checked.
+
+15 arms in `tests/contract/cli-contract-dangling-links.spec.ts`, each inherited
+exemption asserted as an exemption. One of them was written backwards: I assumed
+the pass excluded `docs/adr/` and it does — which is why ADR 0012's dangling link
+had to be found by hand. The arm now records that.
+
+**Not fixed, and named:** `scripts/check-external-evidence.ts` still reads
+`docs/EXTERNAL-EVIDENCE-REQUEST.md`, which the 6.0 M26-M50 retirement deleted, so
+`npm run docs:external-evidence` exits 2 and `npm run certify:integrity` cannot
+complete. Its `EXTERNAL_BOX_CEILING = 39` is a number about a file that no longer
+exists, and lowering it to the 18 rows the runbook actually carries would be a
+recorded number lowered to make a gate pass. D-9 now says so in the document
+instead of continuing to cite a deleted file as the authority for it.
+
+### Added: every workflow step's file argument resolves
+
+`workflow:scripts` answers "does this NAME resolve". The other half of a step is
+"does this FILE resolve", and `.github/workflows/ci.yml` shipped a step naming
+`scripts/diff-detector-hashes.ts` — a file that has never existed. The capability
+was present throughout (`scripts/check-detector-hashes.ts` documents
+`--base <manifest>`) and the step has been corrected to name it, but a corrected
+line is not an invariant and nothing said so. **11 file arguments across 21
+workflows now resolve**, against the same `working-directory` resolution and the
+same `EXEMPT_FROM_SCRIPT_CHECK` list the name check uses.
+
+Verified on the real tree before it was codified: plant the typo in `ci.yml`, the
+gate reports the file and the job, revert, the gate passes. 8 arms in
+`tests/contract/workflow-scripts.spec.ts` keep that.
+
+Two scope decisions are load-bearing. A token counts as a file only when it is a
+bare relative path with a code extension after an interpreter — otherwise
+`./actionlint`, which the previous step downloads, would be reported missing on
+every run forever, and the fix would be an exemption. And `dist/` is a **build
+output**, not a repository file: `node dist/cli.mjs` is how six workflows invoke
+the CLI, so checking it would make this gate red on a clean checkout before
+`npm run build` — which is what `npm run certify:fast` and a bare
+`npm run workflow:scripts` see.
+
+### Fixed: the surface scan counted every document under `docs/` twice
+
+`check-cli-contract` walked `"", "docs", "site", ".github/workflows"`, and
+`walk("")` is a walk of the repository root that already descends into the other
+three. Every file under `docs/` and `site/` was read twice and reported twice, so
+the printed `surfacesScanned` overstated the surface the gate checks.
+
+### Added: ADR 0013, and a kill criterion that is not only a command count
+
+`docs/adr/0013-the-core-ceiling-is-decided.md` records what two independently
+chosen constants implied and nobody decided. `src/rules/measurement.ts` carried a
+docstring reading `!! UNREACHABLE AT THE CURRENT CORPUS CAP` — arithmetically
+correct, and a product decision written as a property of the code. It said _don't
+bother_ where it should have said _this is unresolved_.
+
+The ADR holds the ceiling at 10%, keeps `MAX_SAMPLES_PER_RULE` at 20, and gives
+funded candidates the cap the arithmetic requires. It also records what it does
+**not** decide: re-homing the 39 external-evidence boxes, and anything a core rule
+might need beyond the quad and the interval.
+
+`docs/ROADMAP.yaml`'s 6.0 kill criterion said `npm run check` must fit in 12
+commands. A command count is necessary and not sufficient — the tier system has
+to have a reachable top, or the cut only removed the words. It now says so, names
+the arithmetic, and points at the ADR.
+
+### Added: `--core-candidates`, a sampling mode that spends the budget where it can be spent
+
+The core ceiling is 10% on the Wilson upper bound, so a rule earns core at
+**n ≥ 35 with zero observed false positives** (`samplesForZeroFp`). The corpus
+sampler capped at 20, so the tier was unreachable — and 6.0 found out the
+expensive way that raising the cap globally does not fix that: a raise to 40
+produced **1,121 unadjudicated rows across 42 rules** and
+`unclassified-ceiling.json` refused them, correctly.
+
+The global raise was the wrong ALLOCATION, not the wrong idea. It spends 35+
+samples on rules that cannot use them — a rule already observed wrong, or one
+whose interval already excludes 10% from below — while the adjudication budget is
+finite and belongs to a person.
+
+- `--core-candidates` emits rows **only** for a rule that observes zero false
+  positives and whose `straddleDetail` reports that more clean samples would
+  settle it, and only those rules may draw up to 35 instead of 20. The predicate
+  is derived from the live registry on every run
+  (`scripts/lib/core-candidates.ts`), so a rule crossing the line stops being
+  sampled without an edit.
+- `--core-target <RULE-ID>` (repeatable) says which candidates this pass
+  **funds**. The predicate is worth **29 rules** today; the nearest two are 11 and
+  12 rows from the ceiling. Conflating "who can earn a tier" with "who gets
+  funded this pass" would move the ceiling by an amount nobody decided, so the
+  two are separate and naming a rule that is not a candidate is an error rather
+  than a silent no-op.
+
+Filtering is on **emission**, not only on the cap. A cap-only change would still
+emit rows for every rule below n=20 — the 1,121-row failure with a different
+number on it.
+
+No npm script, CLI verb, gate or rule was added.
+
+### Fixed: three defects the first real `--core-target` run found
+
+- **The mode asked for twice the work it promised.** `tests/corpus/verdicts/unclassified-ceiling.json`
+  moves by the number of rows a person is shown _before_ they are asked to
+  classify anything, so that number has to be exact. The first run collected 35
+  samples per rule and appended **46** rows against a projection of 23, because
+  de-duplication is per verdict FILE and keycloak's file already held 19
+  `QA-PW-117` and 10 `QA-JV-101` rows. The budget is now on **rows**, not
+  samples — `cap − classified − already pending` — computed against the same key
+  set the writer de-dupes with, by one shared function. Re-running the identical
+  command now adds **0** rows, which is the property that stops a scoped pass
+  from silently exceeding the ceiling twice.
+- **A scoped run deleted the review sheets it claimed to preserve.**
+  `writeReviewSheets` carried a comment describing exactly this protection while
+  the condition underneath did the opposite: `!sampledRules.has(id)` is true for
+  every rule a `--repo` or `--core-candidates` run did not visit. A one-repo
+  targeted pass deleted 8 committed sheets (`QA-PY-002/003/004/007/009/011/012`
+  and one more) of pending owner work. Sheets are now removed only for rules that
+  are no longer live; a rule that was visited and sampled nothing still removes
+  its own sheet, because "the queue is empty" is a different statement from
+  "nobody looked".
+- **The unclassified-ceiling gate named the wrong cause.** It throws
+  `(23 > 31)` for a run whose total was 23 and whose ceiling was 31, because the
+  trigger is usually a **per-file** regression — a new file's first row exceeds
+  its allowance of 0 while the total stays inside the ceiling — and the message
+  only ever compared the two totals. It now says which condition fired and names
+  the files.
+
+### Changed: the unclassified ceiling, re-recorded at its reviewed value
+
+`31 → 23`, and `byFile` drops three stale entries for files whose pending rows
+have since been adjudicated away (`pallets-click` 1, `pytest-dev-pytest` 27,
+`new-repo.jsonl` 3) in favour of a new allowance for `keycloak-keycloak.jsonl`.
+
+The 23 rows are the scoped pass above: `QA-PW-117` +11 (n=24 → 35) and
+`QA-JV-101` +12 (n=23 → 35), awaiting human adjudication per
+`tests/corpus/verdicts/README.md`. **Not** 31 → 54: the live backlog had been
+classified down to 0 since the 31 was recorded, so this pass is 0 → 23, and a
+ceiling of 54 would have authorised 31 rows of pending work nobody asked for.
+Zero slack is the correct reading — the next pass must be acknowledged too.
+
+`measured-fp.generated.ts`, `docs/FP-AUDIT.md` and `docs/COUNT-LOCK.md` are
+unchanged, which is the point: blank rows are dropped, not counted, so 23
+unadjudicated findings move no rate until a person classifies them.
+
+### Changed: both plan targets already had a complete fixture quad
+
+`docs/CORE-READINESS.md` lists `QA-PW-117` and `QA-JV-101` as needing the
+four-leg quad. Measured against the tree, both already have all four:
+`MUST-FIRE` and `MUST-NOT-FIRE` fixtures on disk, 17 and 7 adjudicated `TP` rows
+and 12 and 8 adjudicated `TN` rows with zero `FP` in
+`tests/corpus/verdicts/quad/`. Nothing was authored, and the 10% ceiling still
+does not unblock 6.0.0 on its own — D-1 needs both the interval and the quad, and
+only the interval is missing.
+
+### Added: agent skills, and the wiring that makes them load
+
+The repository had four agent skills under `.claude/skills/` and no way for
+Kilo to see them. Kilo reads that directory only when the user-level Claude
+Code Compatibility setting is on, so on a default install the committed skills
+were dead weight in that harness — and `.kilo/` cannot hold them instead,
+because `.gitignore` ignores it as machine-local agent state. `kilo.json` now
+carries a `skills.paths` entry pointing at `.claude/skills/`: one tracked copy,
+both harnesses, and the wiring visible in a diff. `docs/EXTERNAL-CONFIG.md`
+records what that file now declares.
+
+Nine skills were added alongside the existing four, all written against this
+repository's own gates rather than imported wholesale:
+
+- `rule-author` — the full rule lifecycle: ID allocation and non-reuse, the
+  must-fire and must-not-fire fixture firewall, the four quad legs, registry
+  registration, the gates a rule change invalidates, and the
+  deprecation/retirement path from `docs/RULE-LIFECYCLE.md`. The 19-line Copilot
+  agent in `.github/agents/` covered the first half of this and nothing else.
+- `change-gate` — a diff-to-checks map, because `npm run check` is ~8 minutes
+  and the lever that moves it is running the row that covers the change. Names
+  only scripts `package.json` defines, which
+  `tests/contract/docs-consistency.spec.ts` greps every tracked `.md` for.
+- `surface-law` — law 0 as a procedure: what counts as the governed surface,
+  the twelve-leaf ceiling, and the two legal ways to grow.
+- `evidence` — the agent safety contract, including the rule that
+  `INCONCLUSIVE` is a result and never laundered into a pass.
+- `skill-author`, `verification-before-completion` — adapted from
+  `obra/superpowers` (MIT), the parts that decide whether a skill gets opened
+  and whether a claim gets evidence.
+- `prose-honesty` — adapted from `blader/humanizer` (MIT), fenced so it cannot
+  touch a generated page, an asserted surface, or a registered claim.
+- `quarantine-remediation` — the 34 quarantined rules are capped to
+  `severity: info` and `evidence: E0`, so they cannot fail a build; 34 of 79
+  rules are in that state and seven measure 0.0 % FP. `doctor` reports that
+  **none** carries a `quarantinePromotion`, so none has an owner, a review date
+  or an exit condition — the mechanism exists on the `Rule` type and has never
+  been applied. The skill covers the ladder, the Wilson-interval criterion that
+  replaced the point estimate in 6.0, and the promote/rework/retire decision.
+- `skill-supply-chain` — the scan procedure for a skill before it is installed,
+  since a skill is code that runs with the agent's permissions.
+
+No npm script, CLI verb, gate or rule was added, so law 0's ratchet does not
+move.
+
+### Fixed: `check-cli-contract` and `docs-consistency` disagreed about one file
+
+`npm run check` was red on `main`: `check-cli-contract` failed on
+`docs/RELEASE-3.0.0-READINESS.md`, which names `npm run m26:audit` in its
+command table. `scripts/release-verify.ts` records that script as removed in
+6.0 with the M26 ledger, so the name was real when the report was written and
+the report is dated 2026-09-25.
+
+`tests/contract/docs-consistency.spec.ts` already exempted exactly that file, by
+name, with the reasoning written out: a readiness report for a version that
+shipped is a record, not an instruction. Two gates catch the same class of
+dangling name, and the file was exempt from one that still tripped the other —
+an exemption made by accident rather than by decision. `check-cli-contract.mjs`
+now carries the same entry in a named `FROZEN_REPORTS` list, mirroring the
+existing `CAPTURED_ARTEFACTS` shape, and skipping it in both the removed-verb
+pass and the dangling-name pass. The list is by name, not by pattern, so it can
+be argued with per file.
+
+`tests/contract/cli-contract-dangling-names.spec.ts` locks both halves, because
+an exemption nobody tests is a blind spot with a comment on it: a dangling name
+in a live surface still fails, the frozen report still passes, a live doc beside
+the frozen one still fails, and the real tree passes.
+
+### Decided against, on measurement: the 500-word skill budget
+
+`skill-author` carried an upstream rule of "under 500 words". Eight of eight new
+skills broke it on the first pass, from 721 to 1222 words — which is the shape
+of a target nobody measured rather than a target anybody met. The figure was
+wrong for this class of skill: most of the excess is procedure that only runs
+once, and in `prose-honesty` a 22-row lookup catalogue that nobody reads to fix
+one sentence.
+
+So the rule now sorts by shape — a procedure carries a word budget, a lookup
+table is always a sibling file — and the number is measured rather than
+guessed. Two lookup structures moved out: `prose-honesty`'s catalogue to
+`patterns.md` (body 126 → 85 lines), and `skill-author`'s failure-classification
+table plus its no-baseline-run fallback to `baseline-failure.md` (204 → 166
+lines). Both are cases the rule's own branch rule covers: a catalogue is
+scanned for one row, and the fallback is only read when there is no baseline to
+classify.
+
+The ceiling lives in `budget.md` rather than in `skill-author`'s body, and that
+placement is the part worth keeping. A meta-skill that states its own budget
+counts toward it: writing "1250 words" into the body made the body 1251. Moving
+the figure one file over removes the self-reference, so the ceiling can be
+1300 against a measured maximum of 1264 and stay checkable.
+
+The record that the number moved, when, and against what measurement sits in
+`budget.md`. A ceiling that moves silently is the arithmetic of law 0's
+`baselineCore` edit: the arithmetic reads zero and the law reads as satisfied.
+
+### The baseline-failure step: a discoverability audit, and its limit
+
+`skill-author` prescribes a RED step — watch an agent fail the task before
+writing the skill. That did not run; these skills were written from
+`docs/RULE-LIFECYCLE.md`, `CLAUDE.md` and the gate sources. The substitute that
+could run is a discoverability audit: for each load-bearing fact, is it
+reachable from the repository today?
+
+| Fact                       | Reachable from                                                   |
+| -------------------------- | ---------------------------------------------------------------- |
+| a path→gates map           | `docs/archive/` only — nothing live                              |
+| directory → rule-ID prefix | `src/rules/index.ts`; no live doc states the mapping             |
+| the four quad legs         | `src/v6/fixture-quad-probe.ts` and an archived plan              |
+| rule IDs are never reused  | `docs/RULE-LIFECYCLE.md`, `docs/ARCHITECTURE.md`, `src/types.ts` |
+
+So `change-gate`'s content was nowhere to be found, the prefix table and the
+quad vocabulary were reachable only from source, and the ID non-reuse rule was
+already documented — that line is a guardrail kept for cost, not for novelty.
+
+This proves the knowledge was not already available. It does not prove the
+skills work; only watching an agent use one answers that. `skill-author` now
+records the substitute and its limit, so the next author knows which of the two
+they actually ran.
+
+### Fixed: the quarantine report named a field that does not exist
+
+`CorePromotion` declares five fields — `rationale`, `owner`, `grantedAt`,
+`expiresOn`, `evidenceRefs`. There is no exit-condition field, and `rg` finds
+the phrase nowhere in `src/`, `docs/` or `tests/` except in two places that
+were both telling the reader to go looking for one: the `quarantinePromotion`
+doc comment in `src/rules/rule.ts`, and the detail message
+`checkQuarantineOwnership` prints about the largest open item in the tree.
+
+A report that describes a shape the contract does not define is the same
+defect class as a rule reporting a metric it never measured — the reader is
+sent to do work against a field that is not there. The message now names the
+three a backfilled record actually has to supply, and the expiry date is
+labelled as what it is, since it is the exit condition in substance.
+
+`tests/contract/quarantine-record-honesty.spec.ts` locks it by parsing the
+field list out of the type rather than restating it, so it fails if the type
+gains a field the message omits and if the message ever names a phantom one.
+Verified by mutation: all three arms fail against the previous wording.
+
+### Verification
+
+`npm run test` is 11,992 passing with zero failures across 493 files. `npm run
+lint`, `typecheck`, `check-version`, `claims:check`,
+`candidate:manifest:check`, `entry-points:check`, `config:consumers`,
+`scripts:reachable`, `gates:check`, `check-concepts`, `check-cli-contract`,
+`check-certification-surface`, `check-detector-hashes`, `check-fixture-quad`,
+`docs:provenance-drift`, `check-carve-manifest`, `qa-ir:parity` and
+`docs:roadmap:backlinks` all pass.
+
+### Corrected: what `npm run check` was actually red on
+
+The previous version of this entry named a coverage threshold and blamed
+`src/commands/share.ts`. Both halves were wrong, and neither was checked:
+
+- `frontier:contracts` is **not** a leaf of `check`. `package.json` has `check`
+  as nine terms (`build`, `typecheck`, `lint`, `test:coverage:ci`,
+  `check-version`, `gates:claim-integrity`, `docs:regen`, `self-scan`,
+  `doctor`); `frontier:contracts` (`vitest run tests/contract/`) is declared in
+  no chain at all, and `certify` invokes that command directly rather than
+  through the name.
+- A bare `vitest run tests/contract/` collects no coverage — `--coverage` is
+  what enables the provider — so `perFile: true` could not be the mechanism
+  either.
+
+What was actually red was two generated artifacts that had not been refreshed:
+
+- `docs/BLAST-RADIUS-AUDIT.md` recorded `src/commands` at 11,988 lines against
+  a live 11,990, because the `GATE_COMMAND` de-duplication in `share.ts`
+  removed two lines from a file the audit counts.
+- `candidate-trust-manifest.json` failed `workingTreeSha256 drift`, which is
+  what it is for: it hashes the tree it was stamped against.
+
+Both are the same failure mode as the exemption added above — an artifact that
+describes a state nobody refreshed — and `scripts/refresh-generated.mjs` is the
+tool that fixes them, in the one order that converges.
+
+### Fixed: the convergence tool could not converge
+
+`scripts/refresh-generated.mjs` ran `docs:translations:sync` and
+`docs:translations`, both deleted by the v6 positioning carve (#697) along with
+the 20 translated READMEs, and formatted `README.*.md`, a glob that has matched
+nothing since those READMEs went. Prettier exits 2 on a pattern with no files,
+so the refresh reported `FAIL` on three entries and exited non-zero: the tool
+whose entire job is "make the tree agree with its generators" could not be run
+to completion.
+
+Nothing caught it. `npm run check` does not run this file,
+`scripts:reachable` answers the opposite question — is a script reachable FROM
+a caller, not does every name it invokes resolve — and `check-cli-contract`'s
+dangling-name rule reads `.md`, workflows, the Action and the reviewer config,
+not `scripts/**`. Two gates, two different blind spots, one script that could
+not do the one thing it exists to do.
+
+The dead entries are removed and the glob is `README.md`. The `npm run <name>`
+inside a `.mjs` gap is **not** closed here: the shape a general fix would need
+was measured, and the placeholder convention this repository already uses —
+`scripts/check-ci-local-parity.mjs` writes `npm run X` chains and `npm run Y`
+prose — is indistinguishable from an invocation by regex alone. Recorded rather
+than shipped as a gate that reports its own source.
+
+### Decided against, on measurement: the script-layer cut
+
+`npm run check` is ~8 minutes, and the test suite is 79 % of it. All 38 gates
+together cost 100 seconds, so cutting the gate surface from 39 to 12 — the plan's
+`~60 script files / ~45 npm scripts` target — would save under 15 % of the wait,
+while deleting checks that caught six real defects during 6.0. The numbers, the
+arithmetic and the alternative levers are recorded in the `6.0.0-rc.1` entry
+below and in `CLAUDE.md` law 0, so the question no longer has to be re-argued
+from file counts.
+
+The verification trust engine, measured. A tier you can only reach with
+evidence, a promotion that cannot land unreviewed, and generated documentation
+that cannot quietly go stale behind the code. Carries the 6.0.0-rc.1 line below.
+
+### Measured twice: the core promotions, and what they rest on
+
+Two rules hold `core`, and this release is where the arithmetic behind them was
+checked rather than asserted. Both sit at **n=35, zero observed false positives,
+Wilson upper bound 9.89%** against a 10% ceiling — reproduced by hand from
+`src/lib/wilson.ts` before either was believed.
+
+`QA-JV-101` earned it in two batches, and the sequence matters:
+**32 (10.72%) → 34 (10.15%) → 35 (9.89%)**. The first batch's verdict file reads
+as a refusal on its own — "STILL SHORT, NOT promoted" — and the second, from a
+sweep run after `corpus-sample.ts` was corrected to clone the pinned ref, is
+what cleared the ceiling. Read one batch and you conclude the promotion was
+fabricated; read both and it is earned. Both verdict files are cited in the
+certification record for exactly that reason.
+
+The sampler fix that made batch 2 trustworthy works _against_ inflation: it
+clones `repo.ref` instead of the default branch and makes retractions stick, so
+an orphan row cannot resurrect as fresh evidence. Three false rows (JWETest
+74/114/203) were retracted rather than judged.
+
+### The tree told a different story than the code
+
+Both promotions landed in the registry, the tier evidence and this file while
+their generated documentation went on reporting `extended` at n=23 and n=24.
+Nothing failed, because nothing asked.
+
+- **A rule count nobody can check is a claim, so generate it.** `README.md` said
+  "`core` is empty" for a whole release after two rules had earned it.
+  `measurementBlock()` now returns `core` and `docs:counts` stamps it into the
+  census surfaces, so `tests/contract/census-drift.spec.ts` fails if prose and
+  registry disagree. It counts UNMEASURED core rules deliberately:
+  `MAX_UNMEASURED_CORE` is 0, so a registry in that state cannot ship, and a
+  census filtered on `measured` would report a clean `core: 0` at the exact
+  moment the law broke.
+- **`docs:staleness` — one staleness assertion, runnable locally.** Four
+  workflows each asserted it by hand and three could not see an untracked file:
+  with clean tracked `docs/` and one new untracked file in it,
+  `git diff --exit-code -- docs/` exits **0**. That is how a new rule's docs page
+  shipped silently. The replacement reads `git status`, is read-only by
+  construction so it can never cost a tree its adjudication records, and is
+  deliberately absent from `npm run check` — asserting after regenerating is
+  checking the generator against itself.
+- **`docs/MEASUREMENT-CLOSEOUT.md` corrected to 73/6** (it read 74/5), gained
+  the missing `QA-PY-004` row, and now separates **stale** from unmeasured:
+  `QA-PY-004` (revision 4) and `QA-PY-007` (revision 5) have verdict sets that no
+  longer describe the shipped detector and need re-measurement at the current
+  revision — a different job from classifying new rows.
+
+### A promotion can no longer land with no artifact
+
+- **`docs/CORE-CERTIFICATION.json` — a record is required to hold `core`,** and
+  the record expires with its evidence. The measurement block is compared field
+  by field against the live `MEASURED_FP` row on every run: move the detector
+  revision, change n, or introduce an observed false positive and the gate fails
+  until someone re-certifies and writes down why. Every cited path must exist,
+  and cited corpus rows must sum to exactly `n` — self-derived quad verdicts are
+  excluded, which is why both records sum to exactly 35 (29+2+4, 20+10+2+3).
+- **QA-JV-101's record states its known weakness rather than omitting it.** Its
+  must-not-fire fixture is a hand-written different program, not the must-fire
+  fixture with `@Disabled` neutralised, so it shows the detector is directional
+  and does **not** show the predicate is sensitive to the annotation.
+- **No new gate and no new npm script.** Both are arms of existing gates —
+  `rules:promotion:check` and `check-fixture-quad` — because Law 0 charges for
+  surface growth.
+
+### The detector set is wired. It is not yet shown to have teeth.
+
+`docs/PRECISION-RATCHET.json` records 32 rules as holding a PRECISION leg and
+calls itself "a wiring proof, not an accuracy proof, and a self-derived one".
+That caveat now has a number, and it is not comfortable.
+
+A must-not-fire fixture is evidence that a rule is _sensitive_ only when it is
+the must-fire fixture with the defect neutralised. When it is a different program
+that merely does not trigger, the pair shows the detector is directional and
+nothing about the predicate. The quad counts presence, so both read alike.
+
+**Of the 40 live rules carrying both legs, 2 hold a negative fixture that is
+plausibly the positive fixture with the defect removed** (`QA-PW-144`, one changed
+line of nine; `QA-PW-116`, one of seven). The other **38** are a different
+program — the next nearest diverges by 0.55, the furthest by more lines than
+either file contains. Leashed at the true floor of 2, so it fails on a rule
+_regressing_ out of that set and not on the 38 that were always like this;
+`--update` only ever raises the floor, so a regression cannot be absorbed by
+re-running a command. Closing the gap needs a per-rule recipe for what the defect
+_is_, and that work is named rather than assumed away.
+
+### What a consumer may rely on
+
+- **`docs/ENGINE-FREEZE.md`** records the compatibility promise and points at
+  `CONTRACT_REGISTRY` rather than copying version numbers. `scoringModelVersion`
+  2.0.0 is a _semantic_ change (ADR 0014's evidence floor), so a consumer
+  comparing scores across it is comparing different things; and
+  `frameworkSupportMatrixVersion` is written by the engine and read by nothing
+  but a test — a version stamp on a fact, not a negotiated protocol.
+- **The delta loop is in the Quickstart.** Steps 1–3 report the _state_ of your
+  tests; `mjolnir ci verify` reports the _change_, the only question a reviewer
+  has about a diff. `--save-baseline` writes `.mjolnir/baseline.json`; `ci
+verify` reports RESOLVED (of which only `VERIFIED-RESOLVED` is a fix claim) and
+  NEW, under a `0`/`1`/`2` exit contract. Agents were taught this at
+  `src/commands/install-agents.ts:58`; humans had no way to find it.
+- **Governing prose that had gone stale behind the code** was corrected:
+  `rule-author` and `surface-law` both asserted the core tier was empty, and the
+  archived `RULE_CERTIFICATION.md` now carries a SUPERSEDED banner marking its
+  `core` column a fossil of the deleted `registry-census` predicate.
+
+### Not claimed
+
+The five `REMOTE_PROVEN` requirements in `candidate-trust-manifest.json` —
+protected holdout, real-world repositories, platform matrix, consumer install,
+remote workflow — are **not** satisfied, and `releaseAuthorizationState` remains
+`NOT_AUTHORIZED`. `npm run candidate:readiness` reports exactly what is missing.
+That gate exists so "measured" cannot be upgraded by assertion.
+
+## [6.0.0-rc.1] — 2026-10-02
+
+Theme: **two words and one number**. A first run reads `GATE` / `WARN` and
+nothing else, and it names the command that makes the scan a gate. Everything
+below is either a subtraction or a correction of a surface that stated the
+opposite of its own law.
+
+### Fixed: three README claims and the gate that let them ship
+
+`README.md` said the published line was `3.0.0` and the working tree
+`4.0.0-rc.1` while `package.json` was `5.1.0`; its Status heading read
+`**Version 3.0.0.**`; and its exit-code table documented exit `2` as
+"Partial scan… **Never blocks**" — the exact wording
+[`docs/VERSIONING.md`](docs/VERSIONING.md) withdrew when it made exit `2` a
+failure.
+
+The exit-code one had a gate: `tests/contract/exit-code-contract-docs.spec.ts`
+matched `/partial[^.\n|]{0,40}never blocks/`. The character class excluded
+`.`, and the README's cell reads as two sentences —
+`Partial scan (time budget hit, unreadable files). Never blocks.` — so the one
+gate written to catch that sentence could not match it. The class now stops at
+the table cell (`|`) and the newline, which is the unit actually being read, and
+no longer at a full stop: a period ends a sentence, not a claim. The gate also
+gained a positive arm — a surface that publishes an exit table must now _say_
+that `2` fails, rather than being silent about it and reading as a pass.
+
+The version claims had no gate at all, because a version claim is not law prose
+and a docs-consistency gate that checks law prose cannot see one.
+`tests/contract/docs-consistency.spec.ts` now pins the README's release-status
+paragraph to `package.json`'s `publishedStable`/`version` and refuses a Status
+heading that names a line which is neither.
+
+### Fixed: the Action told consumers an unfinished scan was green
+
+`fail-on-partial` defaulted to `false`, and its description said so in as many
+words — "partial scans produce a warning, not a failure" — on the Marketplace
+surface, while `docs/VERSIONING.md` said there is no flag that turns an
+incomplete run into exit `0`. The default is now `true`; the advisory opt-out
+still exists, is still one input away, and now warns that it is reporting green
+on a scan that did not finish. The generated `mjolnir ci install` gate already
+failed on `partial: true`; only its comment had rotted.
+
+**Breaking:** a pipeline relying on the old default will now fail on an
+inconclusive scan. That is the point of the law, and 6.0 is the major where it
+belongs.
+
+### Changed: the default report reads GATE / WARN and nothing else
+
+The `core` / `extended` / `quarantine` tiers are now internal, as are the `E0–E2`
+evidence rungs and the `L0–L5` trust rungs. They are all still computed, still in
+`--json`, and still in `mjolnir explain` — they are the differentiator, and a
+first run is not the reader they are for. `--verbose` still prints the evidence
+descriptor beside each finding.
+
+`GATE` means exactly what the exit code means: that finding counts against the
+configured gate. The label and the exit code come from one function
+(`isAtGate` in `src/claim-evidence.ts`) rather than from two derivations of
+"which findings gate" in two files, which is how a report ends up counting three
+GATE findings on a run that exits `1` for two.
+
+The verdict block lost the rung line and gained the number — `3 GATE · 4 WARN` —
+and NEXT ACTION now names the gate command (`mjolnir ci install`) on every run,
+which removed the second, differently-worded "New here? …" trailer that used to
+print it. First screen: the verdict, the count, the command.
+
+`defensibleTier` / `effectiveTier` and the Wilson interval floor are untouched.
+5.1.0's arithmetic is load-bearing and is not re-litigated here; the tier
+simplification is a presentation decision on top of it.
+
+### Added: `gate` on every finding in the JSON report
+
+Additive within `schemaVersion: 1`, as `docs/VERSIONING.md` requires:
+`tier`, `evidenceLevel` and `trustLevel` are all still there, and this adds the
+boolean the exit code is computed from, so a consumer no longer has to
+re-derive the gate level to know what blocks.
+
+### Added: `mjolnir share` — React Doctor's proof loop, without its server
+
+One scan, one self-contained HTML file, no upload and no share id. It carries
+the score, every `GATE`/`WARN` finding with `file:line`, three commands that
+move the number, and each fired rule's measured FP rate with its sample size —
+including "unmeasured", never a zero.
+
+It is NOT a mode of `scan --format`, because the artifact's contract is
+narrower than the bound Trust Artifact's. That artifact names the repo, the
+commit, the scanId and the rule(rev) inventory precisely so a consumer can tell
+which run produced it — and those are exactly the facts that must not travel
+when a file is handed to a third party. Two renderers, two contracts, one
+canonical scan result underneath.
+
+`tests/contract/share-artifact.spec.ts` is new and asserts four properties:
+byte-identical for the same scan, no absolute path / drive letter / home
+directory / remote / commit SHA, no code (a rule message quoting source is
+escaped, not embedded) and no network primitive of any kind. The zero-network
+law itself (`privacy-network-isolation.spec.ts`) is unmodified; this is the
+output half of it, because that spec can only see source.
+
+### Removed: the M26–M50 program, and what it was keeping alive
+
+`docs/ROADMAP.yaml` was 479 lines: 25 trains, ~160 workstream ids, every owner
+`UNASSIGNED`, and a status of `blocked-pending-live-ledger`. It is now a
+five-row table — the 6.0–10.0 ladder, one promise, one number and one kill
+criterion per row — and the old program is in
+`docs/archive/ROADMAP-M26-M50.yaml` with a header that says, in those words,
+**text preserved, claims not**. `scripts/roadmap/validate.ts` was rewritten for
+the new shape: it no longer reads anything, and it now enforces what the
+retired file could not — one version in progress at a time, and a kill
+criterion on every row. The archive has to resolve and be tracked by git, or
+the retirement is a deletion.
+
+Deleted with it: `docs/M26-GAP-LEDGER.jsonl`, `docs/M26-SUPPORT-MATRIX.json`,
+`docs/M26-ISSUE-DISPOSITIONS.jsonl`, `docs/M26-GITHUB-SNAPSHOT.json`,
+`docs/M26-EXTERNAL-VALIDATION.json`, `docs/EXTERNAL-EVIDENCE-REQUEST.md`,
+`schemas/m26/`, `src/ledger/` (2,738 lines), `scripts/sync-m26-github.mjs`,
+`scripts/revalidate-gaps.mjs`, `scripts/check-m26-ledgers.ts`,
+`scripts/v6/check-issue-disposition.ts`, `scripts/check-disposition-source.mjs`,
+`scripts/v6/reconcile-archive.ts`, `tests/ledger/`,
+`tests/contract/m26-support-matrix.spec.ts`,
+`tests/contract/ledger-shrink-guard.spec.ts`, and nine npm scripts.
+
+The four ledgers were transcriptions of a plan document, and the v6 inventory
+published six numbers copied out of them under `counts:` — where a reader took
+them for measurements of this repository. Those fields are gone rather than
+zeroed: `0` would have claimed there are no gaps, which is the one thing a
+retired ledger must not say. The count that replaced one of them,
+`counts.ciProviders`, is now measured from the code
+(`CI_PROVIDERS` in `src/commands/ci-adapter.ts`) instead of counting support
+matrix cells whose id contained the string `CI`.
+
+Six controls went with their subjects and each is named in the spec that used
+to hold it, because "the thing this asserted is gone" is itself a fact a reader
+needs: the archive gate (TI-022, TI-023), the `release decision`'s `m26Status`
+arm, the support-matrix-backed domain capabilities in the capability registry,
+and `orphan.yml`'s exit-code table (kept, repointed at the run header).
+
+Three ideas from the program survive as gates on live code rather than as rows:
+the Wilson interval floor (`src/rules/tier-evidence.ts`), the adversarial /
+boundary fixture quad (`scripts/v6/check-fixture-quad.ts`), and the
+external-evidence discipline, which becomes the 10.0 benchmark.
+
+### Added: two entry points, and a gate that counts them
+
+`npm run check` is what a pull request runs — twelve commands. `npm run
+certify` is the release path, and it begins with `check`, so it is a superset by
+construction rather than by comparison.
+
+`scripts/check-entry-points.mjs` enforces the number, that neither entry point
+names a script `package.json` does not define, that neither runs a write-mode
+script, and that `certify` reaches everything `check` does.
+
+**Known open, deliberately:** the twelve commands expand to **39** leaf scripts.
+`check-version`, `gates:claim-integrity` and `docs:regen` are themselves
+chains, and collapsing them to their leaves is the plan's larger promise, not
+this release's. The gate prints both numbers on purpose — the chain's own terms
+(12, the ceiling) and the transitive leaf count (39) — because the cheap way to
+satisfy a budget is to count the one that is easy to count, and an alias added
+to make the leaf count smaller would make the chain shorter and the wait longer.
+`tests/contract/entry-points-budget.spec.ts` is the negative arm: it proves the
+gate rejects an entry point that reaches a write-mode script, which is the
+property trust-invariant TI-022 used to be proved against the deleted archive
+reconciler.
+
+### Fixed: a verdict that claimed the analysis stopped when it did not
+
+`classifyTrust` treated any confidence ceiling, and any entry in
+`analysisStatus.reasons`, as proof that the scan was incomplete. Scanning `src`
+— the PR tier's own self-scan target — examined every file, found nothing, and
+printed "**The analysis did not finish** — it proves nothing about the surface
+it did not reach", because the framework was undetectable (a ceiling) and 34
+rules sat in the WARN tier (a `coverage:quarantine:34` reason).
+
+A false "incomplete" is not the safe direction: it trains the reader to ignore
+the word, which is the one state where it was true. Incompleteness is now the
+work-not-done list, named field by field — `partial`, truncated discovery, rule
+evaluation or `truncationReasons`, skipped files, parse fallbacks, crashed
+rules — and a ceiling bounds what a finished run can conclude without claiming
+it stopped. It also no longer licenses a clean result
+(`licensesClean`), which is what a capped run has not earned.
+
+`trustReasons` had a third, slightly different spelling of the same question,
+which is how a report could print a confident headline and say the opposite one
+line below it. It now calls the same exported function.
+
+`npm run self-scan` also scanned `.` where the declared gate scans `src`; it now
+scans `src`, and both the report and the exit code are honest about what was
+examined.
+
+### Fixed: three gate-set defects, and the reason they survived
+
+`gates/nightly.json` declared both `qa-ir-parity` and `gate:qa-ir-parity` (the
+same command) and both `scripts-unimported` and
+`gate:unimported-modules` (the same command): four gate ids, two checks, each
+run twice a night. The duplicate-**id** validation could not see it, because
+the ids differ. `scripts/check-gate-tiers.mjs` now also rejects two ids
+running the same command, and the same pass turned up a third pair
+(`version-check` / `changelog`) in both `release.json` and `nightly.json`.
+
+`gates:check` was nightly-only, so gate-file drift was invisible to every PR
+for up to 24 hours — which is why the pairs above survived a release. It now
+runs in `ci.yml`, and it is declared in `gates/pr.json`, so the declaration and
+the step cannot drift apart.
+
+### Changed: the anti-creep law covers the whole surface
+
+Law 1 in `CLAUDE.md` was scoped to the shipped rule set — the one surface easy
+enough to measure — so every other surface grew unchecked: 139 npm scripts,
+137 script files, 16 verbs, three capability registries, and a
+`frontier:contracts` list hand-written in `package.json` that listed 31 specs
+while `certify` ran the whole `tests/contract/` directory. The latter is now
+the directory. Law 0 states that the governed surface is every capability the
+product claims, and the entry-point gate is its enforcement.
+
+**Decided against, on measurement: the ~60-file / ~45-script cut.** The script
+layer is 138 files and 141 npm scripts. The plan's argument for cutting it was
+that a maintainer cannot hold it in their head — and the argument is about
+_waiting_, so it was worth measuring before deleting anything:
+
+| Term                                   | Wall clock | Share |
+| -------------------------------------- | ---------- | ----- |
+| `test:coverage:ci`                     | 372 s      | 79 %  |
+| `lint`                                 | 47 s       | 10 %  |
+| `docs:regen` (15 generators)           | 20.5 s     | 4 %   |
+| `typecheck`                            | 13 s       | 3 %   |
+| `gates:claim-integrity` (17 gates)     | 8.9 s      | 2 %   |
+| `build`                                | 7 s        | 1 %   |
+| `check-version`, `doctor`, `self-scan` | 4 s        | 1 %   |
+| **`npm run check`, whole**             | **~8 min** |       |
+
+**All 38 gates cost 100 seconds of an eight-minute wait.** Cutting the gate
+surface from 39 gates to 12 would save roughly 70 seconds — under 15 % — and it
+would do that by deleting checks that caught six real defects during this
+release, three of them in code written hours earlier: the exit-code regex that
+could not cross a sentence period, the README version claim no docs gate could
+see, a `DELETE` row whose reason had nowhere to live, a stale `gate` field, a
+carve manifest that had drifted from the tree, and a duplicated gate command.
+
+So the target the plan named was the wrong one. The wait is the **test suite**,
+not the gates, and it is the price of a tool whose thesis is that a green build
+is a claim rather than a fact. The levers that would actually move it are
+recorded rather than taken here: vitest reports ~18 s available from
+`isolate: false` (~4 %), and the e2e journeys are the slow tail — one of them
+spawns the CLI twenty times. Splitting the suite into fast and slow projects so
+the slow tail runs beside the fast one is the real win, and it is CI work
+rather than a surface cut.
+
+`npm run entry-points:check` prints `commands` (9), `executions` (39) and
+`leafCommands` (39) separately, and fails if the chain exceeds twelve terms,
+names a script that does not exist, runs a write-mode script, runs the same gate
+twice, or if `certify` is narrower than `check`. Law 0 makes the surface
+governed; these are its teeth.
+
+Two consumers were left alone rather than deleted: the twelve-file
+`scripts/video/` pipeline (`docs:video:capture`, `docs:video:render`,
+`docs:video`) and its `demo-video.yml` workflow, because the README embeds the
+video they produce and deleting a marketing asset is a product decision this
+change set has no mandate to make. They are declared as write-mode, unreachable
+from either entry point, and cannot be run by accident.
+
+### Deprecated: `--strict` → `--include-warn`
+
+The old name promised enforcement the flag never had: a quarantined detector is
+advisory by design (decision D-2), so `--strict` could never make anything
+stricter, and a user reaching for it was asking for something the tool would not
+give them. The new name says what it does — it includes the WARN tier.
+
+`--strict` still works and warns, naming its replacement, and is removed at 7.0
+per the cycle in `docs/VERSIONING.md`. `tests/contract/deprecation-cycle.spec.ts`
+is new and makes that cycle executable: every deprecated spelling is data in one
+list, and the test walks all three steps of it — the old name parses and does
+exactly what the new one does, it reports the deprecation with its replacement,
+and the replacement itself never warns.
+
+## [5.1.0] — 2026-10-02
+
+### Two subtractions declined, because the surface they would remove says something the replacement does not
+
+**`mjolnir capability`: delete the M0–M5 ladder, render the tier instead.** The
+two are not two names for one thing. `M0_UNKNOWN … M4_CORPUS_VERIFIED` is an
+_evidence_ axis — how far a capability's detection has been proven — and the tier
+(`core`/`extended`/`quarantine`) is a _shipping_ axis — whether it appears in a
+default scan. They are orthogonal in exactly the case that matters: a capability
+can be corpus-verified and still quarantine, and does. `QA-TEST-001` is
+`M2_IMPLEMENTED` with a measured 60% FP over n=20; the maturity ladder says how
+well its detection is built, the tier says it must not gate a build, and neither
+answer implies the other.
+
+Rendering the tier "instead" would also delete the `next level` line — the
+ladder's actual product, which names the next rung and what it requires
+(`M3_FIXTURE_VERIFIED` — "positive + negative + boundary + adversarial fixtures
+pass deterministically in CI"). That is roadmap information stated as evidence,
+and it is the part a maintainer uses. The arm already says the right thing about
+itself: "shown at the level the machine can prove, or not shown at all."
+
+**Cut the PR tier from 28 gates to 8.** This is a velocity trade, not a defect,
+and it runs opposite to the rest of this release: everything above restored
+verification that had silently stopped running — a suite with 48 failures, a
+typecheck with 8 errors, a coverage ratchet that could not evaluate, an anti-creep
+ratchet that switched itself off at release time. Removing 20 gates from
+per-push verification to save eleven minutes on a machine, while leaving CI's own
+`required` set as the binding one, is a decision about which machine developers
+use. It should be made as that decision, explicitly, not as cleanup.
+
+Five of the plan's nine Phase C items are now either done or refuted, and three
+of the refutations shared a cause: each was written from a directory name or an
+orphan-list reason rather than from reading what the code actually does.
+
+### Four unwired modules deleted, two of them second implementations of live ones
+
+C1, the orphan list. Deleting an unwired module is only safe when the reason says
+_why it is dead now_ rather than _what defect it was written for_ — and four of
+the reasons were describing a world that no longer existed.
+
+- **`src/release/pack-audit.ts`** — `scripts/pack-audit.mjs` is what
+  `stable-release.yml` runs, and `tests/contract/pack-audit.spec.ts` proves
+  _that script_ can fire on every forbidden shape and stay silent on the
+  shipped one. An unused copy of the audit is a second answer to "what is a
+  forbidden tarball entry", and only the copy with a gate behind it would ever
+  have been exercised.
+- **`src/release/sbom.ts`** — same shape. `scripts/generate-sbom.mjs` produces
+  and checksums the SBOM the release attaches.
+- **`src/integrations/github/github-permissions.ts`** — validated a token
+  before publishing a PR comment. **There is no PR comment publisher in
+  `src/`**: the `pr-comment` verb went with the v6 carve. Its recorded reason
+  also cited D5 ("the generated workflow inherited the default token scope"),
+  which was fixed by emitting `permissions: contents: read` in both
+  `ci-adapter.ts` and `ci-install.ts` — without this module. The defect was
+  real, the fix did not go through here, and the reason outlived both.
+- **`src/integrations/github/stale-guard.ts`** — enforced TI-020, that an
+  artifact carries the head SHA it was produced for. Same missing publisher.
+
+Kept, with their reasons corrected to state what is actually true:
+`release/provenance.ts` and `release/reproducibility.ts` (the release gets
+provenance from `npm publish --provenance`, a different mechanism; a named
+release property nothing here verifies is a gap, and deleting the only code
+that would verify it converts a gap into an absence), `commands/registry.ts`
+and `engine/command-registry.ts` (three descriptions of one verb list, one
+authoritative — the clearest derived-fact-twice instance in the tree),
+`discovery/ecosystem-detection.ts`, the two `bench/` modules,
+`change-intelligence.ts`, `store/legacy-import.ts`, `v6/test-doubles.ts`, and
+the ten barrels. Orphan count 25 → 21.
+
+**A gap in the gate that authorises these deletions.**
+`docs/CARVE-MANIFEST.json` is exactly the right mechanism — facts generated,
+dispositions hand-written and preserved, and `--check` failing on any file that
+left the tree without a DELETE disposition. It caught these four on the first
+run and named them. But regeneration rebuilds the manifest from the files that
+_exist_, so a DELETE disposition disappears the moment the file it describes is
+gone: the gate reports "2 already removed" for exactly one run, and then the
+reason is no longer in the repository. A manifest whose purpose is to hold the
+human decision should keep a tombstone for it; this one does not. The reasoning
+for these four is in this entry instead.
+
+### The declared tier is a third floor, and now it has teeth
+
+B0 measured all 79 live rules against both existing derivations before anything
+was refactored. The result changed the shape of the work.
+
+The interval floor is all but unreachable at the corpus sample cap, in both
+directions, and `tests/rules/core-tier-reachability.spec.ts` now pins the
+arithmetic with the product's own `wilsonInterval`:
+
+- **core is unreachable.** `ciHigh <= 10%` needs n >= 35 with ZERO false
+  positives — 0/20 reads 16.1%, 0/30 reads 11.3%, 0/35 reads 9.9%. The sampler
+  caps at 20 per rule, so the best a rule can look at that cap is 0/20, and
+  16.1% is above the ceiling. `MEASURED-CORE` in `RuleStatus` is a state this
+  corpus cannot produce. The cap is bounded by the adjudication budget, not by
+  statistics: raising it to 40 previously produced 1,121 unadjudicated rows
+  across 42 rules, which the committed ceiling refused outright — correctly,
+  because blank verdict rows are dropped rather than counted.
+- **quarantine needs a 75% error rate.** `ciLow >= 50%` first fires at 15 of 20
+  false positives; 14/20 reads 48.1%. Exactly one rule clears it:
+  `QA-ENV-001`, wrong 20 times out of 20. The worst of the rest,
+  `QA-TEST-002`, sits at 62% and clears neither bound.
+
+So **34 rules declare `quarantine`, and 33 of them would be promoted into the
+default scan if the declared `tier` field were deleted** — every one in the
+promoting direction, none the other way. Deleting the declared tiers is not a
+refactor; it ships 33 quarantined detectors, including the six CI rules the
+README's caught-by-default table marks advisory.
+
+The arithmetic corrects a summary I wrote first, and the spec caught it: I said
+the interval floor "quarantines zero rules". It quarantines one — `QA-ENV-001` —
+and B0's own table had said so throughout, under a declared column that
+happened to agree with it. The declared count is 34, not 33; 33 is the number of
+rules held down by the declaration alone.
+
+So the declared tier stays, stated for what it is: a floor stricter than both
+derivations, and currently the only thing holding those 33 rules out of a
+default scan. That is documented at the field, with the numbers.
+
+A floor that can also LOOSE is not a floor — it is a way to ship a rule the
+corpus says should not ship, and because every derived number in the tree reads
+the declared value through `effectiveTier`, nothing else would disagree.
+`defensibleTier` now states the floor a declared tier may never sit above, and a
+registry ratchet enforces it: no measurement at all, or observed FP above 30%,
+both mean quarantine.
+
+The first version of that law was written against the interval floor alone and
+measured at **zero teeth** — it could only ever catch a rule declaring `core`,
+which no rule declares, so it would have passed no matter what the registry
+said. Both failure directions are now probed as tests, and they assert that the
+interval floor would have missed them.
+
+The anti-creep exception is discharged rather than copied forward: 5.1.0 shipped
+the declaration, so the baseline absorbs it at 45/45 and the marker no longer has
+to be re-declared on every commit. The demanding branch stays covered by a
+pre-discharge fixture, and one rule above the absorbed baseline is still refused
+without a declaration.
+
+### Three orphan `families/` taxonomies deleted, one of them after being measured
+
+`flaky-patterns.ts`, `marker-registry.ts` and `no-assertions.ts` shipped with
+no importer. The repo's rule for these is "if a rule's measured FP names the
+cause one of them describes, wire it; otherwise delete it" — and none of the
+three describes a cause anything is measured against.
+
+`no-assertions.ts` was the interesting one: 7 framework assertion
+vocabularies, written for `QA-TEST-003`'s named FP cause. Its cause is
+_hidden-assertion helpers and deliberate no-throw smoke tests_, which is not a
+framework-vocabulary gap. Diffed against the rule's own predicate over 15
+representative test bodies it changed 2, **in both directions**: it suppresses
+`expect.extend(…)` — which _defines_ a matcher rather than asserting — and
+reintroduces a false positive on `should(x).be.ok`. Wiring it would have been a
+behaviour change to a quarantined rule justified by a claim the evidence does
+not support, so it is gone and the gap is recorded in the ledger instead, where
+it will be re-measured rather than quietly closed.
+
+(The first measurement of that diff was wrong — a `g`-flagged `RegExp.test()`
+carries `lastIndex` between calls, so the two predicates were being fed a
+moving target. Two differences, not three.)
+
+`flaky-patterns.ts` carried its own `HARD_SLEEP` patterns while a wired
+`hard-sleep` family already exists: a second source for one fact, which is the
+pattern that manufactures drift. Orphan count 28 → 25.
+
+### Two plan items refuted before acting on them
+
+**"Delete `scripts/video/` — nothing consumes it."** It has three npm scripts,
+a workflow, and a README-linked asset. Its storyboard is gated by
+`tests/contract/video-script.spec.ts` (11 tests, re-running the capture and
+failing on drift); only the `.mp4` encode needs Chromium and ffmpeg, which is
+why that step is manual by design. Left alone.
+
+What _is_ true is narrower and worth saying: the committed `mjolnir-demo.mp4`
+was rendered before the v6 carve, so it demonstrates output the CLI no longer
+prints. The README now says so, and names the re-render command, rather than
+letting a stale artifact read as current.
+
+**"Delete the ~25 rule docs for retired rules; make `docs:regen` prune so it
+cannot recur."** The retired pages are kept **deliberately** — they are the
+record of what the tool used to claim — and
+`tests/contract/rule-docs-set.spec.ts` enforces exactly `live ∪ RETIRED_RULE_IDS`
+and nothing else. A prune was written, deleted all 22 on its first run, and was
+removed. That is the strongest available demonstration that "the generator
+cannot remove its own output" is a reason to add a `docs:regen` check, not a
+reason to add a delete. The existing spec already catches the real orphan: a
+page for an id in neither list.
+
+**"Delete `src/certification/` — it certifies 1 language."** It reports
+**0 of 100** detection cells across **5** ecosystems, and separately 1 language
+(`manifest-v5` language support) as CERTIFIED. Those are different ladders and
+the file says so. A module that honestly reports 0% with a per-ecosystem next
+gap is a live status document, not dead weight — the repo already applied this
+reasoning to `src/v6/test-doubles.ts` on the orphan list. Left alone, with the
+number corrected.
+
+### Two bytes of encoding damage
+
+`src/cli.ts` and `docs/DISTRIBUTION-KIT.md` each carried UTF-8 that had been
+decoded as Latin-1 and written back (`·`, `≥`, `×`). Invisible to a reader
+whose editor auto-detects encoding, and to any gate that does not look. Both
+fixed; a scan of all 10,133 text files in the tree finds no others.
+
+### Test fixes
+
+- `tests/contract/coverage-state.spec.ts` was passing its keys to a helper
+  typed for a different shape, so they were dropped and the test loaded a
+  consistent default document. It never tested what it claimed.
+- `src/commands/rule-families.ts` sat at 60% because the carve removed
+  `create-rule`, its second consumer. `tests/contract/rule-families.spec.ts`
+  checks the table against the live registry.
+- The anti-creep and unreleased-entry gates both anchored on "the first `## `
+  heading", which stops describing anything the moment a version is cut. Both
+  now scope to the current version's section.
+
+### `ci verify` could never leave its no-baseline arm
+
+**The `baseline` verb was removed in the v6 carve and nothing replaced it.**
+`saveBaseline` had no remaining caller, so nothing in the shipped product wrote
+`.mjolnir/baseline.json`. `mjolnir ci verify` — a `ci` subcommand, listed in
+`mjolnir ci --help` — therefore exited `2` with "no committed baseline" for
+every user, permanently.
+
+Worse, three shipped messages told you to fix it by running a command that
+could not: the `verify` digest, the MCP `verify` tool, and the agent
+instruction brief `mjolnir install` writes all said to establish the
+before-state with a scan that never wrote one. A recovery instruction that does
+not recover is worse than none — it costs a round trip and teaches the reader
+that the tool's own guidance is unreliable.
+
+`mjolnir <target> --save-baseline` now writes the snapshot, reusing the
+existing writer and renderer. The exit code stays the **scan's**, not the save's:
+the old verb returned `0` unconditionally after capturing, so a repo full of
+error findings exited clean as long as you snapshotted it.
+
+### Unknown flags were silently ignored on three commands
+
+`mjolnir doctor --bogus` printed its usage and exited `10` after a flag-parity
+fix. `mjolnir analyze --bogus` printed "Use --cross-file to enable cross-file
+analysis" and exited `0`; `mjolnir explain --list --nonsense` printed the whole
+rule catalogue and exited `0`. A caller scripting a filter got every rule and no
+warning, and a command that looks like it ran and does nothing is the shape this
+product exists to catch. All three now reject an unknown flag with a usage
+message naming the accepted set.
+
+### The agent instructions named four commands that exit 10
+
+`mjolnir install` writes instruction files for Claude Code, Kilo, Cursor and
+`AGENTS.md` telling an agent how to run the loop. After the v6 carve they said
+`baseline`, `verify`, `why`, `triage` and `forensics` — all removed, all exit
+`10`. The 79 rule docs were re-pointed at the real command; the shipped agent
+brief was not. It now names `--save-baseline`, `ci verify` and `explain`.
+
+### The brand gate checked a file that no longer exists
+
+`scripts/brand-doctor.mjs` rule 7 had a self-test seed and a rule arm both
+reading `src/commands/badge.ts`, deleted by the v6 carve. The arm was guarded
+by `existsSync`, so it reported "0 generated bands" and the self-test aborted
+the whole gate on a missing file. Both are gone: the product emits no
+shields.io badge (the PR comment renders HTML cells), and a check behind an
+`existsSync` that is always false is a check that cannot fail — the exact defect
+that script exists to catch. The self-test now proves 11 of 11 rules.
+
+### Two gates could not have been running
+
+**The anti-creep ratchet switched itself off at release time.** The exception
+marker was scoped to the first `^## ` heading in the changelog. Cutting a
+release empties `## [Unreleased]` — that is what the section is for — and moves
+the change's notes into the version heading below it. From that moment the
+declaration was still there, one heading down, and the law reported legitimate
+growth as unlicensed. The parser now accepts the release heading below an
+empty `[Unreleased]`, and still refuses a marker from any older release; three
+arms pin both directions.
+
+**`tests/contract/coverage-state.spec.ts` never tested its claim.** It called a
+helper typed `Partial<analysisStatus>` with `{ partial, analysisStatus }`, so
+both keys were dropped and the helper's own consistent defaults were used. The
+document loaded for the wrong reason. It now passes the real
+`coverageState` — and fails without it, which is how you know.
+
+### The type gate had never run
+
+`npm run typecheck` reports **8 errors**, all in test files, all pre-existing at
+`ef500a8b`. The gate was red in the same way the release was red: nobody ran
+it. Two were hiding a real defect behind a cast — `TrustSummary` had
+`level: "high"`, which is not a `TrustLevel` at all (`L0`..`L5`), and
+`assessDoubleRisk` was being called with `intent` where the interface says
+`intention` and requires `hasFixture`/`hasLifecycle`. Neither had compiled
+against the real type. Both are fixed; the gate is green.
+
+### A test that passed vacuously, found by the coverage floor
+
+`src/commands/rule-families.ts` sat at 60% because the carve removed
+`create-rule`, its second consumer — the table's rows went from "exercised by
+the scaffolder" to "loaded once and never checked". `tests/contract/rule-families.spec.ts`
+now checks the table against the live registry: every token is a family the
+rules use, every family with rules has a directory that exists, and the derived
+`RULE_ID_RE` accepts every family in the table and rejects families that are
+not in it.
+
+The check that surfaced the drop is the reason the new arms were added
+in-process. A test that spawns the binary earns no istanbul credit, so
+`--save-baseline` and the two flag-parity arms would have shipped untested by
+the ratchet's own measure.
+
+### The coverage ratchet, measured against a suite that could not run
+
+The high-water marks (98.28 / 94.87 / 99.17 / 98.64) were recorded against a
+green suite. At `ef500a8b` 48 tests failed, a failing run writes no summary,
+and `coverage:ratchet` errored with "run npm run test:coverage first" instead
+of reporting a number — there was no comparable measurement. The measured value
+with a fully green suite is **97.22 / 93.71 / 98.78 / 97.80**; the marks moved
+accordingly, with the reasoning recorded in `docs/COVERAGE-GATE.md` before the
+build was expected to pass.
+
+### `runDoctorPlaywright` was not reachable, and its tests passed a wrong argv
+
+Six test files called `runDoctorPlaywright(["doctor", "--frameworks", dir])`.
+The handler takes the target as the first non-flag argument, so it was scanning
+the literal string `"doctor"` and printing `SELECTOR HEALTH` for it. The verb
+was removed by the carve, so nothing in the product reaches the handler at all.
+The calls pass `[dir]`.
+
+### The brand gate checked a file that no longer exists
+
+`scripts/brand-doctor.mjs` rule 7 had a self-test seed and a rule arm both
+reading `src/commands/badge.ts`, deleted by the v6 carve. The arm was guarded by
+`existsSync`, so it reported "0 generated bands" and the self-test aborted the
+whole gate on a missing file. Both are gone: the product emits no shields.io
+badge (the PR comment renders HTML cells), and a check behind an `existsSync`
+that is always false is a check that cannot fail — the exact defect that script
+exists to catch. The self-test now proves 11 of 11 rules.
+
+### Test fixes
+
+- `tests/milestone-12.spec.ts` cast four `ScanResult` fixtures with `as any`
+  and omitted the required `frameworks` field, so the fixtures threw
+  `TypeError` on `.length`. The product reads `result.frameworks.length`; the
+  fixtures were wrong. One also asserted `scoreDelta === 0` for two null
+  scores, contradicting the deliberate `?? 0` fix — a null score yields a null
+  delta, and the expectation now says so.
+- `TI-024`'s `verificationCase` named a test title that was replaced when the
+  translation machinery was retired. It now names the case that exists, and the
+  registry spec proves the title is still in the named file.
+- The version-surface drift arm hardcoded `@v4` in both its seed and its
+  expected message, so it seeded `v5` and asserted "v3 does not match v4" — the
+  check fired correctly and the test failed on its own staleness. The major is
+  now read off the fixture and the message composed from it.
+- The exit-code sweep, journeys 2, 3/4 and 5/6/7/8 called fourteen verbs the
+  carve removed. Each is now asserted in the form that ships, and the retired
+  names are asserted to be usage errors — a verb that comes back under its old
+  name is a surface the docs no longer describe.
+- `crash-paths.spec.ts` had a `describe` with no tests (the carve deleted every
+  body and left the hooks), which fails collection. Its arms made the write
+  target unwritable with `chmod 0o555` — a no-op on Windows, so half the suite
+  verified nothing on the platform most contributors run. The throw is now
+  injected at the IO boundary: deterministic everywhere, same catch.
+- `tests/integrations/release-workflow.spec.ts` expected the release job list
+  to be `["contract-verify", "tag"]` — a CLI verb, not a job in the workflow —
+  while the assertion 15 lines below still read `needs.verify.outputs.tarball`.
+  Both cannot be true, and the one naming a job that does not exist would have
+  let a rename break the publish path silently.
+- `CORPUS` pinned `positive-fixtures` to a tree SHA the carve had moved.
+- `test:release` still named the empty `release-trust-branch.spec.ts`, which
+  was deleted.
+- `candidate-manifest-base-sha` tolerated 3 of the checker's 4 content
+  invariants, so a `lockfileSha256` drift — what any `npm audit fix` produces —
+  failed the test with a message it did not recognise as transient.
+- The anti-creep and unreleased-entry gates both anchored on "the first `## `
+  heading", which stops describing anything the moment a version is cut. Both
+  now scope to the current version's section.
+
+### README
+
+The opening claimed seven detections and put the strict-mode split 21 lines
+below the list. The list now carries a **caught-by-default** column beside each
+false-green, and the split sits directly under it. The seven claims were not
+false — every one of those false-greens is real and detected — but the default
+scan catches five of the nine rows, and the README's structure made the
+advisory four look equivalent to the other five.
+
+### Maintenance
+
+`npm audit fix` — `brace-expansion` high-severity DoS (transitive), three
+advisories.
+
+### The demotion ratchet's own numbers were transcribed, not measured
+
+**Eighteen of the nineteen `ciHigh` values in `DEMOTED_FOR_UNSUBSTANTIATED_CORE`
+were wrong.** They were written once at the 6.0 demotion and never re-derived,
+so a re-sample moved the real interval and left the number beside it describing
+a measurement that no longer exists. `QA-PY-002` recorded `0.152` against a real
+`0.2996` — the row said "the largest sample on an observed-nonzero Python rule
+here, and still short of the ceiling" about a rule that was twice as far from the
+ceiling as recorded.
+
+The ratchet that should have caught this only asserted `ciHigh >
+CORE_FP_CEILING`, which every stale value also satisfied. A check on a
+hand-maintained number that tests only its sign cannot fail.
+
+So the number is no longer hand-written. Each row keeps `ruleId` and
+`justification` — the part that is judgement — and `ciHigh` is computed from
+`MEASURED_FP` on load using the same expression `measurementInterval` uses. A
+rule whose measurement has been withdrawn yields `NaN`, and `NaN > 0.1` is
+false, so it fails the check rather than passing it. A new ratchet assertion
+compares each recorded value against the **live** `measurementInterval`, so a
+stale `detectorRevision` or a withdrawn measurement is caught too, and the
+check now fires when a value drifts.
+
+All nineteen remain legitimately demoted — none clears the ceiling — so the
+ratchet stays armed and the tier is still empty.
+
+`docs/CORE-READINESS.md` now records, in the generator rather than only in
+prose, that `EARNED`, `DECLARED` and `EXPIRED` are empty because no rule's
+interval clears the ceiling and no rule carries a `corePromotion`. All three
+states are kept: they are reachable, and deleting a state because its count is
+zero deletes the branch that would have reported a non-zero count.
+
+### The anti-creep law now governs the rules that actually ship
+
+`ANTI-CREEP-EXCEPTION` — the law's own mechanism for a growth that is not a
+creep. The launch set is redefined from `tier === "core"` to
+`effectiveTier !== "quarantine"`, which is what the law has always said it
+covers ("the rules that ship in the default report"). That is **45 rules, not
+0**: the core tier has been empty since 6.0, with all 79 rules resolving to 34
+`quarantine` and 45 `extended`.
+
+The ratchet therefore reports growth of 45 against a previous baseline of 0,
+and this line is the reason. It is not new surface area — every one of those 45
+rules already shipped; the law simply was not counting them. What changes is the
+bar: growth above 45 now needs one of these markers, and `CORE_CAP`'s 65 leaves
+20 free slots rather than 65.
+
+- **`docs/ANTI-CREEP-BASELINE.json`** records `baselineCore: 45` with
+  `previousBaselineCore` left at **0** deliberately. The law compares the tier
+  against the _previous_ baseline, so leaving it at 0 keeps the move from 0 to
+  45 visible as growth; setting it to 45 in the same edit would make a
+  redefinition of the governed set look like a legal no-op, which is the exact
+  escape that rule exists to close.
+- **Law 3 (north-star) keeps governing the core tier, on purpose.** The ≥10
+  verdict requirement is enforced against `tier === "core"` and was not moved to
+  the shipped set: applying it to 45 rules would fail the check on day one. That
+  is a policy decision about what the product may ship, not a defect, so it is
+  recorded here rather than taken unilaterally. The open question — does the
+  ≥10 requirement apply to the shipped set or the core tier? — is unresolved and
+  belongs to the law's owner.
+- `CORE_CAP` stays at 65 and `MAX_SAMPLES_PER_RULE` stays at 20. Both are
+  deliberate; the corpus sampler's in-source rationale (`scripts/corpus-sample.ts`)
+  records why raising the cap produced 1,121 unadjudicated rows that the
+  committed ceiling refused. The defect was never the constants — it was that
+  the law measured a set of zero.
+
+### Single-site corrections, and one key that matched nothing
+
+- **`FRAMEWORK_FAMILY.selenium` and `SLUG_TO_FAMILY.selenium` were `"QA-SEL"`.**
+  No rule id carries that prefix — the real one is `QA-SE` — so both maps
+  resolved to the empty list. The Selenium capability reported no evidence at
+  all while its three rules (`QA-SE-001`–`003`) were credited to nothing.
+  An unmatched key returns an empty result rather than an error, which is why
+  nothing reported it. `QA-SE` was the only family in the registry that no
+  capability could reach.
+- **`M5_FIELD_PROVEN` did not require `M4`.** `fieldProven` was the first test
+  in `deriveMaturityFromEvidence`, so a capability carrying only that flag
+  reached M5 — a level whose published meaning includes "declared" and
+  "implemented" — without either. The ladder's own stated invariant ("each level
+  requires every criterion below it") did not hold at the top, and the only route
+  to M5 was to satisfy none of M4's criteria.
+- **`LOCAL_PROVEN` could cite an unmeasured rule.** `proofFor` picked the first
+  non-_retired_ rule, so a capability whose first listed rule had no corpus
+  evidence could be marked proven with a pointer into `docs/FP-AUDIT.md` for a
+  rule the audit never measured. It now picks a rule from `facts.measured` —
+  the same predicate the status itself reports on.
+- **A parity violation could name a field that cannot differ.** `checkParity`
+  guarded on the fingerprints being different and then iterated
+  `["intention", "fingerprint"]`, so the `fingerprint` arm was unreachable. Its
+  sibling `extractBindings` already looped correctly over the same files for the
+  same kind of marker.
+- **The claim linter reported the first claim on a line and dropped the rest.**
+  `scanText` used a single `exec` per line, so a line making two claims of the
+  same kind reported one — and the half it dropped was the half a maintainer has
+  to go and fix. All matches are now reported, with a zero-length guard so a
+  future pattern that can match empty cannot hang the linter.
+- **The forensics `successRate` was not a rate.** It could only be 0 or 1, and
+  this object is only built when a test passed _on retry_ — so within
+  `maskedFailures` it was invariably 1. A reader seeing "success rate: 1" would
+  conclude the test passed on every attempt, which is the opposite of what the
+  entry means. Renamed `finalPassBinary`. Its `attempts === 0` guard was
+  unreachable: the enclosing filter requires `attempts > 1`.
+- **Two CI findings reported themselves under the wrong name.** An `exit 0` was
+  typed `or-true` while its own description said it forced an exit code of 0, and
+  the pattern `||\s*(?:true|:)` matched both `|| true` and `|| :` while the
+  description said `|| true` unconditionally — naming a construct the script does
+  not contain, on exactly the finding a reader is about to go looking for. They
+  are now `or-true`, `or-colon` and `exit-zero`.
+- **A rule that sampled nothing no longer overwrites its review sheet.**
+  `writeReviewSheets` wrote a sheet whose entire content was a heading, the
+  verdict legend, and "Total sampled: 0" — and replaced any sheet from an earlier
+  run that had samples, destroying pending classifications. A zero-sample rule now
+  removes its sheet. This is distinct from a rule this run did not _visit_, whose
+  sheet is owner work-in-progress and is still preserved.
+
+### The readiness table told maintainers to do the wrong work
+
+`docs/CORE-READINESS.md` is the document a maintainer reads to decide what to
+do next, and two of its three actionable columns did not compute what they said.
+
+- **`FP headroom` could never contain a positive number.** It asked how many
+  _more_ false positives a rule could be **added** and still clear the ceiling —
+  and adding false positives only widens the interval, so every rule that had
+  already earned the tier read `0` and every other rule read `—`. The quantity
+  that actually decides work is the opposite one: how much of the current
+  evidence has to be **retracted**. Renamed `FPs to remove` and computed by
+  searching downward from the observed count. It is now `—` only where
+  retraction genuinely cannot reach the ceiling at that `n`, which is a fact
+  about the sample rather than a missing value.
+- **`NEEDS-FP-REDUCTION` condemned detectors on thin evidence.** It fired on a
+  point estimate above the ceiling, so a rule observed at 42.9% over `n=14` was
+  labelled "the rule is wrong, not the corpus" by an interval that comfortably
+  _included_ the ceiling. It now requires the Wilson interval to exclude the
+  ceiling from below, so a rule the data cannot yet distinguish from a
+  conforming one is told to gather more evidence first. **Nine rules moved from
+  `NEEDS-FP-REDUCTION` to `NEEDS-SAMPLES`**, and the document's own counts
+  change with them (28 → 19, 45 → 54).
+- **The same FP count was reconstructed two ways.** `measurementInterval` and
+  `compareFpMeasurements` handed `wilsonInterval` an unrounded `fpRate * n`
+  while this table rounded it — 10.5% of 19 is 1.995, and `wilsonInterval`
+  rounds internally, so the ratchet and the readiness table derived two
+  different `ciHigh` values for the same rule at the same n. Both round now. The
+  interval math was always correct; the defect was in what reached it.
+- **`samplesForZeroFp`'s cross-check was wrong.** Its docstring quotes two
+  `wilsonInterval(0, n)` values as the verification of the closed form. The
+  `n=34` figure was quoted as 0.1012; the function returns 0.1015. A
+  cross-check that fails when you run it reads as evidence and is not, so the
+  numbers are now asserted in a test rather than only in prose.
+
+### Three places a claim was checked by something other than the thing it claimed
+
+- **CONVERGENT did not mean convergence.** `groupByRootCause` fell back to
+  `ruleId`, and nothing in the tree assigns `rootCauseId` — the machine
+  contract reports it `null` on every finding — so the key for every group was
+  the rule. N independent defects from one rule across N files rendered as
+  "CONVERGENT — N findings share root cause QA-PW-002", which is the inverse of
+  the claim: several findings being one thing versus several findings sharing a
+  rule id. The fallback is now the finding fingerprint, `rootCauseId` still
+  wins the moment anything populates it, and the listed identities are distinct
+  — the old fallback made a three-finding group list one id three times, so a
+  consumer could not tell the members apart, and the same-file AMPLIFIED
+  conclusion it suppressed was being lost as collateral.
+- **Two glob compilers disagreed, and a gate used the wrong one.** `ignores.ts`
+  and `scan-pipeline.ts` each compiled globs, and they differed on `?` (a
+  metacharacter in one, a literal in the other) and on both forms of `**`. The
+  mass-suppression integrity gate reached into `ignores.ts` for its compiler
+  while the scan applied suppressions through `scan-pipeline.ts` — so it
+  measured the suppressed set in a different dialect than the one that
+  suppressed it, counting findings the scan never suppressed. Both now compile
+  through `src/lib/glob.ts`, which is the only implementation of the dialect.
+  One behaviour narrows: config `exclude` no longer reads `?` as a wildcard. No
+  shipped default or repository config uses `?`, and `*`/`**` are unchanged.
+- **An unparseable expiry was perpetual.** `new Date("2026-13-45").getTime()`
+  is `NaN`, and every comparison against `NaN` is false — so a suppression with
+  a typo in its expiry date was never reported expired and suppressed findings
+  forever. A date nobody can read now counts as expired; a suppression that
+  genuinely never expires must say so by omitting `expires`, which is a
+  decision someone made on purpose.
+
+`detectMassSuppression`'s threshold boundary was already `>=`; what was missing
+is that the boundary was stated nowhere, so "50%" read as "above 50%".
+
+### Deletions, and one that was hiding another
+
+- **`src/v6/tool-coverage.ts` deleted.** `ScanResult.toolCoverage` was declared
+  and never assigned by anything — no assignment exists in `src/` or `scripts/`
+  — so the block it assembled reached no surface, no report and no contract.
+  Its header claimed "the census gap list shrinks by 15 real entries"; that
+  reduction comes from `NOT_QA_TOOLING` in `ecosystem-census.ts`, which
+  classifies names regardless of who calls it. The module contributed nothing to
+  it. Recorded as a `DELETE` disposition in `docs/CARVE-MANIFEST.json` with that
+  evidence, rather than dropped from the record.
+- **Deleting it exposed a second gap.** Its only importer was
+  `src/v6/test-doubles.ts` — the false-proof detector, the module this product
+  is named after. Nothing in `src/` or `scripts/` has called it since. That is
+  now an explicit entry on the committed orphan list with the reason, rather
+  than a fact hidden by a dead import edge. The `DOUBLE_ONLY`/`TRUTHY` fix
+  landed on it in this release, so the logic is right and the wiring is still
+  owed. It is listed, not deleted: a thesis module that is unwired is a
+  product gap, and deleting it would make the gap invisible rather than gone.
+- **`src/scorer/scoring-validation.ts` deleted.** An orphan that documents four
+  scoring invariants and implements two, one of them vacuous. It also carried a
+  duplicate `SCORING_MODEL_VERSION` — `contract-versions.ts` owns that
+  constant and `scan-pipeline.ts` reads it from there. Fixing and wiring it
+  would have been strictly more code than deleting a module nothing runs.
+- **`--policy` no longer prints a scoring formula.** It read
+  `score = 100 · (1 − deductions / (findings + NORMALIZATION_K))`, which
+  contradicts `scorer.ts` on four counts: the denominator is test
+  _declarations_, not findings; `SMOOTHING_C` is missing from it;
+  `NORMALIZATION_K` multiplies the rate rather than sitting in the denominator;
+  and the `min(100, …)` cap is absent, so the line described a score that can go
+  negative. A table whose header says "every number here is imported, never
+  written down" was carrying a formula written by hand, and it was wrong. It now
+  names `docs/SCORING.md` and `scorer.ts` instead — a restated formula is the
+  same defect one layer over, and it drifts the first time the scorer changes.
+- **Three empty imports removed from `src/commands/milestone.ts`** —
+  `import {} from …` on three modules, which asserted a dependency the file
+  does not have.
+
+### One path check, three callers: a claim that names a deleted file is now a failed check
+
+Every artifact claim in this repository is a path inside a file — a
+`provisionalArtifacts` entry in `ROADMAP.yaml`, an `evidence` citation in the
+v6 inventory, a `regression_test`/`evidence_artifact` on an M26 ledger row.
+Three validators read those claims and all three asked the same weak question,
+"is this field a non-empty string?", so a citation to a module the v6 carve
+deleted validated clean. One check now serves all three, so a fourth caller
+cannot come back weaker.
+
+- **`docs:roadmap:backlinks` is wired into the release and nightly tiers.**
+  It was correct and red the whole time — reporting 19 missing provisional
+  artifacts — and in no tier at all. It now runs through `gates:claim-integrity`,
+  which is where a roadmap's artifact claims belong.
+- **The 19 dead `provisionalArtifacts` rows are deleted, not repointed.** M29,
+  M31–M36, M38, M39, M41, M43–M50 each declared an artifact the carve
+  removed. A successor is a different module answering a different question,
+  so citing one would turn "this was never built" into a claim that something
+  was.
+- **`docs/V6-CURRENT-STATE.md` and `docs/V6-GAP-MATRIX.md` are drift-locked.**
+  Only the JSON halves of these generated artifacts were ever compared against
+  a fresh render. The `.md` halves were hand-editable, which is how a
+  hand-edited line came to contradict the `docs/v6-inventory.json` beside it.
+  Both are now compared, and both sides are formatted in memory so the check
+  still never writes to the tree it inspects.
+- **A generated artifact may no longer cite a file that does not exist.**
+  Every repo-relative path in the rendered `.md` is now checked, which is what
+  found the 11 dead citations the §100 classification was still carrying. The
+  claims were corrected at source rather than in the rendered output: §59
+  (dashboard) and §66 (quality debt) are now `OBSOLETE`, which is the state
+  the enum had declared and nothing had ever used.
+- **M26 ledger rows are BLOCKED when a cited evidence path does not resolve.**
+  `regression_test` and `evidence_artifact` are the only pointer a closure
+  claim has to the thing that proves it. A `warning`, not an `error`: a row may
+  legitimately cite a path this checkout does not carry, and "unverifiable
+  here" is the honest status. The root is a parameter rather than a default,
+  so a record's validity never depends on the working directory.
+- **Hand-written prose deleted from the generators.** GAP-V6-005's summary
+  carried "14 of the 108" while the matrix beside it reported 18 — two
+  representations of one number, one hand-maintained, where the renderer
+  already derives the authoritative figure. The §38/§65 notes named
+  `pw-report` and `trend`, which are commands, as modules of `src/forensics`.
+  The `QA_DOMAIN_RECORDS` provenance column named a symbol that exists
+  nowhere in `src/`.
+- **"156 cells" was never true.** The support matrix carries 136 cells and 6 on
+  the language-framework axis. The figure was hand-written in source, so
+  regenerating could not have fixed it; the language manifest now names the
+  surface and points at the matrix that carries the count.
+- **`docs/ANTI-CREEP.md` pointed at `src/rules/tier-policy.ts`;** the module is
+  at `src/engine/tier-policy.ts`.
+- **`docs/MANUAL-SCRIPTS.md` claimed `docs:roadmap:backlinks` was wired into
+  the nightly tier.** It was not. It is now, so the row is gone — and the
+  script-reachability gate enforces that a script cannot be both a gate and a
+  manual tool.
+
+A gate that has never fired is not a gate: the rendered-markdown comparison was
+verified to fail on a planted hand edit and pass after reverting it.
+
+### False greens: three places a scan reported a stronger result than it had
+
+Every ordinary scan withheld 34 quarantined rules and reported nothing about
+it at three different surfaces. This release closes that gap. **These are
+user-visible status changes** — an `INCONCLUSIVE` finding is no longer
+`FIXED`, and SARIF `executionSuccessful` is now `false` on a scan that
+withheld rules. Existing baselines and saved reports will show the new,
+weaker claim; that is the point of the change.
+
+- **A quarantined rule could prove a finding "fixed" on a scan that never ran
+  it.** `analysisStatus` reported _how many_ rules were withheld but not
+  _which_, and lifecycle resolution — which decides one finding at a time —
+  had nothing to go on. A finding whose rule was filtered out disappeared
+  from the scan and rendered `FIXED SINCE BASELINE`. New optional field
+  `analysisStatus.withheldRuleIds` carries the set; `resolve()` returns
+  `INCONCLUSIVE` with a new `rule-withheld` cause when the finding's rule was
+  withheld. With `--strict` the rule runs and the fix resolves normally.
+  `schemaVersion: 1` is unchanged — both new fields are additive
+  (`docs/VERSIONING.md`).
+- **"FIXED SINCE BASELINE (verified by a complete same-revision scan)" was
+  false for every withheld scan.** The sentence claimed the whole scan was
+  complete; it now claims only what survived every guard — the rule ran, the
+  file was in scope, it no longer fires.
+- **SARIF called a `PARTIAL`-coverage scan fully successful.**
+  `executionSuccessful` was `!partial && rulesCrashed === 0`, and
+  `coverageState` is deliberately orthogonal to `partial`, so a scan that read
+  every file it was given and ran 45 of 79 detectors reported success to GitHub
+  code scanning. `executionSuccessful` now also requires
+  `coverageState !== "PARTIAL"`, with a `toolExecutionNotifications` entry
+  naming the withheld count and pointing at `--strict`.
+- **`analysisStatus.reasons` now carries `coverage:quarantine:<n>`,** which
+  `types.ts` already promised and nothing emitted. The flat reason set is what
+  a machine consumer reads, and it was empty for the one gap that affects
+  every non-`--strict` scan. `coverage:*` reasons are excluded from
+  report-io's `partial` markers, so disclosing coverage does not make a saved
+  report unloadable and does not turn ordinary scans into partial ones.
+- **A lone `expect(x).toBeTruthy()` was reported as a false proof.** The QA-IR
+  gives `TRUTHY` an `"ANY"` expectation — an explicit, evidence-bearing shape
+  — while the double-risk model did not list it as substantiating. The two
+  modules disagreed, so the assertion counted as neither substantiating nor a
+  double and fell into `DOUBLE_ONLY`: "every assertion is about a test double"
+  about a test with no double assertions, at a `hollowRatio` of 0. `TRUTHY` is
+  now substantiating, and `DOUBLE_ONLY` requires at least one double.
+- **The trust-trend report invented numbers.** `score` is `null` for a repo
+  with no tests, and `(last ?? 0) - (first ?? 0)` reported a fabricated
+  `+100` when a repo gained its first score. `scoreDelta` is now
+  `number | null` and the rendering says "not comparable". `overallDirection`
+  compared the _number_ of regression entries against improvements, so one
+  50-point drop lost to three 1-point gains and the trend read "improving" —
+  it now sums magnitude. `frameworkCount` was `1` whenever detection was known
+  (four detected frameworks and one rendered identically) and is now
+  `frameworks.length`. The `warnings > errors * 2` ratio degenerated to
+  `warnings > 0` at zero errors, reporting "weak assertions" for every repo
+  with warnings and none; it now requires a denominator.
+
+### Names: one command, one name
+
+`package.json` carried eight families of stragglers — two names for the same
+command, a name and its write arm under different spellings, and a chain whose
+members each had a name of their own. Nothing failed, because npm has no
+opinion and a second name is indistinguishable from a first one.
+
+- **`build --determinism` and `unimported --check` had twins.** `unimported:check`
+  and `check-unimported-modules` both ran `scripts/check-unimported-modules.mjs`;
+  `build:determinism` and `verify-build-determinism` both ran
+  `scripts/verify-build-determinism.mjs`; and so on for
+  `fp-audit:generate`/`generate-fp-audit-table` and `docs:rules`/`generate-rule-docs`.
+  A reader who typed the wrong one got the right answer and no signal that the
+  name was wrong.
+- **`check-cli-contract` is the gate that made it visible.** It reads
+  `docs/cli-contract.json`, which carries one disposition per verb in
+  `src/engine/cli-command-names.ts`, and it fails when two npm names resolve to
+  the same entry with the same argv, when a verb has no disposition, and when
+  any `.md`, workflow, or Action names an `npm run` script that does not exist.
+  A check arm and a write arm of one generator is **not** a duplicate — that is
+  a declared convention in eleven places — so the rule is about the command,
+  not the file.
+- **`corpus:regression`, `corpus:regression:update`, `corpus:resample` and
+  `corpus:regression:refresh-provenance` are now `corpus:audit` with flags.**
+  Same subject, four names. `scripts/resample-unmeasured.ts` became a guarded
+  module the audit imports rather than a second entry point.
+- **`rules:quad:check`, `rules:quad:write` and `corpus:quad:verdicts` are now
+  `check-fixture-quad` with flags.** The census's own report already told
+  readers to run `npm run check-fixture-quad --verdicts`, which was not a name
+  that existed.
+- **`version:check`, `version:surface:check`, `reporter:version-check`,
+  `changelog:check` and `changelog:unreleased` are now `check-version`.** It is
+  a file, not an npm chain, for a reason that bit during this change: `ci.yml`
+  runs the unreleased-entry check with `--base=origin/<base>`, and npm appends a
+  flag to the LAST command of a chain. A chain that is reordered by one line
+  routes the flag to a check that ignores it, and the step keeps reporting PASS
+  while comparing against an empty `git status` on a fresh CI checkout. The flag
+  now has exactly one consumer, dispatched explicitly, and any other argument is
+  a usage error rather than a silent no-op.
+- **`site:doctor` is now `doctor`**, and `doctor` runs the product's own
+  self-audit before the site's, so the name a maintainer types is the name that
+  diagnoses Mjölnir.
+
+### Carve 1.1 — twenty-two READMEs, and the gate that could only be met by deleting them
+
+`README.<lang>.md` existed for 22 languages, machine-assisted, each about a
+dozen sections behind the English file. `docs/TRANSLATION-RATCHET.json` recorded
+`translationsNotFresh: 22` against a ceiling of 22 — so the ratchet could only
+ever be satisfied by deleting the thing it measured, and the maintainer had
+already documented that the failing branch was unreachable for the shape of
+regression it was written for. It was, in the end, a gate that measured nothing.
+
+Deleted: the 22 files, the advisory report, the strict variant, the ratchet, the
+release-status sync, the shared language list, and the three specs that policed
+them. `README.md` is the only README. `docs/EXTERNAL-CONFIG.md` and the three
+gate rows in `gates/{pr,release,nightly}.json` were updated rather than left
+pointing at commands that no longer exist, and `tests/contract/gate-exit-codes.spec.ts`
+now asserts the machinery is _absent_ — a deleted gate is a hole with a comment
+on it, and the comment is the only thing that survives to be trusted.
+
+The relic that went with them: `package/README.md`, a hand-maintained 778-line
+copy of the root README that nothing read and that had drifted 62 lines behind
+its own source. `pack-audit` matches tarball entries by name, so the fixture
+directory was never a real one.
+
+### Phase 2 — the matrix and the gaps: a claim, and a work queue
+
+**`generate-certification-matrix`** writes `docs/CERTIFICATION-MATRIX.md` from
+three artifacts — the language manifest, the declared surface, and the cell
+records — and `--check` is a gate in all three tiers. The first output is
+**`0/100 cells certified`**, which is the honest number and not a failing state:
+a gate that blocks on progress reports nothing else.
+
+The header says what the percentage means on every rendering, because a bare
+percentage beside a language name is exactly the misreading §5.4 warns about:
+_"the fraction of this ecosystem's required detection surface backed by
+certified evidence"_ — **not** how trustworthy a language is.
+
+**`generate-certification-gaps`** turns each of those 100 open cells into an
+issue-ready entry: the ecosystem, the concept, the language and framework, the
+gate that fails, **the arithmetic of why**, and the floor that closes it. A gap
+entry that says "n too small" is a task description; one that says
+`precision n=0 is below 35` is a specification.
+
+**Gate D was unfalsifiable, and the generated report is what showed it.** It
+failed any cell whose concept had more than one language binding — which means
+no cell of the three-language concepts could _ever_ pass, and 40 of the 100 open
+entries listed gate D. Language parity is a property of the SET, computed by
+the ecosystem roll-up in the matrix; a single cell cannot answer it. What a cell
+_can_ answer is whether it names a language its concept is bound to, which is
+what gate D says now.
+
+**Seven missing manifest rows, added.** §5.1's table claims eleven ecosystems
+with none deleted, and seven had no row — so the matrix had nothing to print for
+GitHub Actions, Playwright, Cypress, Selenium, GitLab CI, Jenkins or Azure
+Pipelines. Every one is `DISCOVERED`, which is §5.1's own definition for "we
+have seen it exist"; `UNMEASURED` would claim a measurement nobody ran.
+`ECOSYSTEM_MANIFEST` and `ALL_ECOSYSTEMS` are the new names, with the old
+`LANGUAGE_MANIFEST` kept because four specs import it — renaming an export to
+fix a noun is a breaking change dressed as tidying.
+
+**Three PENDING-CONSUMER rows deleted themselves**, which is the mechanism
+working rather than a nuisance. `validate.ts`, `record.schema.ts` and
+`language-manifest.ts` were allowlisted because nothing imported them; the
+moment the matrix generator imported them the orphan gate said _"an entry that
+no longer describes reality is a lie in a data file"_ and failed. An exemption
+that outlives its reason is how a gate starts protecting things nobody
+remembers.
+
+### Phase 2 — the §6 cell record: counts in, verdicts out, and what the schema refuses
+
+**`src/certification/record.schema.ts`** — one record per
+`concept × language × framework`, as a JSON Schema plus a type-aware validator,
+following the repository's existing pattern (`src/config/config-schema.ts`)
+rather than buying a schema library for one file.
+
+**Three things the schema refuses, and one it cannot.**
+
+It refuses a stored Wilson bound in three places — the `not` clause, the
+`additionalProperties: false`, and the validator — because the plan's
+counter-example (`{fp: 5, n: 250, fpWilsonUpper: 0.02}`) reads as valid to
+anything that does not recompute it. It refuses one _nested_ inside the counts,
+which is where someone actually pastes a rate they just computed; a top-level
+check passes it. And it refuses `standard: "manifest-v5"` on a cell record.
+
+It cannot express `n === tp + fp`, so the validator does. An `n` that disagrees
+with its own parts asserts something the evidence beside it does not support —
+the arithmetic twin of the stored-bound defect, and one nothing recomputes
+because an integer looks final.
+
+**§5.2's two columns, spelled.** `CELL_STATES` is `v6-PENDING`,
+`v6-PARSEABLE`, `v6-CERTIFIED`, … and the validator rejects a bare
+`CERTIFIED`. TypeScript must read as `CERTIFIED (manifest-v5, n=240) · 0/9 cells
+(v6-abcdef, PENDING)` — the plan's own worked example, and the reason a cell
+state carries its standard in the name. A bare `PENDING` beside a `CERTIFIED` in
+the same row is a sentence two readers will contradict each other about.
+
+**§6.4's re-attachment needs an arm.** `legacyVerdicts[].arm` exists because
+multi-arm rules are real here: `TQUAL-001` carries a no-assertion arm and a
+mock-only arm, `PW-124` a project-split arm and a config-gap arm. Keying on
+`(oldRuleId)` alone would attach half a rule's verdicts to the wrong arm.
+
+### Phase 2 — `EXPECTED_CERTIFICATION_SURFACE`: the denominator, declared
+
+**`src/certification/surface-manifest.ts`** — 107 cells across all eleven §5.1
+ecosystems, each `REQUIRED` or `NOT_APPLICABLE` **with a reason**, plus
+`check-certification-surface` and its committed baseline.
+
+Without a committed denominator, "60% → 100%" is achievable by deleting the
+five cells that were not certified. That is the one move that improves every
+number in the report without anybody writing a fixture, and no metrics-only
+report can tell it from progress.
+
+Four properties, each with a test:
+
+- **The surface cannot shrink silently.** The gate compares the manifest
+  against a committed baseline, so a removal committed last month is still
+  visible today. A gate that compared the manifest against itself could not
+  see it at all — the change would already have passed.
+- **`REQUIRED` may grow freely.** Raising the bar is never gated; only
+  shrinking is, and only with `--acknowledge-surface-change=<why>`, which moves
+  the baseline and records the reason beside the new list.
+- **Every exclusion NAMES AN ALTERNATIVE.** `NOT_APPLICABLE` is a first-class
+  state and it is printed, but a reason that says only why _not here_ is a
+  deletion wearing a label. The gate rejects it; the plan's own example — a CI
+  concept on a Python ecosystem — shows the real shape.
+- **No cell names a concept the vocabulary does not have.** This caught three on
+  the first run: `frameloctor-…`, `ignored-exit-code-or-true` and
+  `trial-click-…` were ids I guessed rather than read, and a `REQUIRED` cell for
+  an undefined concept is a denominator entry nobody can ever close.
+
+**The three wave-C ecosystems with zero corpus repositories STAY.** Deleting
+GitLab CI, Jenkins and Azure Pipelines would improve every percentage in the
+report by removing the ecosystems nobody has measured. §5.1 retains all
+eleven; a wave is a ranking, not a deletion.
+
+**Two defects the spec found in the gate it was written for.**
+
+The gate computed `removed` and `added` with the _same_ filter over the current
+keys — so `removed` was really the added set, and a genuine shrink was
+invisible. The gate that exists to catch a shrinking denominator did not
+detect one. The fixture shrank the surface by a cell and the gate said PASS,
+which is how it was found.
+
+And the gate **swallowed a failure to read its own manifest**: with no
+`node_modules` in the fixture tree the `tsx` spawn failed, the error was
+ignored, and it printed `PASS — 107 cells`. A gate that reports a pass because
+it could not read its input is the loudest possible wrong answer, so an
+unreadable manifest is now exit 10 and says so. The fixture needed a
+`node_modules` junction for a different reason: it copied the gate and then
+invoked the _real_ one, which computes its root from its own location — so the
+mutation was applied to a copy nobody read, for three runs.
+
+### Phase 2 — the concept vocabulary, and the §6 contract that judges a cell
+
+**`src/certification/concepts.ts`** — 60 concepts covering all 79 rules,
+**generated** from the registry by `scripts/generate-concepts.ts`, **committed**
+for review, and **verified** by `tests/contract/certification-concepts.spec.ts`.
+The registry is the authority; the table is a claim about it a reader can check.
+
+A concept is a failure MODE and a rule is that mode in one language. The
+derivation is mechanical because the titles in this tree already assert the
+grouping: `QA-TEST-004` ("Hard sleep in test", TypeScript) and `QA-PY-005`
+("time.sleep() in test", Python) are different rules for the same concept, and
+§6 certifies `concept × language × framework` — so a concept that split them
+would certify one detector twice and report two cells where there is one.
+
+It yields 60 concepts where the plan says 32, because the plan's concepts are
+COARSER: it calls `test-cannot-fail` one concept, the tree calls it five ("Test
+without assertions", "Empty test body", "Skipped test", "Focused test",
+"Disabled test"). Both are defensible and they measure different things, so
+the fine cut is committed and the coarse groupings are expressible as a VIEW
+over it — additive and reviewable, where merging rows is not. The count is
+reported, not gated, which is the plan's own rule for counts.
+
+**`src/certification/validate.ts`** — §6 as code: six independent gates, counts
+in and verdicts out.
+
+**Counts are stored; intervals never are.** `CellEvidence` has no
+`fpWilsonUpper` field and `assertCountsOnly` rejects a JSON record that has
+grown one — walking the TREE, because the first version checked only the top
+level and `fpRate` nested inside `precision` is exactly where someone would
+paste it. The plan's own counter-example is `{fp: 5, n: 250}` with a stored
+0.02 upper bound: it looks valid to anything that does not recompute it.
+
+The thresholds are pinned by tests, because they are not round numbers:
+`n ≥ 35` is where a PERFECT 35-of-35 clears both a `≤ 0.10` FP upper bound and a
+`≥ 0.90` recall lower bound — `wilson(0,35) = 0.0989` and `wilson(35,35) =
+0.9011`. That coincidence is the entire justification for the concept bar, and
+`n ≥ 34` failing is asserted beside it, because a threshold nobody fails is not
+a threshold.
+
+**Three wrong readings of the Wilson bound, and the tests caught all three.**
+`wilsonInterval(x, n)` is a proportion of SUCCESSES. For precision the successes
+are the FALSE POSITIVES; for recall they are the TRUE POSITIVES. Reading `fn`,
+or reading the complement `n - tp`, gives a lower bound of exactly **0** on a
+perfect cell — the Wilson bound at p = 0 is 0 — so every cell in the repository
+fails gate B. The plan's own numbers settle it: `wilson(35,35) = 0.9011` is a
+lower bound on a cell with no failures.
+
+The tiering is asserted as a RELATIONSHIP rather than a comparison: the same
+24-of-24 evidence clears the cell bar (0.862 ≥ 0.80) and fails the concept bar
+(0.862 < 0.90, and `n = 24 < 35`). That is the reason §5.5b has two tiers, and
+an assertion comparing a bound to a count would have passed for no reason at
+all — which is what the first version of that test did.
+
+**One commit-time self-caught defect.** Registering the two new npm scripts, the
+first draft was `check-concepts: "… generate-concepts.ts"` plus
+`generate-concepts: "… generate-concepts.ts --write"` — two names, one file,
+one command. That is the exact straggler pattern Phase 0 existed to remove,
+committed by the person removing it, and caught by the gate built for the
+purpose.
+
+`validate.ts` is on the orphan list as `PENDING-CONSUMER`, with the reason that
+its first production caller is `generate-certification-matrix.ts`. It is filed
+as pending rather than as an exemption on purpose: this gate fails an allowlist
+row that something now IMPORTS, so the row disappears the moment the matrix
+generator lands.
+
+### Carve 1.6.1 — the order-dependent pair, and why they are still reachable
+
+The plan marks `historical-trust.ts` and `machine-contract-verification.ts` as
+deletable **only** after `commands/milestone.ts` stops needing them, and says to
+do it here rather than in 1.5 for exactly that reason. Every refactor that
+removed a verb left `milestone.ts` as the home of the survivors, so two modules
+on the delete list stayed reachable through a filename that no longer described
+what the file was.
+
+`commands/milestone.ts` went from 1,049 lines to 463, split along the seams it
+already had:
+
+- **`milestone-args.ts`** — the arg parser, the target validator and the
+  workflow-file check. Seven commands used them and they are **shared**, not
+  copied seven times: a flag rule that exists twice can disagree with itself,
+  and the copy a pipeline runs is the one that has to be right.
+- **`contract-verify.ts`** — the ~280 lines of nested type guards that decide
+  whether a file on disk is the document the tool claims it wrote, plus the
+  command.
+- **`release-trend.ts`** — the trust-snapshot history and `ci release-trend`.
+
+**The two engine modules stay, and `docs/cli-contract.json` records why with
+their importer named.** `contract-verify` is a live verb (the plan's merge into
+`ci verify` is a behaviour change to a live command, recorded as
+`plannedTarget` rather than done), and `ci release-trend` is a live subcommand.
+The delete list was written when those verbs were going away; the capability
+moved rather than vanished. "On a delete list" and "reachable from three
+places" are both true, and only one of them is a reason to delete.
+
+A range extraction cannot see what a slice depended on, and the compiler listed
+all 300 resulting errors. Four of them are worth recording because each is a way
+this goes wrong quietly:
+
+- `ContractDocument` is `ScanResult & { contract }`, not a wrapper with a `scan`
+  field. I guessed the wrapper. A persisted contract artifact is the scan with
+  its own verdict attached, and a reader that has to know which of the two
+  shapes it holds is a reader that will hold it wrong.
+- `MilestoneArgs` was declared _above_ the extracted range, so the module that
+  PARSES it no longer contained it. A type with three homes is a type with
+  none; it belongs where the parsing is.
+- `STRICT_SUPPRESSION_POLICY` sat immediately above the range and stayed behind
+  with its only reader gone — moved down to it.
+- `ContractDocument` ended up declared in two of the new files, because a
+  declaration and its first use can straddle a boundary. Two identical copies
+  are invisible to the compiler, which is the reason to look for them by hand.
+
+### Carve 1.6 (MOVE arm, group 3) — three internal verbs folded, two arrows that do not connect
+
+`pw-report`, `framework-maturity` and `doctor:playwright` all fold into flags —
+`explain --playwright`, `doctor --frameworks`, `doctor --frameworks` — which is
+what the plan calls INTERNAL for all three: none is a capability a reader is
+meant to reach for. `doctor --frameworks` is a FLAG and not a second
+`argv[0] === "doctor"` branch, because `tests/contract/readme-commands.spec.ts`
+reads those literals as the known subcommand set and one verb with two entries
+in it is a set that no longer means what it says.
+
+**Three of the plan's arrows do not connect, and the contract says so.**
+
+- `contract-verify` → `ci verify`. `ci verify` is the BLOCKING CHECK and does
+  not run the machine-contract or exit-code validators. Folding it is a
+  behaviour change to a live command, not a rename, so the verb, the
+  implementation and its eleven tests stay and the row reads
+  `plannedTarget: ci verify` with the reason.
+- `analyze` → `explain`. `analyze` is CROSS-FILE analysis — shared imports,
+  duplicated blocks, circular dependencies — and its findings reference
+  multiple files. `explain` answers "what does this finding mean"; making it
+  answer "which files import each other" would give a verb a capability it
+  does not have.
+- `handoff` → `install agent-rules`. `install` writes agent INSTRUCTION
+  surfaces; `handoff` renders a deterministic remediation plan from a saved
+  report. One configures an environment, the other renders a document an agent
+  can execute.
+
+**Two routing bugs the collapse introduced and this step fixed.**
+
+- `mjolnar ci install --help` started running the installer. The `--help` rule
+  was positional in its first form and had a second special case for the
+  three-token case; the collapse generalised the first and deleted the second,
+  taking the `ci install --help` path with it. The rule is now "a `--help`
+  anywhere in the invocation asks for help", which is the rule that was always
+  true.
+- `mjolnar ci verify --help` rendered **`ci install`'s** page, because the
+  dispatcher built the subject as `ci:install` and the catalogue keys it
+  `"ci install"` — a space, because no verb name contains one. A `:` was
+  chosen to avoid colliding with `doctor:playwright`, which read as clever
+  right up to the moment it sent a reader to a page that does not exist.
+
+The root help also no longer prints a section whose verbs are all retired: the
+collapse emptied two groups and left the headings, and a table of contents that
+promises a section it does not have is the same class of claim as a command
+that does not exist. The `GROUPS` list itself was rewritten to name the fourteen
+entries the catalogue actually has — it used to list twenty-nine, of which the
+renderer silently skipped twenty, so the file read as a graveyard.
+
+`tests/cli/help.spec.ts` gained a sweep that renders every catalogue entry and
+both composite pages and asserts none names a retired verb, reading the
+retirements out of `docs/cli-contract.json` rather than listing them. The
+pattern covers slash-separated tool lists as well as invocations, because the
+`mcp` line carried three retired names in that shape and the narrower sweep was
+blind to it.
+
+### Carve 1.6 (MOVE arm, group 2) — five capabilities became `explain` arms
+
+`explain` is the question verb. Five capabilities were top-level verbs that all
+answer a variation of that question, and each is a flag on it:
+
+| Was          | Now                   |                                                       |
+| ------------ | --------------------- | ----------------------------------------------------- |
+| `rules`      | `explain --list`      | the rule catalogue, with each rule's measured FP rate |
+| `why`        | `explain <file:line>` | already an arm — see below                            |
+| `cross-file` | `explain --callers`   | who calls this symbol                                 |
+| `handover`   | `explain --plan`      | who owns what, and what to do next                    |
+| `triage`     | `explain --evidence`  | runtime evidence from a real run                      |
+
+**`why` never moved.** `explain` has delegated the `file:line` subject form to
+that command since before the collapse, so retiring the verb removed a second
+name for a capability `explain` already had. The cheapest MOVE in the set and
+the one most likely to be got wrong: `mjolnir why file.ts:12` is now a usage
+error, and the fix is a different word in the same position.
+
+`--playwright` is the internal arm (the plan says so), and it is marked as such
+in the table. `pw-report` summarised a Playwright run for a person reading CI
+output; the same information arrives through `--evidence` once that arm reads a
+report rather than one runner's format, and one flag that means "the run
+summary" beats two that mean it for one of them.
+
+The arms table has the same shape as `CI_SUBCOMMANDS` and for the same reason:
+it is the single source the dispatcher reads **and** the help renders from.
+Arms are dispatched **before** the subject is read, because `--list` and
+`--plan` take no subject and the subject check is what `mjolnar explain --plan`
+would otherwise have hit.
+
+**One residue worth naming.** `cli-handlers.ts` carried
+`import {} from "./forensics/triage.js";` — an empty import left behind when the
+`triage` VERB was retired, because every specifier in that statement became
+unused and the statement survived. Legal TypeScript, imports nothing, and it
+points at the file a maintainer would go looking in for where triage lives.
+
+The generator of the 101 rule-doc footers was fixed before the files were, so
+`mjolnir rules --md` did not come back on the next `npm run generate-rule-docs`.
+The 22 PRESERVED retired-rule pages still name it, correctly: they record what
+a rule said while it existed, and the gate now skips a rule doc whose ID is not
+in the live registry — a fact read from the registry, not a pattern exemption.
+
+### Carve 1.6 (MOVE arm, group 1) — five verbs became `ci <subcommand>`
+
+`ci` is the right home for all five, and the word is not incidental: each one is
+a check a pipeline runs, and `ci` is already the verb whose meaning is "the
+thing a pipeline does".
+
+| Was               | Now                  |                                                         |
+| ----------------- | -------------------- | ------------------------------------------------------- |
+| `ci-adapter`      | `ci adapters`        | which ecosystems can be analysed, and how well          |
+| `ci-integrity`    | `ci integrity`       | the generated workflow is itself correct                |
+| `verify`          | `ci verify`          | run the blocking check and the suppression policy       |
+| `release-trust`   | `ci release-trust`   | the signed measurement release's trust record           |
+| `trust-trend`     | `ci release-trend`   | how that record has moved across releases               |
+| `contract-verify` | `ci verify` (merged) | its two checks are the judgement `verify` already makes |
+
+`integrity` and `verify` are the sharpest case in the whole collapse: as
+top-level verbs, `mjolnir integrity` and `mjolnir verify` read as two
+products that happened to share a surface nobody could see from the command
+list. `contract-verify` is recorded as a **merge with its destination named**,
+not a rename — "the checks went somewhere" has to be checkable.
+
+**The table is the claim.** `CI_SUBCOMMANDS` in `src/cli.ts` is one object, the
+dispatcher reads it by name, and `mjolnir ci --help` renders from it — so a
+subcommand that exists is documented and one that is documented exists. A
+dispatcher with five inline `if` arms plus a separate help string is how the two
+drift apart, and this repository has that shape somewhere in every other
+subsystem. An unknown subcommand names the known ones and exits 10.
+
+Two routing bugs the collapse fixed on the way: `ci --help` rendered the ROOT
+help, and `ci verify --help` rendered **`ci install`'s** help, because the
+`--help` rule hardcoded `["ci", "install"]`. Both are now derived from the
+request rather than from a constant.
+
+### Carve 1.6 (REPLACE arm) — four verbs became flags, and two could not
+
+`scan` gained three `--format` values and three modes:
+
+| Retired verb       | Replacement                    | What the flag is                                                                               |
+| ------------------ | ------------------------------ | ---------------------------------------------------------------------------------------------- |
+| `trust-report`     | `scan --format trust-report`   | the terminal render, spelled out                                                               |
+| `pr-comment`       | `scan --format pr-comment`     | the same renderer plus the stored-baseline diff, so a comment can still say RESOLVED           |
+| `summary`          | `scan --format github-summary` | named after its CONSUMER, because `summary` was ambiguous with the terminal's own summary band |
+| `suppressions`     | `scan --suppressions`          | the ledger, now reading the TARGET rather than the cwd                                         |
+| `suppression-gate` | `scan --suppression-gate`      | **delegates** to the command; the flag lands first                                             |
+| `policy`           | `scan --policy`                | the SCORING table, printed from the constants                                                  |
+
+`scan --policy` is the new file here: `src/scorer/scoring-policy.ts` imports
+`NORMALIZATION_K`, `SMOOTHING_C`, both ceilings and the deduction-mass bands
+and renders them, so the table cannot drift from the code that scored the run.
+The `NORMALIZATION_K` line says **declared, not fitted** in the table itself,
+because printing a bare `5` among measured numbers reads as a measurement, and
+it is not one.
+
+**Two of the plan's REPLACE rows were not honest replacements, and are recorded
+as pending rather than done.** `stats → scan --json` would replace a milestone
+ledger with a scan result — a different document wearing the same name. `rules →
+explain --list` and `why → explain <file:line>` name arms that do not exist
+yet. And `policy` keeps its verb, because `mjolnir policy init` and
+`validate` manage `mjolnir.policy.json`, a file that gates CI; folding a
+subcommand tree into a flag would lose both. Each row in
+`docs/cli-contract.json` now says what is missing, because "the plan says so" is
+not a disposition.
+
+`--suppression-gate` delegates rather than reimplementing: a governance rule
+that exists twice can disagree with itself, and the flag and the command are
+the same judgement, so the flag synthesises argv and calls it.
+
+### Carve 1.6 slice 2 — `mutation`, `forensics` and `triage`, and a directory that had to stay
+
+The `mutation` verb is gone with `src/mutation/` (501 lines): reading Stryker
+and Mutmut reports is reading another tool's opinion of the code, and the
+directory had no importer but the verb's own runner. Two fuzz harnesses are
+narrowed rather than deleted, and the loss of mutation-format fuzz coverage is
+recorded here rather than left in a file that was about to be deleted.
+
+**`src/forensics/` stays.** The plan makes `forensics` a DELETE, and the verb
+is deleted — but the import graph says the directory is not dead:
+`evidence-hygiene.ts` is imported by `commands/trust-report.ts` and
+`integrations/github/evidence-sanitization.ts`, the path the GitHub Action's PR
+comment goes through, and `triage.ts` is imported by `mcp/server.ts` under a
+parity contract. Deleting 2,600 lines by name would have broken the PR commenter
+and the MCP server, and the diff would have been green. That is the plan's own
+"names are not evidence" applied to a directory the plan did not enumerate.
+
+`triage` is a MOVE to `explain --evidence` and the flag lands with the next
+slice, so the contract records `targetStatus: PENDING` rather than claiming the
+capability has arrived. The verb goes now so nothing can depend on it; the
+capability arrives when the flag does.
+
+**The generated output was naming the dead tool at users.** `FLAKY.md` and
+`TRIAGE.md` stamp themselves "Generated by `mjolnir triage`" — a string
+written into a file a user commits to their repository, asserting a command
+ran. Both now name Mjölnir and the data source instead, which is both true and
+stable across the verb's next move.
+
+One source-layer miss worth recording: the rule `fix` strings that told users
+to run the retired verbs live in `src/rules/`, and I edited the _generated_
+`docs/rules/*.md` first. `npm run generate-rule-docs` would have put them
+straight back — the same class of bug as the hardcoded `@v3` in the
+translation sync, one level up. The rules are the source; the docs, the site
+pages and the demo report are all downstream of them, and changing a generated
+file without changing its generator is a decision that survives exactly until
+the next regeneration.
+
+Two artifacts turned out to be hand-maintained with no writer:
+`assets/readme/demo-report.json` (four readers, no generator) and
+`packages/playwright-reporter/` (unpublished, 0.1.0, its whole description
+about the three retired verbs). Both are noted rather than quietly patched; the
+reporter is a Phase 7 decision, since its output format is still what the
+evidence path will read.
+
+### Carve 1.6 (DELETE arm) — ten verbs removed, and every place that named one
+
+`badge` · `debt` · `impact` · `trend` · `exec-report` · `dashboard` ·
+`baseline` · `diff` · `create-rule` · `init` are gone: the command module, the
+`cli.ts` `VERBS` row, the `argv[0] === "…"` literal that
+`tests/contract/readme-commands.spec.ts` reads, the import and re-export lists,
+the `cli-handlers.ts` runner, the help-catalogue entry, and 117 tests across 27
+spec files — four of which were deleted outright because the removed verb was
+their entire subject.
+
+**A verb's disposition is about the verb, not the module.** `baseline` is the
+case that would have shipped a green build and a broken product: the module is
+imported by `stats.ts`, `verify.ts`, `mcp/server.ts` and
+`reporter/pr-report-shared.ts`, so deleting it with the verb would have broken
+the MCP server, the PR reporter and `verify`. The module survives as a shared
+reader with a header that says so; the verb does not, because a stored
+"yesterday was fine" is the same trust-the-green-check failure the product
+exists to catch. That is the plan's own instruction — _names are not evidence_ —
+applied to an object it did not name.
+
+**The suggestions the product printed were the bug nobody filed.** The
+reporter's `nextStep` strings are not documentation; they are the next thing
+printed into the terminal. `nextStep("mjolnir diff")` in a product whose `diff`
+was retired in the same commit is a command that does not exist, in the one
+place a user is guaranteed to be looking. `check-cli-contract` treats `src/`
+as a live surface for exactly this reason, and it is why `src/` was swept too
+rather than left to a later documentation pass.
+
+**The contract is now a record of removals, not only of presences.**
+`docs/cli-contract.json` gained `retiredVerbs`, and the gate learned to check
+it: a `DELETE` row for a verb that has left `cli-command-names.ts` must appear
+in `retiredVerbs` with the commit that made it, and a `retiredVerbs` entry for
+a verb that is still registered fails too. Ten verbs retired; the gate now
+fails any README, site page, workflow, Action or source string that names one.
+
+Follow-through, all of it found by gates rather than by looking: three coverage
+exemptions whose subject is gone, three `vitest.config.ts` coverage exclusions,
+two degradation exemptions, the dashboard-template assertion (which asserted
+"exactly one generator" and became vacuous when the generator was deleted, so
+it now asserts the invariant that still has teeth — that two renderers cannot
+both claim a band), and the demo asset, regenerated.
+
+`forensics` stays. The plan makes it a DELETE too, and it will be — its
+subsystem and the `triage` relocation into `explain --evidence` are the next
+slice. Its row says KEEP until they land, because a contract that asserts a
+deletion the binary does not honour is worse than one that is merely out of
+date.
+
+### Carve 1.5 — 14,986 lines of unwired modules, and one the plan got wrong
+
+Nineteen modules with zero importers, all nineteen already on the committed
+orphan list, all nineteen with a dedicated spec file that imported nothing but
+them. A module with a test and no caller is the shape that makes dead code look
+alive: `tests/` counted as coverage of a file the product never reached.
+
+Deleted: `evidence-artifacts` · `finalize-scan-result` · `pipeline-stages` ·
+`semantic-model-api` · `runtime-evidence-graph` (1,857 lines) ·
+`runtime-static-correlation` · `coverage-ingestion` · `evidence-enforcement` ·
+`reporter/sarif-compliance` · `m38-challenge-contract` ·
+`m43-system-of-systems` · `m44-historical-intelligence` (2,247) ·
+`m49-experience-parity-contract` · `bench/m48-scale-operating-model` ·
+`governance/m33-m34-contract` (2,745) · `qa/domain-model` ·
+`frameworks/universal-pack-contract` · `plugins/sdk-contract` ·
+`mutation/failure-sensitivity` — and their twenty specs. Nineteen stale
+allowlist rows went with them, because a row describing a file that no longer
+exists is the same lie as a row describing a file something now imports.
+
+**The plan listed a twentieth as a true orphan, and it is not one.**
+`src/engine/evidence-graph.ts` has two importers and is shipped-reachable —
+`src/commands/milestone.ts` is one of them, which is the command that serves
+the `evidence-graph` verb. Deleting it would have removed the only way to reach
+a query surface the §3 table does not even mention. It stays, and
+`docs/cli-contract.json` now records the import-graph evidence rather than the
+plan's assertion.
+
+The check that caught it is worth naming, because the first version of it was
+wrong: it resolved the plan's bare filenames (`evidence-graph.ts`) against
+`src/`, where they do not live, so the import graph returned an empty importer
+list for all twenty and every one of them looked like a safe deletion. The
+files are under `src/engine/`, `src/bench/`, `src/governance/`, `src/qa/`,
+`src/frameworks/`, `src/plugins/` and `src/mutation/`. A graph lookup that
+answers "no importers" for a path that does not exist is not evidence of
+anything, and the plan's own instruction — _names are not evidence_ — applies
+to the plan's file list exactly as it applies to the tree.
+
+### Carve 1.3 — the brand self-audit survives, and its header stopped lying
+
+`npm run brand:doctor` is a nine-rule self-audit over a six-node graph, and
+it still passes 9 of 9 with an empty `KNOWN_OPEN` ratchet. The tokens stay:
+`src/brand/tokens.ts` is load-bearing for the reporter, the site theme, the
+README generators and the mark hashes, and `assets/brand/tokens.json` is
+byte-locked against it.
+
+What changed is the gate's own description of the tree. It said the badge
+drift appeared "in all 23 READMEs" and referred to a `site-doctor` check by a
+name that no longer exists. "Every README" is now one file plus five generated
+bands, and the rule did not weaken to reach that number — the twenty-two
+translations were never a distinct edge, they were copies of the same badges,
+and the copying is what made the drift expensive.
+
+Site gate after the step: `gen`, `test`, `doctor` (0 of 8 failing), `build`,
+with no generated drift.
+
+### Carve 1.2 — the 86-second tour drew a command the product will not have
+
+`assets/video/script.tour.json` rendered `mjolnir forensics
+./test-results/`, and `forensics` is a DELETE verb in the v6 CLI collapse
+(plan §3). A committed render script is evidence: it is what the renderer
+is allowed to draw, and it was drawing a command that will not exist.
+
+Removed: `captureTourScript()`, the `tour` script id, `script.tour.json`,
+the `tour` arm in three contract specs, the `both|demotour` choice on the
+`demo-video` workflow, and the tour rows in the video README. Order mattered —
+this runs before the CLI collapse so the three specs that re-run the capture
+and fail on drift stay green instead of going red on a verb the carve was
+about to remove.
+
+The hero stays. Its story — a false-green CI gate found, fixed, re-proved —
+is the whole positioning, and it uses only verbs the collapse keeps.
+
+One behaviour change while the file was open: rendering no longer overwrites
+the committed MP4. `publishDemo()` used to run unconditionally after any
+render, so a manual workflow dispatch replaced two binaries the README links
+to without asking. Publishing is now an explicit `--publish`, which
+`npm run docs:video:render` passes, so regenerating the shipped asset is
+unchanged for a human and safe by default for a workflow.
+
+### The Action major tag every reader was told to pin did not exist
+
+`action.yml` documented `uses: Sergey-Bar/Mjolnir@v3` while the published stable
+was **5.0.0** — and `scripts/readme-release-status.mjs` did not merely inherit
+that, it re-wrote it. Every translation sync ran
+
+```js
+replaceAll("Sergey-Bar/Mjolnir@v1", "Sergey-Bar/Mjolnir@v3");
+```
+
+so twenty-two translated READMEs instructed every non-English reader to pin a
+tag the repository stopped moving at 3.x, and the next sync put it back. A
+hardcoded major is a syntactically valid ref; it fails for the reader as a 404
+and for nobody in this repository.
+
+The sync now derives the major from the released version, and
+`tests/contract/census-drift.spec.ts` sweeps every live surface for a
+`Sergey-Bar/Mjolnir@vN` that is not the published major, with the same
+dormant-shape and match-count discipline the census sweep already uses.
+
+### The carve manifest: 28 files, and the one that mattered
+
+Phase 1 removes ~10,000 lines across twenty areas. The cheapest way for that to
+go wrong is for a reviewer to trust a folder name, and the plan's own evidence
+says not to: `src/ledger/` reads like bookkeeping and is 2,856 lines of M26
+validators that four scripts import. So `docs/CARVE-MANIFEST.json` records, per
+file, who imports it, whether it ships, which specs name it, and how big it is —
+generated facts, hand-written dispositions that survive regeneration, and a gate
+(`npm run check-carve-manifest`) that fails when the two disagree.
+
+All 28 files start at KEEP. Nine have no importer; every one of them was already
+on the disclosed orphan list, so the manifest found no new dead code — it found
+the size of the code that a directory name would have hidden.
+
+The gate also fails on the case a directory-based review cannot see: a file that
+left the tree without a DELETE disposition. That is the difference between a
+reviewed removal and an accident, and it is one field.
+
+### Claim integrity — the gates that could not fail
+
+Every item here is a check that was running, reporting, and could not have
+failed. The pattern is one defect wearing a dozen hats: a value that looked
+load-bearing and held nothing.
+
+- **`coverage:ratchet` measured a truncated run.** It read
+  `summary.total` and never counted files, so a two-file run of a 292-file
+  tree passed at 97.92% — and a partial run reports _higher_ percentages than
+  a complete one, because the files that survive are the easy ones. It now
+  asserts a file-count ratio and a non-trivial denominator, both fail-closed.
+- **`nForZeroFp` said 1.** The expression `z²·p / (p·(1−p)) − z²` simplifies to
+  `z²·p/(1−p)` ≈ 0.427, and `Math.ceil` turned that into 1 — so every
+  straddling rule read "About 1 clean sample would settle it". The correct
+  value at the 10% ceiling is **35**.
+- **`docs/rules/` and the registry both claimed the core tier, differently.**
+  `effectiveTier` now resolves it everywhere, including dedup survivor
+  resolution, where an undeclared rule defaulted to `core` and outranked every
+  rule that had declared `extended`.
+- **The capability registry resolved evidence once for the whole registry.**
+  One measured rule anywhere made `hasMeasurement` true for every capability,
+  and `ci.provider.azure-pipelines` was advertised on an unrelated Java rule's
+  measurement. Evidence is resolved per entry now.
+- **`OVER_CLAIMED_MATURITY` compared a value with itself.** `proven` and
+  `maturity` were assigned from one call, so the gate could not fire. They now
+  come from two resolvers — the census declares, the registry proves — and a
+  provider whose evidence beats the ledger is visible as such.
+- **`STALE` was unreachable.** The FP-audit generator filtered stale
+  measurements out of `MEASURED_FP`, so `hasStaleMeasurement` was
+  structurally always `false` and `QA-PY-004` (42 hand-classified verdicts,
+  one detector revision behind) reported as never sampled. `MEASURED_FP_RAW`
+  keeps them and both consumers read it.
+- **The claim registry had no recency budget.** `observedAt: null` satisfied
+  its presence check, so a 2026-06 observation read like yesterday's.
+  Per-type budgets now apply, the digest check runs against a real status
+  instead of a value absent from the enum, and every `BLOCKED` claim carries a
+  `blockedReason` and a review date.
+- **The tier ratchet was vacuous on an empty tier.** `MAX_UNMEASURED_CORE = 0`
+  was satisfied by a set with no members, so the first core promotion would
+  have arrived with the check already green. A rule is now accounted for by ≥10
+  classified verdicts **or** by an unexpired `corePromotion` naming an owner.
+- **The anti-creep law had two escapes.** The exception marker was searched
+  for across the whole append-only changelog, so one marker in any past
+  release disabled the ratchet for good — and with an empty tier and a zero
+  baseline, the first promotion would have switched the law off permanently.
+  The comparison is also now against `previousBaselineCore`, so lowering the
+  baseline to match a grown tier no longer hides the growth.
+- **The census could call an ecosystem `SUPPORTED` with a fixture
+  directory as its only evidence.** `SUPPORTED` now requires an adapter **and**
+  a verified four-leg quad, which demoted 33 entries — the honest result, and
+  the reason 19 rules were demoted in 6.0 for the same reason.
+- **Two hardcoded-`false` quad resolvers, in two files.** They could not fail
+  and the census's directory-size proxy answered a different question from the
+  registry's `false`. Both now read one filesystem probe.
+- **Seven gates ran only locally.** `qa-ir:parity` and `check-unimported-modules` were
+  on a nightly cron, so a PR that broke either passed CI and failed on the
+  maintainer's machine. The other seven are new here. All nine are in
+  `gates:claim-integrity`, which `ci.yml` runs as one step — named per gate
+  inside the chain so a failure identifies itself — and declared in all three
+  `gates/*.json` tiers.
+
+### New gates
+
+`npm run gates:claim-integrity` chains the nine claim-integrity checks so a
+failure names its gate instead of a step number. Also new: `workflow:scripts`,
+`config:consumers`, `scripts:reachable`, `translations:ratchet`,
+`docs:provenance-drift`, `check-fixture-quad`, `rules:promotion:check`,
+`check-changelog`.
+
+### Deliberate omissions
+
+- **The 4-leg fixture backfill (148 legs) is not in this change.** The plan
+  requires the quad to be _executed_, not merely present; writing 148 legs
+  no detector had run against would have made `check-fixture-quad` green by
+  construction. `npm run check-fixture-quad` prints the work list — 53 rules
+  have `MUST-FIRE`, 40 `MUST-NOT-FIRE`, 75 `RECALL`, **0 `PRECISION`**, and 0
+  of 79 have all four — so the backfill is driven by data rather than memory.
+  `PRECISION` is zero because it demands a classified `TN` on a negative
+  fixture, and no fixture has been classified as silent.
+- **`gitlab-ci` is written but not registered.** The adapter exists and three
+  detection classes are already enumerated in `src/adapters/gitlab-ci.ts`, but
+  it has no rules, so registering it would trade one false claim for another.
+  Admitting it means writing the three rules with fixtures, and it is gated by
+  the same quad as everything else.
+
+### PR reports say what to do next (#698)
+
+`src/reporter/pr-report-actions.ts` turns a PR comment from a finding list into
+a handover: each band names the action it implies, so a reader who disagrees
+with a verdict can see which command contradicts it without reading the source.
+Six score badges (`assets/brand/pr-status/*.svg`) are generated from the brand
+tokens by `npm run brand:pr-status` and drift-locked by
+`tests/reporters/pr-report-actions.spec.ts`, which fails if a badge's stroke
+stops matching the token it came from. `brand:pr-status` is a deliberate brand
+change, so it is declared manual in `docs/MANUAL-SCRIPTS.md` rather than wired
+into a gate.
+
+### The website reading stack, and the palette it arrived with (#696)
+
+A quieter, cooler set of greys and a teal→violet accent rule for the landing and
+guide surfaces, plus `docs/AI-DISCOVERY.md`, `site/public/llms.txt`, the guided
+proof walkthrough, and vendored Nordic and Cascadia fonts.
+
+The palette arrived as raw hex inside the theme stylesheets, which is exactly
+what `brand-doctor` rule 6 exists to catch: a second palette no gate could see.
+It is now nine tokens in `BRAND` — `readingAccent`, `readingAccentAlt`,
+`readingFocus`, `readingAccentBright`, `readingAccentInk`, `readingUnworthy`,
+`readingMuted`, `readingDim`, `readingLede` — emitted as `--mj-reading-*` and
+referenced by the stylesheets that use them. Putting them in `BRAND` rather than
+a group of their own is deliberate: rule 8 computes WCAG AA for every foreground
+in `BRAND` against every surface, so the nine are held to the same floor as the
+terminal palette rather than escaping it. The weakest pairing is
+`readingAccentAlt` on `soft` at 5.75:1.
+
+These are scoped to the reading surfaces. `steelDim` and `heroMuted` keep their
+values for the terminal, the README artwork and every other surface — the POC
+never claimed otherwise.
+
+### Known open, deliberately
+
+**Publishing a package is not certifying it.** 5.1.0 is on npm; that is a
+statement about distribution, not about evidence. The candidate manifest remains
+`WORKING_CANDIDATE` / `NOT_CERTIFIED` / `NOT_AUTHORIZED`, and nothing in this
+release moves those states.
+
+Four gates report `BLOCKED` on `npm run release:verify` and did not gate this
+publish:
+
+- **`m26:audit`** — no consented external execution and no holdout proof.
+- **`candidate:readiness`** — no real-world, platform-matrix or
+  consumer-install evidence.
+- **`candidate:decision:release`** — the same, adjudicated as a release-stage
+  decision rather than an engineering one.
+- **`docs:roadmap:check`** — 69 support-matrix cells are explicitly `BLOCKED`
+  and `docs/M26-EXTERNAL-VALIDATION.json` records external validation as
+  `BLOCKED`, not `COMPLETE`. This is the same missing evidence read through
+  the roadmap ledger, and it is a reporting gate: `stable-release.yml` does not
+  run it. It has read this way since the v6 carve — no commit since then has
+  touched `docs/M26-SUPPORT-MATRIX.json`, `docs/M26-EXTERNAL-VALIDATION.json`
+  or `docs/M26-GAP-LEDGER.jsonl`.
+
+The first three still run and still print on every publish; they stopped blocking
+only because a person recorded `vars.STABLE_RELEASE_AUTHORIZED=true`
+(`stable-release.yml`, `Candidate evidence`). `npm run ci-local` passes, because
+`candidate:decision:engineering` clears every engineering blocker.
+
+This is the designed state for 5.x, not a workaround. The alternative — editing
+the manifest to claim `REMOTE_PROVEN`, `CERTIFIED` or `AUTHORIZED` — is the
+false-green this project exists to prevent.
+
+## [5.0.0] — 2026-09-27
+
 ### Breaking changes
 
 - **`business-case` no longer prints a dollar figure you did not supply.** The
@@ -47,6 +2943,18 @@ once shipped, so this file is the record of what changed between versions.
   The generation timestamp moved out of the visible body into
   `<meta name="mjolnir-generated-at">`, and `--deterministic` omits it entirely
   so the artifact is byte-identical and can be diffed in review.
+- **`mjolnir report` no longer publishes a test-run status.** The top-level
+  `status` was computed from the findings
+  (`partial ? "interrupted" : hasError ? "failed" : "passed"`), so a clean scan
+  wrote `{status: "passed", totalTests: 0}` — the first field a Playwright
+  consumer reads, asserting a green run over zero executed tests, with the
+  contradicting `execution: "STATIC_ANALYSIS"` marker buried in the extension
+  block. `failed` was equally dishonest: it implies tests ran and lost. The
+  field is now the literal `interrupted` on every path, and what the scan
+  actually found is reported separately as
+  `mjolnir.scanOutcome` (`clean` / `blocked` / `partial`), which the previous
+  `mjolnir.status` field carried. Consumers reading the root `status` will see
+  `passed` → `interrupted`; that is the correction, not a regression.
 - **Score bands are decided in one place.** The dashboard split at 60 while the
   terminal split at 80, so a score the terminal called UNWORTHY rendered amber
   in HTML; the contributor handover used 90; `mermaid.ts` and
@@ -55,6 +2963,14 @@ once shipped, so this file is the record of what changed between versions.
 
 ### Added
 
+- **`npm run ci:standard` now runs in CI.** `scripts/check-ci-standard.mjs`
+  was unit-tested by `tests/integrations/ci-standard.spec.ts` but referenced
+  by no workflow, so the invariants it checks — the PR scan's partial-analysis
+  handling, the coverage and ratchet gates, and the read-only scan job's
+  permissions — were enforced nowhere. It runs as a step in `workflow-lint`,
+  next to actionlint, since both are static checks of the repo's own CI
+  config.
+
 - **Opt-in Sentry crash reporting.** Set `SENTRY_DSN` and the CLI and the MCP
   stdio server report their own fatal errors — release-tagged as
   `mjolnir-qa@<version>`, tagged by surface, and nothing else: no user data
@@ -67,7 +2983,11 @@ once shipped, so this file is the record of what changed between versions.
   the two existing top-level catch blocks rather than `uncaughtException` /
   `unhandledRejection` handlers, which would have changed the frozen exit-code
   contract. `npm run sentry:release` creates the release and uploads source maps
-  (the build now emits them; the published tarball still excludes them).
+  (the build now emits them; the published tarball still excludes them). Both
+  release pipelines now run it after `npm run build` and before `npm pack`,
+  because the debug ids it stamps are written into `dist/` in place: pack first
+  and the shipped tarball carries no ids, so the maps uploaded for the release
+  match nothing and every stack trace degrades to a bundle frame.
 - `npm run report:honesty` — no surface may print a zero for a measurement that
   may be absent. Four reviewed exceptions are recorded for computation inputs,
   each with a reason and a follow-up.
@@ -93,8 +3013,229 @@ once shipped, so this file is the record of what changed between versions.
   or descriptor to print. It opens no file, touches no clock and formats no
   document, and a test enforces that.
 
+### Changed
+
+- **Ruleset `01` now enforces 11 required checks instead of 4.** It required
+  only the four `build-test` matrix contexts, which meant the repo's entire
+  review surface — self-scan, certification, generated-docs-drift, site-build,
+  workflow-lint, property, fuzz — could be red while a PR still merged. That
+  made every one of those checks advice rather than a gate, and it meant the
+  deleted `merge-verify.yml` header was describing a ruleset that never
+  existed. The enforced set is now the four matrix entries plus
+  `property-tests`, `fuzz`, `site-build`, `workflow-lint`, `self-scan`,
+  `certification` and `generated-docs-drift` — every check that can actually
+  block. Deliberately still _not_ required: `detector-revision-diff` (advisory
+  by design — a hard fail would only manufacture routine revision bumps),
+  `scan` / `publish` (the Mjölnir PR report, which reviewers read but which
+  duplicates `self-scan` on the `src` tree), and the CodeQL/OSV workflows,
+  which report but do not gate. `strict_required_status_checks_policy` and
+  `do_not_enforce_on_create` are preserved, so a PR must still be current with
+  `main` to merge.
+- **`docs/BRANCH-PROTECTION.md` now states the enforced set instead of an
+  aspiration.** It listed eight required checks; three of them were enforced.
+  Its verification command also read `branches/main/protection`, which does not
+  carry required checks at all on this repo — they live in ruleset `01` — so it
+  could not have worked. Both are corrected.
+
+### Removed
+
+- **The Snyk webhook is gone.** Snyk posted a `security/snyk (sergey-bar)`
+  commit status on every push, duplicating the first-party `osv-scanner.yml`
+  (`scan-pr` / `scan-scheduled`) and the Dependabot security updates that are
+  already configured. Repo webhooks are now empty. Restore with Snyk's own
+  integration settings if it is ever wanted back — the deleted hook pointed at
+  `https://api.snyk.io/webhook/github/4ac3f376-3f24-42f7-a2c4-8830700f671d`.
+- **The `merge-verify` workflow is gone.** It re-ran the entire PR gate
+  (build, typecheck, lint, coverage, property, fuzz, site, self-scan, docs
+  regen) on every push to `main` — roughly doubling CI cost. Its stated
+  justification was that "a green PR that merges into a red main is not a
+  green PR", but that failure class is already closed by ruleset `01` running
+  `strict_required_status_checks_policy`, which refuses to merge a PR that is
+  not current with `main`. The file also asserted that ruleset `01` "requires
+  the complete PR matrix, property/fuzz, site, workflow-lint, self-scan,
+  certification, detector-revision, and generated-docs checks before merge" —
+  it did not, and never has. The ruleset requires only the four `build-test`
+  matrix contexts. Both the workflow and the claim are removed rather than left
+  to mislead a reviewer about what blocks a merge.
+- **The `bench-advisory` CI job is gone.** It spent a full `npm ci` plus a
+  3 000-file benchmark run on every PR to produce a comparison that
+  `continue-on-error: true` then discarded, and whose only output was a
+  warning nobody could gate on. `npm run bench:scan`, the pinned
+  `.mjolnir/bench-baseline.json`, and their schema/comparison tests in
+  `tests/adversarial/bench-gate.spec.ts` are untouched — the benchmark is
+  still runnable and still tested, it just no longer costs every PR a runner.
+- **Four copies of the soft job time-budget report.** Each of `build-test`,
+  `self-scan`, `generated-docs-drift` and `bench-advisory` re-derived its own
+  wall-clock minutes into `$GITHUB_STEP_SUMMARY` and printed a warning that,
+  by its own comment, "never gates". The jobs already declare
+  `timeout-minutes`, which is the hard bound, and GitHub reports job duration
+  natively.
+
 ### Fixed
 
+- **Order in the report no longer depends on the machine that produced it.** 23
+  sites in `src/` sorted with a bare `localeCompare`, which resolves against the
+  process's default locale. `scan-cache.ts` was the worst: it sorted INSIDE
+  `hashDir`, so the order was fed to `hash.update(entry.name)` and became a
+  semantic input to the detector fingerprint that `isIncrementalSafe` keys off
+  — one repository, two fingerprints, one per locale. All 23 now use
+  `compareCodePoints` from `src/lib/compare.ts`, except two whose key is a
+  human-readable label, which use a comparator pinned to `en` rather than
+  inheriting the environment. `tests/contract/deterministic-ordering.spec.ts`
+  fails the build on any unpinned `localeCompare` in `src/`.
+- **`mjolnir bind` can no longer be hijacked by a repository's own `git`.**
+  `src/engine/candidate-binding.ts` — called on every scan — ran
+  `execFileSync("git", …)` with a bare name. On Windows `CreateProcess` searches
+  the current directory before `PATH`, so a committed `git.exe` in an untrusted
+  repo chose the `commit` and `tree` that land in `runIdentity` and the evidence
+  graph. It is the last bare-name process launch left in `src/`, and
+  `tests/contract/no-bare-process-exec.spec.ts` now audits the whole tree.
+- **The coverage exemption ledger can no longer drift silently.** Each
+  non-structural entry in `docs/COVERAGE-EXEMPTIONS.json` now carries
+  `defectSignatures` — regexes that must still match its file — or an explicit
+  `closureState` when the defect it described is gone. A signature that stops
+  matching fails the gate, so a code fix forces a ledger edit in the same
+  commit. Six entries were already describing defects the current code had
+  fixed (`maturity`, `business-case`, `dashboard`, `enterprise`, `exec-report`
+  and the `report-playwright` row), and are reclassified accordingly.
+- **Skipped and expected-fail tests now have a price.** Nothing in the
+  repository counted them, so the count could grow from zero to hundreds with
+  every other signal still green. `docs/SKIP-BUDGET.json` records the current
+  counts — 8 skipped tests, 1 skipped file, 3 expected failures — measured by
+  `scripts/vitest-skip-budget-reporter.mjs` during the run. They may fall;
+  raising them fails `npm run skip:budget` and names the tests that spent the
+  budget. A missing or incomplete measurement fails too, so a reporter that
+  stops being wired in cannot read as a clean run.
+- **The M26 release gate and the version-drift checks are covered where it
+  matters.** Both run inside `certify` and both were excluded from the coverage
+  ratchet, so their reject arms — the paths that only execute when something is
+  wrong — had no reviewer pressure on them. `tests/ledger/m26-validator-reject-arms.spec.ts`
+  is table-driven over every required field, so a field that is added without a
+  test fails; `tests/release/version-surface-drift-arms.spec.ts` covers the
+  fail-fast arms of the version synchronizer.
+- **One error derivation, one `isRecord`, one crash-isolation path.** The tree
+  carried `isRecord` eight times (seven byte-identical), error rendering four
+  times under two names, and crash isolation seven times — and the copies
+  disagreed, which is the only reason any of this mattered. `String(obj)`
+  renders `[object Object]`, so the two _thinner_ error helpers turned a real
+  Node failure shape like `throw { code: "EISDIR" }` into a message naming
+  nothing — in a doctor detail, an MCP tool result and a `summary` line
+  respectively. The richer body survived the collapse, and
+  `isRecord` — the predicate every JSON reader uses to decide "this is an
+  object I may index into", which is a question a hostile saved report gets
+  to ask — is now the exported one in `src/lib/safe-json.ts`. The four
+  adapters' duplicated `try { rule.run } catch { onCrash }` is now
+  `runRuleIsolated`, because that block is what the `rulesCrashed` count is
+  built on and seven copies mean seven chances to lose it.
+  The per-adapter _filter chain_ and budget check were deliberately **not**
+  folded into the existing `runRulesShared`: the TypeScript adapter injects
+  an AST, framework tags, a lazy `codeText` getter, config-only gating and
+  `configGateMatches`, and it _aborts the whole file_ on budget exhaustion
+  where `runRulesShared` only skips one rule. Routing every adapter through
+  it as written would have silently changed which rules run — the exact
+  unmeasured claim this program exists to delete.
+  `tests/contract/single-error-helper.spec.ts` holds the counts at one, and
+  pins the object arm so a future "simplification" cannot drop it.
+
+- **A crashed rule is no longer certified as a rule that stayed silent.**
+  The doc generator caught a rule THROW while running it against its own
+  must-not-fire fixture and returned `null`; the caller read that as
+  `fired: false` and committed, into a generated doc page and the
+  certification surface, the sentence _"Verified against … — a legitimate,
+  similar-looking pattern this rule correctly leaves alone."_ A detector that
+  crashes produces exactly the same absence of findings as one that correctly
+  abstains, so that claim had no evidence behind it — and it contradicted the
+  same function's own docstring, which says the field degrades honestly.
+  The outcome is now the tri-state the doctor's own model already defines:
+  `FIRED` (a real firewall violation), `DID_NOT_FIRE` (certified), and
+  `INCONCLUSIVE` (the rule did not run). An `INCONCLUSIVE` page says so and
+  says why, and it never renders the certification sentence. A missing
+  fixture is a fourth, separate thing — nothing was attempted — and says
+  that instead. The field is typed as a `FixtureOutcome` union rather than a
+  boolean, so reintroducing a derived `fired` flag does not typecheck.
+
+- **A human-facing table stopped sorting by code unit.** Pinning every
+  `localeCompare` to code-unit order (the fix for the ambient-locale drift)
+  made the per-rule corpus-occurrence table read
+  `SeleniumHQ-selenium` before `microsoft-playwright-dotnet`, because `S`
+  sorts before `m`. Stable, and worse to read than the alphabetical order the
+  table implies it has. That surface is a table a person chooses repos from,
+  so it now uses an **explicitly pinned** locale — readable order, identical
+  on every machine, which is the actual defect being avoided.
+
+- **Fifteen silent capability losses are now counted, and the count reaches the
+  report.** A `catch` in a detection path that returned a clean default made
+  the scan exit 0, report `analysisComplete`, and quietly lose the thing that
+  made its verdict trustworthy — the reader had no way to tell a whole scan
+  from a narrowed one. The worst case was `getCodeOnlyText` returning raw text
+  after a throw, which switches OFF the comment/string false-positive firewall
+  for that file rather than merely slowing it down. Every such site now records
+  a reason in one append-only ledger (`src/engine/degradation-ledger.ts`),
+  following the precedent already set by `parserRetryDegradationCount`, and the
+  scan result carries `analysisStatus.degradations` — reason-coded counts,
+  present only when something was actually lost, alongside a
+  `degraded:<reason>:<count>` entry in `reasons`. A non-empty set makes the
+  scan `partial`. `truncationReasons` is untouched: a degradation is not
+  truncation, and a reader must be able to tell "the scan stopped" from "the
+  scan lost a layer".
+  - Two distinctions the ledger refuses to blur. **Absent is not degraded:** a
+    Python, Java, Go or Rust repository has no `package.json`, and recording
+    that would mark every non-Node project partial while training readers to
+    ignore the field — so only a manifest that exists and will not parse
+    counts. **A no-AST adapter is not a downgrade either:** the same line
+    W1.4 draws for the deadline fallback.
+  - Two sites outside the original list were found by the new contract spec
+    and fixed in the same commit: the tree-sitter Java/C#/Python parses (left
+    alone, because the pipeline already counts every `parseAst → undefined` as
+    one parse fallback, and counting again would tally one file twice in two
+    different fields) and `hashDir`'s `readdirSync`, whose early `return`
+    omitted a whole subtree from the detector fingerprint — two rule trees
+    differing only inside an unreadable directory then hash identically, which
+    is a stale-cache hit wearing a fresh one's clothes.
+  - `mjolnir trend show` no longer prints "No trend data yet." and exits clean
+    for a history file whose every line failed to parse. The count of
+    discarded lines is now reported on stderr, and a history that exists but
+    cannot be read is `EXIT_INTERNAL` — the difference between no history and
+    unreadable history, which both used to arrive as the same empty array.
+  - `mjolnir explain` distinguishes _the rule found nothing_ from _the rule
+    never ran_. A rule that THREW on its own fixture produced the same output
+    as a correctly silent one, in the one surface whose purpose is to show
+    that a rule works. It now says so, with the reason.
+  - `tests/contract/no-uncounted-degradation.spec.ts` is the durable half: a
+    `catch` in the detection path that RETURNS A VALUE must record a reason,
+    rethrow, route to a counted sink, or be exempted with a stated failure
+    direction. The rule is about the _return_, not the `catch` — 37 of the 70
+    detection-path catches return nothing and cannot lie to a caller, and a
+    spec that listed all 70 as individual exemptions would be the same as no
+    exemption list at all.
+
+- **Scanning a subdirectory no longer reports a framework it read from its
+  parent.** `runScan` walks up past the target to find the project root, and
+  re-anchors the scan root to the target when the target is a strict
+  descendant — but it kept the discovered root's parsed `package.json`. So
+  `mjolnir scan monorepo/packages/foo` reported `jest` because
+  `monorepo/package.json` said so: a read outside the explicit scan root, and
+  a framework verdict about a tree nobody pointed at. Framework detection now
+  works from in-root evidence only (config files and the anchor's own
+  manifest), and reports `frameworkDetectionUnknown` when that evidence is
+  absent — an absent verdict you can see, rather than a parent's you cannot.
+  Scanning the project root itself is unchanged. This is the CLI counterpart
+  to the containment property the MCP workspace-boundary contract already
+  enforced.
+- **A scan that ran out of time no longer loses its AST stage silently.** When a
+  scan passes `--max-duration`, the remaining files were analyzed by regex
+  instead of AST — a different detection capability, not a slower version of the
+  same one, so the same tree produced different findings and a different score.
+  The mode was faithfully recorded in the scan cache and reported nowhere; the
+  only nearby disclosure, `file-budget`, fired incidentally because the
+  per-file rule-loop deadline was usually already spent too. Such a scan now
+  carries the truncation reason `ast-budget-fallback` and an
+  `analysisStatus.reasons` entry `ast-budget-fallback-files:<n>` saying how many
+  files were analyzed by regex, and is honestly `partial`. An adapter that
+  declares no AST stage at all (a YAML workflow, for instance) is a declared
+  capability envelope and is NOT reported as truncation. `truncationReasons` is
+  an open `string[]` by design, so consumers should test for members rather than
+  assert the exact array.
 - **`frontier:contracts` was reporting 19 suites it never ran.** It named 24
   test files; nineteen had been deleted by the `cc5fcb88` cleanup and its
   follow-up. Vitest treats a missing path as "no tests here" rather than an
@@ -285,6 +3426,27 @@ were live in 3.0.0 and neither was in the plan.
 
 ### Known open, deliberately
 
+- [ ] **Trust certification is not claimed, and this release was authorized
+      without it.** `candidate:readiness` reports `BLOCKED` /
+      `INCONCLUSIVE` on all ten of its checks — candidate identity is not a
+      release candidate, the candidate SHA is not authorized, engineering
+      certification is not complete, and external validation, protected holdout
+      proof, real-world repository proof, the platform matrix, consumer install
+      proof and remote workflow proof are all absent.
+      `m26:audit` is likewise unsatisfied. Both ran, both printed, and neither
+      blocked the publish, because `vars.STABLE_RELEASE_AUTHORIZED` is `true` —
+      the same explicit override 4.0.0 shipped under.
+      The distinction is the point: **publication of a package is not the same
+      claim as a certification of it.** 5.0.0 asserts that the reporting
+      surface is honest, that a silent capability loss is disclosed, and that no
+      verdict is published without a measurement behind it. It does not assert
+      that a holdout corpus, a platform matrix and an external validation run
+      have been completed, because none of them have.
+      Consumers are not asked to take that on trust: the npm package publishes
+      the candidate manifest, which reads `NOT_CERTIFIED` and
+      `NOT_AUTHORIZED`, and every one of those ten blockers is enumerated above
+      rather than summarised. Closing them is the work that would make a
+      certification claim possible; it is not work this release did.
 - [ ] `CERTIFICATION_STATES` is not in ladder order, so `rankOf` — the only
       ordering function — ranks `KNOWN` above `TRUST-COMPLETE`, and
       `requiresEvidence` asks `BLOCKED` and `DEGRADED` for a corpus their own
@@ -427,9 +3589,9 @@ This release is software-complete and locally certified for the declared enginee
 
 - Added seven milestone commands to the public CLI and root help:
   - `mjolnir ci-integrity` validates GitHub/GitLab/Jenkins scan gates and reports non-blocking or disabled candidates.
-  - `mjolnir framework-maturity` reports bounded F0–F5 maturity while preserving human calibration authority.
+  - `mjolnir doctor --frameworks` reports bounded F0–F5 maturity while preserving human calibration authority.
   - `mjolnir suppression-gate` evaluates reasons, expiry, allowlists, total counts, and matched-finding mass suppression.
-  - `mjolnir cross-file` reports duplicate test names, shared imports, circular dependencies, and amplified findings.
+  - `mjolnir explain --callers` reports duplicate test names, shared imports, circular dependencies, and amplified findings.
   - `mjolnir contract-verify` validates machine-contract fields and binds persisted contracts to a fresh scan.
   - `mjolnir trust-trend` persists, deduplicates, and compares trust snapshots.
   - `mjolnir evidence-graph` builds provenance-bearing evidence graphs and supports file/rule queries.
@@ -1390,7 +4552,7 @@ Azure DevOps support: guarded azure-pipelines.yml parsing, the QA-CI Azure arms,
   preserved byte-identically (differential preservation suite).
 - **Explain v2 (WI-7).** `mjolnir explain` gains verdict mode
   (`mjolnir explain verdict --json <mjolnir.json>`) and finding mode
-  (file:line delegates to `mjolnir why`); every mode now answers the §8
+  (file:line delegates to `mjolnir explain <file:line>`); every mode now answers the §8
   checklist including WHAT WOULD CHANGE THE VERDICT and NEXT ACTION.
 - **Triage v2 (WI-8).** `mjolnir triage` now runs the §9 guided workflow —
   CLASSIFY → EVIDENCE → TRUST VERDICT → NEXT ACTION per row, every row
@@ -1591,7 +4753,7 @@ Azure DevOps support: guarded azure-pipelines.yml parsing, the QA-CI Azure arms,
 
 ### Added
 
-- **`mjolnir why <file>:<line>`** — occurrence-level evidence query
+- **`mjolnir explain <file:line> <file>:<line>`** — occurrence-level evidence query
   (informational, NOT a gate): exact file+line match, severity icon,
   message/why/fix, evidence level, trust level, measured FP rate
   (or the honest "ships on assumption"), runtime corroboration when
@@ -2001,7 +5163,7 @@ rules… → Scoring…`) fed by the new additive `ScanHooks.onProgress`.
   unified filter excludes them from non-strict scans exactly like core
   (post-scan cap still observable under `--strict`; the cli-scan-arms
   test updated to cover both sides).
-- **Drift-checked:** `mjolnir rules --md --external` renders the
+- **Drift-checked:** `mjolnir explain --list --md --external` renders the
   catalog from the LOADED external rules with a provenance column
   (`core`/`external`) — an on-disk edit changes the next render; the
   catalog can never drift from what actually ships.
@@ -2560,7 +5722,7 @@ SEMANTIC | FRAMEWORK | RUNTIME`) instead of free text: `src/rules/rule.ts`
 
 ### Added — UNSURE adjudication gate + QA-PW-101 measured (plan §11.5)
 
-- **UNSURE ceiling ratchet:** `npm run fp-audit:generate` now fails when the
+- **UNSURE ceiling ratchet:** `npm run generate-fp-audit-table` now fails when the
   UNSURE backlog grows beyond the committed
   `tests/corpus/verdicts/unsure-ceiling.json` (the §11.5 mechanism: UNSURE
   never counts into `n` but always triggers review). The ceiling only moves
@@ -2629,7 +5791,7 @@ detectorRevision, FP ≤ 10%, n ≥ 10`), on any detectorRevision mismatch
 - **`mjolnir doctor`**: `MAX_UNMEASURED_CORE` lowered 40 → **0** (Phase 1
   exit gate: 0 unmeasured in effective core, now enforced); tier checks
   consume `effectiveTier` + stale-measurement logic. Display surfaces
-  (`mjolnir explain`, `mjolnir rules`, generated rule docs, capability
+  (`mjolnir explain`, `mjolnir explain --list`, generated rule docs, capability
   matrix) render the PROVISIONAL status honestly.
 
 ### Verification Trust Evolution, Phase 0 + Phase 1 prep
@@ -2659,7 +5821,7 @@ detectorRevision, FP ≤ 10%, n ≥ 10`), on any detectorRevision mismatch
 - **`tests/corpus/detector-revisions.json` sidecar**: hand-maintained,
   one entry per measured rule (all at revision 1 today), diffable.
   `MEASURED_FP` entries now carry `detectorRevision` stamped from the
-  sidecar by `fp-audit:generate`; `docs/FP-AUDIT.md` gains a
+  sidecar by `generate-fp-audit-table`; `docs/FP-AUDIT.md` gains a
   `detectorRev` column. Measurement inheritance law (§07): a measurement
   belongs to a specific detector implementation, not merely to a rule
   ID. Drift lock extended in `tests/measured-fp-generated.spec.ts`
@@ -2888,21 +6050,21 @@ detectorRevision, FP ≤ 10%, n ≥ 10`), on any detectorRevision mismatch
   code; that fact previously lived only in `docs/FP-AUDIT.md` and
   `mjolnir doctor`. Now surfaced everywhere a user looks:
   - The scan footer reports how many of the rules that _fired_ are measured.
-  - `mjolnir rules --unmeasured` / `--measured` filter the catalog; a new
+  - `mjolnir explain --list --unmeasured` / `--measured` filter the catalog; a new
     "FP (measured)" column in `rules --md`; a "Measured FP rate" row on every
     `docs/rules/` page and in `mjolnir explain`.
   - JSON findings carry `measuredFpRate` and `measuredFpN` (additive —
     `schemaVersion` is still 1).
 - `src/rules/measured-fp.generated.ts` bakes the rates into the shipped
   package (the raw verdicts are not packed); regenerated by
-  `npm run fp-audit:generate`, drift-locked by a test, and now the single
+  `npm run generate-fp-audit-table`, drift-locked by a test, and now the single
   source `mjolnir doctor` reads.
 - Scoring is unchanged — this is visibility only.
 - **Corpus expanded 6 → 13 repos** so the previously-silent rule families
   (QA-TEST, QA-TQUAL, most QA-PW, QA-CI-001) fire on real consumer code:
   added `next-auth`, `vite`, `sveltekit`, `astro`, `TanStack/query`,
   `eslint-plugin-playwright`, `playwright-pytest`. `corpus:sample` and
-  `corpus:regression` now scan with `--strict` (quarantine rules were
+  `corpus:audit` now scan with `--strict` (quarantine rules were
   invisible to both before). `docs/FP-AUDIT.md` is 15/91 (down from 19 —
   see the dispatch fix below, which retired the leaked cross-language
   verdicts for QA-PW-101/112 and QA-TEST-004/QA-ENV-001 on Java/Python
@@ -3103,7 +6265,7 @@ by a `must-not-fire` fixture so the class cannot return silently.
 - Upgrade-Plan-v3 Phase 0.1: expanded the false-positive corpus with two
   additional Python repos (`pytest-dev/pytest`, `psf/requests`) so all
   QA-PY-001..012 rules are exercised against real code via
-  `npm run corpus:regression`.
+  `npm run corpus:audit`.
 - Added `CHANGELOG.md` (this file) per Upgrade-Plan-v3 critical item #3:
   user-visible rule behavior changes get a first-class entry from now on.
 - Upgrade-Plan-v3 Phase 1: five new TypeScript/Playwright rules —
@@ -3148,17 +6310,17 @@ by a `must-not-fire` fixture so the class cannot return silently.
   Promoted to core: QA-CS-101 (0% FP, n=20), QA-JV-105 (10% FP, n=20).
   Quarantined rules still ship and are still documented — they are opt-in via
   `--strict` rather than shaping the default report.
-- `mjolnir rules` (`--json` and `--md`) now exposes each rule's `tier`, and
+- `mjolnir explain --list` (`--json` and `--md`) now exposes each rule's `tier`, and
   every generated page under `docs/rules/` shows it in the metadata table.
 
 ### Fixed — documentation claims a `grep` disproved
 
 - Every generated rule page told the reader to reproduce corpus counts with
-  a `corpus:audit` script. That script had been renamed to `corpus:regression` in
+  a `corpus:audit` script. That script had been renamed to `corpus:audit` in
   the Tempering plan and the generator string was never updated — the command
   printed on 91 published pages did not exist. Same dead name in
   `docs/PUBLISHING.md`
-  (`corpus:audit:update` → `corpus:regression:update`).
+  (`corpus:audit:update` → `corpus:audit --update`).
 - **`docs/FP-AUDIT.md` under-reported the rule base as 84 rules when the
   registry holds 91.** The coverage denominator was built by grepping source
   for `id: "QA-…"`, which silently missed the seven rules that the Phase 6