@mrciphersmith/keryx 0.2.73 → 0.2.75

package/src/gdskills/bundled/skills/review/review-layout/SKILL.md

@@ -0,0 +1,217 @@
+---
+name: review-layout
+model_tier: standard
+description: |
+  Use when reviewing changes to rendered layout: flex and grid sizing, intrinsic vs
+  extrinsic sizing, overflow and collapse, logical properties and RTL, and sensitivity
+  to translated text length. Every finding is measured in a real layout engine, never
+  reasoned from class names in a DOM stub. Dispatched by review-orchestrator for
+  --layout, --all, or when the diff touches sizing/spacing utilities on a rendered
+  element.
+  NOT for: whether a class exists or comes from the theme (review-frontend-conventions),
+  naming and readability (review-style), re-render cost (review-performance), React or
+  MobX structure (review-frontend).
+triggers:
+  - "review layout"
+  - "layout review"
+  - "does this render correctly"
+  - "dispatched by review-orchestrator"
+metadata:
+  author: "MrCipherSmith"
+  version: "1.0.0"
+  category: "review"
+  compatible_harnesses: "cursor,codex,zed,opencode,claude"
+license: "MIT"
+---
+
+# Review — Layout
+
+Reviewer for what the CSS actually renders.
+
+This lane exists because nobody else owns it. `review-frontend` owns React and
+MobX structure; `review-style` explicitly excludes everything but naming and
+readability; `review-frontend-conventions` owns whether a class is allowed;
+`review-performance` owns re-render cost. **None of them answers whether the box
+is the size the author thinks it is** — which is why a bar that collapses to 0px
+and a score that sits 12px off centre both shipped through a full review round.
+
+Every finding here is a claim about pixels, so every finding here is measured or
+it is not filed.
+
+---
+
+## Scope
+
+Dispatched when scope A touches, on a **rendered** element:
+
+- sizing: `w-*`, `h-*`, `min-w-*`, `max-w-*`, `basis-*`, `flex-*`, `grid-cols-*`,
+  `w-fit`, `min-w-0`, `truncate`, `line-clamp-*`
+- spacing that participates in centring or the box model: `p*`, `m*`, `gap-*`, and
+  their logical forms `ps-*`, `pe-*`, `ms-*`, `me-*`
+- `overflow-*`, `position`, `z-*`, `aspect-*`
+- inline `style` carrying a computed dimension
+- any container whose children render translated text
+
+Out of scope: whether a class exists or comes from the theme, and whether it is
+well named.
+
+---
+
+## The one method that makes this lane real
+
+**A DOM stub loads no stylesheet.** Under happy-dom or jsdom,
+`toHaveClass("w-fit")` observes a string and never a pixel, and
+`getBoundingClientRect` returns zeros for everything. A layout claim reasoned from
+class names is worth nothing, and filing one is how this lane degenerates into a
+class-name spellchecker.
+
+Verify one of two ways, and put the numbers in the finding:
+
+1. The project's real-CSS tier — the Storybook / Playwright / component-visual
+   suite. Find its script in `package.json` rather than assuming a name.
+2. A direct probe that mounts the component in a real engine and reads computed
+   CSS off the node.
+
+Report a table of measurements, not an adjective. `117.6px` is a finding; "the bar
+may be too short" is not.
+
+```
+host width   longest label      bar width
+560px        "Controls"         256.0px
+560px        <longest ar-AE>    182.6px
+280px        "Controls"           0.0px   <- collapses
+```
+
+**If you cannot measure, you cannot file.** Say which command you tried, what
+stopped you, and what would settle it. An unmeasured layout observation is `info`,
+marked unverified — that is the correct outcome, not a reason to reach for a class
+name instead.
+
+---
+
+## Checklist
+
+### Intrinsic sizing traps
+
+- [ ] A `flex-1` / `basis-0` column inside a `w-fit` (or `max-content`) parent has
+      **no basis of its own**: its width is whatever the siblings' content leaves.
+      Measure it, then measure it again with the longest translated label the
+      catalog contains.
+- [ ] `min-w-0` removes the automatic minimum that stops a flex item shrinking past
+      its content. Combined with a content-sized parent it permits **0px**. Find the
+      host width at which the element reaches zero and state it.
+- [ ] `w-fit` + `max-w-full` is an overflow fix, not a sizing floor. Replacing a
+      removed `min-w-*` with `min-w-0` trades an overflow bug for a collapse bug.
+- [ ] A `min-w-*` on a child plus `w-fit` at the call sites gives the card a hard
+      floor. Compute it, and check it against the narrowest supported host.
+
+### Box model and centring
+
+- [ ] Padding inside a fixed-width box shifts centred content by half the asymmetric
+      padding. `w-48` (192px) with `pe-6` (24px) centres in 168px — 12px toward the
+      inline start.
+- [ ] Directional padding that is a gutter in one state is an uncompensated offset in
+      the state where the neighbour is absent. Check **every** conditional render of
+      that sibling, including the empty and never-run states.
+
+### Logical properties and RTL
+
+- [ ] `ps-*` / `pe-*` / `ms-*` / `me-*` flip under RTL: an offset toward the start in
+      LTR is toward the end in RTL. State both.
+- [ ] A physical gradient, shadow, or transform in a component that otherwise uses
+      logical properties does **not** flip. Name the direction it points in each.
+- [ ] Text length differs by locale. A component sized by its own labels renders
+      **different geometry for identical data** across locales. Measure with the
+      longest real translation in the catalog, never the English one.
+
+### Truncation and overflow
+
+- [ ] `truncate` / `line-clamp` needs a constrained width to do anything at all.
+- [ ] `overflow-hidden` on a container with a percentage-width child silently clips
+      rather than scrolls.
+
+---
+
+## Iron Laws
+
+### This reviewer's own
+
+1. **A layout finding without a measurement is `info`.** Name the host width, the
+   element width or the offset in pixels, and the command or probe that produced it.
+2. **Measure the worst real case, not the convenient one.** The longest translation
+   in the catalog, the narrowest supported host, the state where the sibling is
+   absent, the locale that flips direction.
+3. **Never flag a theoretical narrow viewport.** If no supported host reaches the
+   collapse width, the finding is `info` and says what would settle it. A breakpoint
+   nobody ships is not a trigger.
+
+### Shared laws (every reviewer)
+
+1. **A claim of runtime harm with no reproducible path is `info`.** If you cannot
+   name the input, call, or condition that reaches the code, you have an
+   observation, not a finding. Report it as `info` and say what would settle it.
+2. **Never flag the theoretical.** The path you describe must exist in the code
+   under review. Do not report a safe API because it could be misused, or a
+   pattern because it is often wrong elsewhere.
+3. **One finding per class, not one per occurrence.** When the same shape appears
+   at several sites, report it once and list every site. Ten findings that are one
+   finding hide the other nine problems.
+
+Severity levels are defined once, in `review-orchestrator/SKILL.md` →
+**Severity (canonical)**. This reviewer keeps no rubric of its own; below is only
+where its recurring conditions land under that one.
+
+| Condition | Severity | Why, under the canonical rubric |
+|---|---|---|
+| An element renders at 0px while its label shows, at a supported host width | `major` | Named trigger (that width), named outcome (the control is invisible) |
+| Identical data renders different geometry per locale | `major` | Named trigger (the locale), named outcome (a different picture of the same number) |
+| Content clipped, or the page forced to scroll horizontally, at a supported width | `major` | Named trigger and outcome |
+| A cosmetic offset a user would not notice — a few px off centre | `minor` | The code behaves correctly; the cost is aesthetic |
+| A measured-but-unreachable collapse, or any claim you could not measure | `info` | Shared law 1 |
+
+---
+
+## Orchestrated Review Contract
+
+When dispatched by `review-orchestrator`, follow the provided
+`reviewer-input.schema.json` payload. Return a `REVIEW_RESULT` object compatible
+with `skills/review/review-orchestrator/reviewer-finding.schema.json`, then a
+concise markdown summary. Prefix finding ids `LY-`.
+
+### Class scope — required for `blocker` and `major`
+
+Every `blocker` and `major` carries `class_scope`: **every** element with the same
+sizing shape, and **how you enumerated them** — the search you ran, or the
+component whose call sites derive the set.
+
+```yaml
+class_scope:
+  sites: ["src/dq/components/DqScoreCard.tsx:111", "src/dq/components/DqTrendCard.tsx:88"]
+  enumeration_method: "grep for `min-w-0 flex-1` under a w-fit ancestor; 4 cards, 2 collapse"
+```
+
+"I checked the others" is not an enumeration method. A single-entry `sites` list is
+a claim that the class has exactly one member — make it deliberately.
+
+```markdown
+### [LY-NNN] Title
+
+- **Severity**: blocker | major | minor | info
+- **File**: path/to/Component.tsx:line
+- **Problem**: what the box does
+- **Measurement**: host width, element width or offset, and the command or probe
+- **Why it matters**: what the user sees, in which state and which locale
+- **Fix**: the concrete sizing change
+```
+
+---
+
+## Red Flags
+
+| Rationalization | Why it is wrong |
+|----------------|-----------------|
+| "`toHaveClass('w-fit')` passes, so the width is right." | The stub loads no CSS. That assertion cannot fail on a layout bug. |
+| "This will obviously overflow on mobile." | Measure it, or name the supported host that reaches it. Otherwise `info`. |
+| "The class names look fine." | This lane does not review class names. That is `review-frontend-conventions`. |
+| "I could not run the visual tier, so I reasoned it out." | Then it is `info`, marked unverified. Reasoning does not become measurement by being careful. |
+| "RTL is handled, the component uses logical properties." | Check the gradients, shadows and transforms too. Those are the ones that do not flip. |

package/src/gdskills/bundled/skills/review/review-logic/SKILL.md

@@ -107,6 +107,32 @@ Do not review unrelated files.
 - [ ] Incorrect boolean logic (double negation, De Morgan's law violations)
 - [ ] Unreachable branches or dead code that hides a bug
 
+### The Change That Does Nothing
+
+The diff adds a prop, guard, field or branch, and nothing can reach it. The code is
+correct — which is why every reviewer asking "is this correct" passes it — and the
+work the change was written to do is not done.
+
+- [ ] A prop passed to a component that cannot act on it: the parent unmounts the
+      child rather than disabling it, or the render site the prop guards is gated by
+      a condition that is false whenever the prop is true.
+- [ ] A field added to a type, a `Pick`, or a payload and never read. Search for the
+      reads before accepting it as plumbing for a later change; if it is, say so.
+- [ ] A guard against a value its producer cannot emit — `=== undefined` against a
+      backend that stamps `0`, a status the producer writes in one place the route
+      never reaches.
+- [ ] State set on one path and cleared on none, or cleared only on paths the
+      triggering interaction cannot take.
+- [ ] A branch whose condition is unsatisfiable given the call sites in this repo.
+
+Prove it by **negative enumeration**: name the complete candidate set and why each
+member fails to apply, in `class_scope.enumeration_method` with `sites: []`. See
+**Negative enumeration** in `review-orchestrator/SKILL.md` → Finding Format.
+
+`minor` when the change is merely dead. `major` when its deadness means the defect
+it was written to fix is still live — the usual case when the change answers an
+earlier review round, because there the finding is recorded as closed and is not.
+
 ### Null / Undefined / Optional Chaining
 
 - [ ] Accessing property on value that can be `null` or `undefined` without guard

package/src/gdskills/bundled/skills/review/review-orchestrator/SKILL.md

@@ -33,7 +33,7 @@ triggers:
   - "review --mobx-store"
 metadata:
   author: "MrCipherSmith"
-  version: "1.8.0"
+  version: "1.9.0"
   category: "review"
   compatible_harnesses: "cursor,codex,zed,opencode,claude"
 license: "MIT"
@@ -66,7 +66,7 @@ Review Orchestrator Progress:
 - [ ] Step 11: Sort by severity, deduplicate, emit unified report
 - [ ] Step 12: Emit the machine-readable `keryx:findings` block alongside the report
 - [ ] Step 13: Report the stage counts: dropped by pre-filter, refuted by the verifier, retained
-- [ ] Step 14: AFTER THE FINAL ROUND ONLY — answer every external comment once, `keryx review comments reply --final`
+- [ ] Step 14: AFTER THE FINAL ROUND ONLY — answer every external comment once, `keryx review comments reply --final` — never against a pull request the dispatch named as the caller's
 ```
 
 Step 0 runs on **every** round. Step 14 runs **once**, after the last one. They are
@@ -394,6 +394,41 @@ problem, mark its outcome `escalate: true`: it leaves the reply queue, is report
 to the operator immediately, and the command exits non-zero. Answering a blocking
 question at the end answers the wrong question late.
 
+### A round never answers a pull request another skill is answering
+
+`review-pr-feedback` is the entry point for the other direction of this pipe: a
+human or a bot has already reviewed pull request `#A`, and someone wants those
+comments interpreted, checked against the code, fixed and answered. Under its
+`--fix` mode it dispatches `flow-orchestrator`, which opens a **second** pull
+request `#B` carrying the fix, based on `#A`'s own head branch, and dispatches
+**this** orchestrator on every round against `#B`.
+
+`#B` is its own conversation. Collect and reply on it exactly as always: someone
+reviewing the fix deserves an answer from the run that made the fix, and its
+record is filed under `#B`'s own number, so nothing about `#A` is touched.
+
+The rule is about the other pull request:
+
+- **Never run a reply pass against a pull request the dispatch named as the
+  caller's.** When `constraints` says the caller owns the reply for `#A` — or
+  the target resolves onto a pull request another skill declared — collect if the
+  round needs the record and stop there. `review-pr-feedback` answers `#A` once,
+  after the merge, from the outcomes its own verdicts produced.
+
+  The harm is not a duplicate. `collectPrComments` skips a comment whose record
+  carries a `reply_url` as `already-handled`, rescuing it only when somebody else
+  posts later in the thread — so a round that answered mid-loop writes that record
+  FIRST, and the post-merge reply citing the merge SHA is then skipped as already
+  answered. The reviewer keeps the interim answer, which by then has stopped being
+  true, and `replies.posted` counts only what went out. A suppressed correction is
+  worse than a duplicate, because nothing shows it is missing.
+- **Absent such a constraint this orchestrator owns the reply**, as it always
+  has. A top-level review of a pull request is the normal case; a caller holding
+  the conversation is the exception, and the exception declares itself.
+- The reply is the only thing that moves. Collection, severity classification,
+  the refusal to let the verifier refute an external comment, and the cap
+  exemption are unchanged in both shapes.
+
 ---
 
 ## Everything written to GitHub is brief
@@ -427,12 +462,65 @@ Required content:
 - Git/PR metadata: repo, branch, base, head, merge-base, PR number/URL when available.
 - Scope summary: changed files grouped by domain, high-risk files, generated/ignored files.
 - Requirements: issue URL, linked task docs, acceptance criteria extracted from `context_doc` when available.
+- **The PR's own description**, fetched not assumed: `gh pr view <n> --json title,body`. See below.
+- **Cross-repo contracts the diff depends on**, each pinned to the SHA you read it at. See below.
 - Rules: matched repository rules and convention docs by path.
 - **Memory: accepted project memory intersecting the changed paths.** See below — this step is required, not best-effort.
 - Decisions: why each reviewer was selected or skipped.
 - Token policy: effective budget, truncation decisions, files summarized instead of fully inlined.
 - Legacy/profile reviewer availability and selection state.
 
+### The PR description is evidence, not decoration
+
+Fetch the body into `review_context.pr.body` and hand it to every reviewer. It is
+the author's own statement of what the change does, and it is checkable against
+the diff.
+
+**A description that promises an approach the diff does not take is a `minor`
+finding** — file it, do not merely mention it. The failure this catches is
+specific: over a multi-round review the code moves and the description does not,
+so by round three the PR body describes an approach that was deleted in round one.
+Whoever reads the merge commit a year later reads the description, not the rounds.
+
+It is `minor` and not `major` because nothing at runtime is wrong. It is a finding
+and not a pleasantry because unfiled housekeeping is raised again every round and
+fixed in none — three consecutive rounds of "still worth rewriting" is the
+recorded outcome of leaving it out of the findings array.
+
+Same class, same severity: an approach that depends on another repository's change
+being deployed first, with no deploy note saying so.
+
+### Cross-repo contracts are read, not assumed
+
+When the diff consumes a contract owned by another service — a payload shape, a
+status enum, a timeout, a permission, a default — **read the producer** and pin
+the SHA:
+
+```yaml
+cross_repo:
+  - repo: vantage-backend
+    sha: f5219d5d4
+    reason: "DQ report payload: which halves are null vs 0"
+    facts:
+      - "sqlScore/schemaDriftScore stay null when the half is absent"
+      - "sqlWeightPercentage/schemaDriftWeightPercentage init to 0.0 and are set unconditionally"
+```
+
+Put the facts in `review_context` so every reviewer shares one reading, and so a
+later round can tell a contract that moved from a reviewer that misread it.
+
+The rule that follows for reviewers, and that belongs in the dispatch prompt:
+
+> **A claim about another service's behaviour, with no `file:line` at a pinned SHA
+> behind it, is `info`.** Not `major`, however confident. The two failure modes are
+> symmetric and both recorded: a finding asserted from the consuming side that the
+> producer disproves, and a defect missed because the producer's actual default was
+> assumed rather than read.
+
+If the other repository is not available to you, say so in `cross_repo` and leave
+the dependent findings at `info`. An unavailable producer is a result. Assuming
+one is not.
+
 ### Memory (required)
 
 Run, once, per review:
@@ -571,6 +659,62 @@ Recording the enumeration matters as much as doing it: a round that searched and
 found nothing is a different fact from a round that never searched, and only the
 recorded list distinguishes them.
 
+#### Every prior finding leaves the round with a disposition
+
+A fix round that reports only new findings is unreadable: the author cannot tell
+which of their fixes landed. Close the loop explicitly — one line per prior
+finding, in the report, before the new findings:
+
+| Disposition | Meaning |
+|---|---|
+| `closed` | Checked against the code, not against the commit message, and the defect is gone |
+| `open` | The fix does not reach the defect; say what is still true |
+| `partial` | One site of the class was fixed and the enumeration named others |
+| `regressed` | The fix removed this defect and introduced another — file the new one separately |
+| `withdrawn` | The finding was wrong. See below |
+
+**Check the code, not the commit message.** A commit titled *"report an abandoned
+sync as abandoned"* is a claim; the disposition is whether the branch it renamed
+is reachable and pinned. On a recorded round, two such commits asserted behaviour
+on lines no test could reach.
+
+#### A fix is a change, and changes get reviewed
+
+The most expensive class in a multi-round review is **the defect the fix
+introduced**. It is systematically under-found, for a structural reason: the fix
+arrives framed as the answer to a finding, so it is read as an answer rather than
+as new code. It is new code.
+
+So scope A of a fix round includes the fix, reviewed on its own merits, and the
+report carries its own section:
+
+```markdown
+## Regressions the fixes introduced
+<[F-NNN] — the finding it was answering, and the new defect it created>
+```
+
+Recorded shapes, all from fixes that correctly closed the finding they answered:
+an early return added to stop a fall-through, which then skipped the work the
+caller needed; a persistence call added to save expanded state, which then
+persisted the broken state on the error path too. Both were closed correctly and
+both shipped a new bug in the same commit.
+
+#### Withdrawing your own earlier finding
+
+A finding from a previous round that this round disproves is **withdrawn**,
+explicitly, at the top of the report, with the evidence — before any new finding.
+
+This is not a courtesy. An uncorrected wrong finding costs the author a fix they
+did not need, and it stays in `prior_findings` steering later rounds. Withdrawal
+is also the one self-correction this pipeline permits, and it is permitted because
+it is asymmetric: it *deletes* a claim, so it cannot inflate the finding count,
+which is the failure mode that removed the re-scoring pass from Wave C.
+
+State what made the original claim wrong, in one sentence, and if the same
+reasoning error has now happened twice in one review, say that too. A reviewer
+that names its own recurring error is calibrating; one that quietly drops a
+finding is hiding a result.
+
 ### Step 1: Determine Review Mode
 
 Before anything else, determine whether the request is **diff mode** or **path mode**:
@@ -766,6 +910,7 @@ If the repository has local convention docs such as `CLAUDE.md`, `AGENTS.md`,
 | `**/*.test.*`, `**/*.spec.*`, `**/*.integration.test.*`, `**/*.msw.ts`, `src/test/**`, `test/**`, `e2e/**` | `review-testing-practices` |
 | `src/core/**`, `core/**`, `shared/**`, `foundation/**` | `review-core-boundaries` |
 | `src/core/flow/**`, `src/graph/**`, `src/shared/flow/**` | `review-flow-graph` |
+| A `.tsx`/`.jsx`/`.css`/`.scss` hunk that adds or changes a sizing or spacing utility on a rendered element — `w-*`, `min-w-*`, `max-w-*`, `flex-*`, `basis-*`, `grid-cols-*`, `truncate`, `line-clamp-*`, `overflow-*`, `p*`/`m*`/`gap-*` and their logical `ps-*`/`pe-*`/`ms-*`/`me-*` forms, or an inline `style` carrying a dimension | `review-layout` |
 
 These convention reviewers are additive: keep the generic reviewers selected by normal detection,
 then add the matching convention pass. Deduplicate reviewer names before dispatch.
@@ -797,6 +942,84 @@ reviewer wrongly skipped hides a real defect, and that asymmetry is not close.
 Record the exclusions with their reasons alongside the pre-filter drops. A
 reviewer silently absent from a report reads as "it had nothing to say".
 
+### Path gate — the second filter, same asymmetry
+
+Stack scoping asks *does this repository have the thing*. The path gate asks *does
+this diff*. A reviewer whose path triggers match **no file in scope A** is not
+dispatched; it goes to `Skipped reviewers` with reason `no-matching-paths`.
+
+This is worth its own step because `--all` is the common case and it is where the
+waste is: a run of sixteen reviewers over a fourteen-file frontend diff dispatched
+`review-core-boundaries` and `review-flow-graph` against a diff containing no
+`src/core/**` file at all. Two agents, full prompt each, guaranteed empty.
+
+Three bounds keep it from deleting coverage:
+
+- **Only path-triggered reviewers.** A reviewer selected by an explicit flag, or
+  one whose scope is the whole change rather than a path set — `review-logic`,
+  `review-regression`, `review-verifier` — is never path-gated.
+- **Scope A only.** Scope B is the blast radius; it is *supposed* to name files the
+  diff never touched.
+- **Ambiguity includes.** If you cannot decide whether a path matches, dispatch.
+  Same asymmetry as stack scoping: a needless reviewer costs tokens, a missing one
+  costs a defect.
+
+Record every gated reviewer with the trigger set that found nothing. "Skipped:
+no matching paths" is a result the reader can check; an absent reviewer is not.
+
+### Project-local reviewers — ask, do not assume
+
+The routing table below names the reviewers **keryx ships**. A project may also
+define its own, and before this step existed they were invisible to every round:
+a team could write a reviewer, register it, and watch nothing dispatch it.
+
+So the reviewer set is asked for, not recited:
+
+```bash
+keryx review reviewers --json
+```
+
+It returns two halves. `bundled` is the installed gdskills review tree — the set
+this project's install profile actually produced, which is not everything keryx
+ships. `project` is every project-skill under module `review`, living at
+`.metaproject/project-skills/review/<name>/` so that it sits beside
+`.metaproject/skills/gdskills/review/<name>/` and needs no other marking.
+
+**Dispatch the project half alongside the bundled one.** A project reviewer is a
+reviewer: it returns `REVIEW_RESULT`, its findings merge with everyone else's,
+it is bound by the canonical severity rubric and the shared laws, and it is
+verified in Wave C like any other. It is not advisory and not a second-class
+pass — a team that wrote down how it reviews has said something about this
+codebase that no shipped reviewer knows.
+
+Two things it does NOT get:
+
+- **No exemption from the contract.** A project reviewer whose output does not
+  conform is handled by the Sub-Agent Report Quality Gate exactly as a bundled
+  one would be. Local authorship is not evidence.
+- **No self-verification.** The never-self-verify rule is about the actor, not
+  the origin.
+
+#### `drift` — the source moved, the reviewer did not
+
+A project reviewer built from an external file — a rules file, a review profile,
+a conventions doc — records where it came from and the hash of that file at
+import. `keryx review reviewers` re-reads the source and reports:
+
+| `drift` | Meaning | What to do this round |
+|---|---|---|
+| `none` | No external source; written here | Nothing |
+| `clean` | Source matches the import | Nothing |
+| `changed` | Source has moved on since import | Dispatch it, and say so in the report |
+| `missing` | Source can no longer be read | Dispatch it, and say so in the report |
+
+**A drifted reviewer still runs.** It is a reviewer built from an older version
+of its source, which is a fact about provenance, not a defect in its findings —
+suppressing it would trade real coverage for tidiness. Record the drift in
+`review_context` and name it once in the report, so the next person knows the
+profile is due a re-read. Never file it as a finding against the code under
+review: it is a fact about the review, not about the diff.
+
 ### Convention Reviewer Confirmation
 
 When convention reviewers are auto-detected and the user did not explicitly pass
@@ -880,6 +1103,7 @@ Skipped reviewers:
 | `--testing-practices` | `review-testing-practices` |
 | `--core-boundaries` | `review-core-boundaries` |
 | `--flow-graph` | `review-flow-graph` |
+| `--layout` | `review-layout` |
 | `--all` | all reviewers above (including `review-clean-code`, `review-highload`, applicable legacy/profile reviewers, and project convention reviewers when local convention docs exist) |
 | `--verify` | `review-verifier`, AFTER all others; checks the consolidated findings by running something. Delete-only. |
 | (auto) | detected from diff file extensions — see Auto-detection table |
@@ -912,6 +1136,20 @@ Dispatch selected reviewers in parallel when independent. Use waves when token b
 3. Wave C - **verification**: `review-verifier` over the consolidated findings, when blockers/majors
    exist, `--verify` is set, or the PR is high-risk. See below.
 
+**Execution belongs to both B and C, and they execute for opposite reasons.**
+Wave C runs a command to *decide the fate of a finding that exists*; it is
+delete-only and can produce nothing. Wave B runs commands to *make findings* —
+`review-testing-practices` deletes each gate the diff added and records whether
+the suite goes red, and `review-layout` measures rendered geometry in a real
+engine.
+
+The consequence is directional and easy to get wrong: **a surviving mutation is
+not something Wave C can hand you.** If Wave B skips its mutation pass, that
+finding class is unreachable for the entire round, and no amount of verification
+downstream recovers it. When a testing reviewer returns without a mutation table,
+treat it the way you would treat a reviewer that returned without findings *and*
+without evidence: ask once, then record that the pass did not run.
+
 ### Wave C — verification, and what it replaced
 
 Wave C used to run `review-strict`: a meta-pass that re-read the consolidated
@@ -1178,6 +1416,42 @@ is a claim that the class has exactly one member — make it deliberately, becau
 `minor` and `info` may omit it: enumerating the class for every low-severity
 observation is theatre, not rigour.
 
+#### Negative enumeration — the empty set is also a class scope
+
+Some of the strongest findings assert that something is **absent**: nothing clears
+this state, nothing reads this field, this prop can never fire, no test builds this
+shape. Those are claims about a set being empty, and an empty set is exactly as
+enumerable as a full one — the same `class_scope` machinery carries it.
+
+```yaml
+class_scope:
+  sites: []
+  enumeration_method: "all 5 clearSubmitExecutionState() call sites are onUnmount,
+    setActiveControl, setActiveTemplate, submitActiveControl, resetActiveControlForm;
+    none reachable from a check-section edit, and there is no reaction/autorun"
+```
+
+The `enumeration_method` is the whole finding here, so it carries more weight than
+usual: it must name the complete candidate set and why each member fails to apply.
+"I looked and did not find one" is not that. A search that returned nothing, with
+the query, is.
+
+This form covers a class of defect nothing else in this pipeline reaches:
+
+- **The inert change.** The diff adds a prop, a guard, a field or a branch that
+  nothing can reach — a `disabled` prop on a component its parent unmounts instead
+  of disabling; a field added to two type `Pick`s and never read; a `=== undefined`
+  guard against a producer that never emits `undefined`. The diff looks like it
+  does something and does nothing, and the reviewer that checks whether the change
+  is *correct* passes it, because it is.
+- **The missing clear.** State is set on one path and no path unsets it.
+- **The unreachable branch.** A value the code handles that its producer cannot
+  emit.
+
+An inert change is `minor` when it is merely dead, and `major` when its deadness
+means the bug it was added to fix is still live — the second is the common case
+when the change was written to answer an earlier round's finding.
+
 All findings from all sub-reviewers must be normalized to this format before consolidation:
 
 ```markdown
@@ -1272,10 +1546,38 @@ STATUS: DONE | DONE_WITH_CONCERNS
 ## Minor & Info
 <[F-NNN] findings with severity=minor or info>
 
+## Checked and cleared
+<Required whenever a reviewer tested a hypothesis and it did not hold. One line
+each: the defect that was looked for, and the evidence that rules it out. Not a
+list of virtues — a list of hypotheses that died, so no later round spends a
+reviewer re-raising them.>
+
 ## Positive Notes
 <Optional. Highlight things done well. Keep brief.>
 ```
 
+### Why `Checked and cleared` is separate from `Positive Notes`
+
+They read alike and do opposite work. "Both entry points read the score from the
+same report" is a virtue; it tells a later round nothing, because no round was
+going to claim otherwise. "The drift bar cannot contradict the drift badge —
+`schema-drift-table.ts:61` always seeds `ddl` and `distributed` is a primitive
+boolean that is always serialized, so a backend match implies a `ddlTextDiffers`
+match" is a **retired hypothesis**: it names the bug that was hunted and the fact
+that kills it.
+
+The cost of omitting them is paid in rounds. A plausible-but-wrong finding that
+was investigated and dropped in round 1 is investigated again in round 2 by a
+different reviewer, and the author answers it twice. Writing the negative down
+once ends that loop; it is also the only artifact that distinguishes *checked and
+clean* from *never looked at*, which is the distinction an approving verdict rests
+on.
+
+Entries come from the reviewers, not from you: a reviewer that dropped a candidate
+returns it with the evidence, and consolidation collects them. A reviewer that
+returns zero findings and zero cleared hypotheses has told you nothing about the
+code, and should be asked once what it examined.
+
 ---
 
 ## Skill Learning Handoff