@mrciphersmith/keryx 0.3.133 → 0.3.135

package/dist/core.js

@@ -1078,6 +1078,12 @@ var init_catalog = __esm(() => {
       "Anchor class_scope on the callers that break, never on the changed line.",
       "Say when the radius could not answer \u2014 a non-code change has an empty one."
     ]),
+    skill("review-degradation", "review", ["full"], "Ask whether the code is worse after a change than on the base branch (behaviour, defaults, speed, structure) and whether that can be shown, over the diff plus every consumer of each changed shared symbol.", [
+      "Read the diff against the description before reading any consumer.",
+      "Trace the consumers the code graph lists for each changed shared export; the set is the graph's, not yours.",
+      "Name one degradation class and one evidence kind per finding; a major or blocker without evidence is lowered to info at ingest.",
+      "Say what was traced when nothing was found, and say when the consumer cap dropped any."
+    ]),
     skill("review-pr-contract", "review", ["recommended", "full"], "Compare what the PR body claims (checklist boxes, stated changes) with the diff, and look for documentation outside the diff that the change made stale.", [
       "Work every checklist box in pr-context.md as a row: quoted box, state, quoted diff line, expectation.",
       "File a finding only where a quoted box or claim disagrees with a quoted diff or document line.",
@@ -9733,6 +9739,7 @@ var init_skill_length_ceilings = __esm(() => {
     "review/review-backend": 361,
     "review/review-clean-code": 538,
     "review/review-core-boundaries": 158,
+    "review/review-degradation": 191,
     "review/review-flow-graph": 183,
     "review/review-frontend": 607,
     "review/review-frontend-conventions": 206,
@@ -30058,6 +30065,7 @@ var IMPACT_TEMPLATE = "A high-risk hunk with no test in the same diff exercising
 // src/review/slice-routing.ts
 var ALWAYS_ROLE = "review-logic";
 var REGRESSION_ROLE = "review-regression";
+var DEGRADATION_ROLE = "review-degradation";
 var DEEP_ROLES = [...CORE_MANDATORY_REVIEWER_IDS, REGRESSION_ROLE];
 var DOC_FILE = /(\.(md|mdx|rst|txt|adoc)$|(^|\/)docs?\/)/i;
 var STYLE_FILE = /(\.(css|scss|sass|less|styl)$|(^|\/)(styles?|themes?)(\/|\.)|\.(styles?|theme)\.[jt]sx?$)/i;
@@ -30077,6 +30085,7 @@ var SECURITY_PRINCIPLE = new RegExp([
   String.raw`process\.env|\bBun\.env\b|\benv\[`,
   String.raw`\bfetch\(|\bhttps?\.(get|request)|\bnet\.|\bWebSocket\b|\bsocket\b|new URL\(`
 ].join("|"));
+var SHARED_SYMBOL_CHANGE = /^[+-]\s*export\s+(\*|\{|default\b|declare\b|abstract\b|(async\s+)?(function|class|interface|type|const|let|var|enum)\b)/m;
 var ENTRY_FILE = /(^|\/)(index|mod|main)\.[cm]?[jt]sx?$/;
 var ROLE_RULES = [
   { role: "review-testing-practices", why: "test file", path: (f) => isTestFilePath(f) || BUNDLED_PATH_GATES["review-testing-practices"](f) || /\.stories\.[jt]sx?$/.test(f) },
@@ -30093,6 +30102,7 @@ var ROLE_RULES = [
   { role: "review-architecture", why: "agent instructions (skill, rule, AGENTS/CLAUDE file, prompt)", path: (f) => AGENT_INSTRUCTION_FILE.test(f) },
   { role: "review-architecture", why: "contract or schema", path: (f) => CONTRACT_FILE.test(f) },
   { role: "review-architecture", why: "exported signature or contract type changed", content: /^[+-]\s*export\s+(declare\s+)?(type|interface|abstract\s+class|enum)\b|^[+-]\s*export\s+(async\s+)?function\s+\w+\s*[<(]/m },
+  { role: DEGRADATION_ROLE, why: "shared (exported) symbol changed", content: SHARED_SYMBOL_CHANGE, codeOnly: true },
   { role: "review-security-code", why: "process, argv, git, input-derived path, env or network", content: SECURITY_PRINCIPLE, codeOnly: true },
   { role: "review-security-code", why: "process, filesystem write or trust-sensitive code", content: /\b(exec|execSync|execFile|spawn|spawnSync|Bun\.spawn|child_process|eval|new Function|innerHTML|dangerouslySetInnerHTML|password|passwd|secret|token|credential|api[_-]?key|sanitiz\w*|escape\w*|redact\w*|untrusted|trust\w*|permission\w*|allow-?list|deny-?list|sandbox\w*|cookie|cors|csrf|jwt|writeFile\w*|rm|unlink|rmdir|chmod|symlink\w*|realpath)\b/i, codeOnly: true },
   { role: "review-security-code", why: "auth, crypto or secret path", path: (f) => /\b(auth|login|session|permission|acl|rbac|credential|crypto|cipher|secret|security|trust|sandbox)\w*/i.test(f) && !isTestFilePath(f) && !DOC_FILE.test(f) },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrciphersmith/keryx",
-  "version": "0.3.133",
+  "version": "0.3.135",
   "description": "Version-controlled project context for AI coding agents: code graph, architecture wiki, project memory, relevant tests, quality signals, and task flows.",
   "private": false,
   "publishConfig": {
@@ -73,7 +73,6 @@
     "README.md",
     "package.json"
   ],
-  "dependencies": {},
   "overrides": {
     "fast-uri": "^3.1.9",
     "body-parser": "^2.4.0",
@@ -85,6 +84,7 @@
     "protobufjs": "7.6.6",
     "sharp": "0.35.5"
   },
+  "dependencies": {},
   "optionalDependencies": {
     "@modelcontextprotocol/sdk": "^1.32.1",
     "@opentui/core": "^0.4.5",

package/src/gdskills/bundled/install-manifest.json

@@ -455,7 +455,7 @@
     },
     "review-core-skills": {
       "kind": "skill",
-      "description": "Generic (non-stack-specific) review skills: orchestrator, logic, architecture, security, performance, clean-code, highload, regression, core-boundaries, flow-graph, layout, style, testing-practices, verifier, premise, pr-feedback, and the legacy AI/learned/style review profiles.",
+      "description": "Generic review skills: orchestrator, logic, architecture, security, performance, clean-code, highload, regression, degradation, core-boundaries, flow-graph, layout, style, testing-practices, verifier, premise, pr-feedback, and legacy AI/learned/style profiles.",
       "paths": [
         "src/gdskills/bundled/skills/review/review-orchestrator/**",
         "src/gdskills/bundled/skills/review/review-logic/**",
@@ -465,6 +465,7 @@
         "src/gdskills/bundled/skills/review/review-clean-code/**",
         "src/gdskills/bundled/skills/review/review-highload/**",
         "src/gdskills/bundled/skills/review/review-regression/**",
+        "src/gdskills/bundled/skills/review/review-degradation/**",
         "src/gdskills/bundled/skills/review/review-pr-contract/**",
         "src/gdskills/bundled/skills/review/review-core-boundaries/**",
         "src/gdskills/bundled/skills/review/review-flow-graph/**",

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

@@ -0,0 +1,191 @@
+---
+name: review-degradation
+model_tier: deep
+description: |
+  Use when: asking whether the code is WORSE after a change than on the base branch
+  (behaviour, defaults, speed or structure) and the answer can be shown. Dispatched
+  by review-orchestrator in a deep round at profile `full`, over the diff plus the
+  graph-listed importers of the module that holds each shared export the diff changed.
+  NOT for: the dependents-only regression check (that is review-regression), and NOT
+  for style, naming or architecture of code the change did not touch.
+triggers:
+  - "review degradation"
+  - "is the code worse than base"
+  - "degradation against the base branch"
+metadata:
+  author: "MrCipherSmith"
+  version: "1.0.0"
+  category: "review"
+  compatible_harnesses: "cursor,codex,zed,opencode,claude"
+  origin: "authored"
+license: "MIT"
+---
+
+# Review: Degradation
+
+How this differs from `review-regression`, before anything else:
+
+| | `review-regression` | `review-degradation` |
+|---|---|---|
+| Looks at | dependents of the change only | the diff itself plus the importers of each changed shared export's module |
+| Floor | `major`; below it the ingest screen refuses the finding | none: `blocker`, `major`, `minor`, `info` |
+| Set | the blast-radius files, refused in code if outside them | the consumers `keryx gdgraph affected` lists, never chosen by you |
+
+`review-regression` is untouched by this reviewer and keeps its own screen. Do not re-file its findings; do not widen yours into its question.
+
+Your inputs are the reviewer payload only; session memory and earlier conversation are not inputs. You run no command unless your payload's `allowed_tools` says `run-tests`, except the read-only `git log`, `git blame` and `git show` where your host gives a read-only child git (keryx shell does not: there the payload supplies the history).
+
+## The one question
+
+> After this change, is the code worse than on the base branch: in behaviour, in defaults, in speed or in structure, and can that be shown?
+
+"Worse" is measured against the base branch, not against an ideal. Code that was
+already imperfect on the base is not a finding; it goes in the **pre-existing** lane.
+
+## Classes
+
+Every finding carries exactly one `degradation_class`:
+
+| Class | The change made the code worse by | Example shape |
+|---|---|---|
+| `behaviour-delta` | behaving differently from base on an input or event | an Escape key press handled by a nested popup now closes the parent |
+| `default-change` | moving a default or a normalisation | an empty value now falls to a different placeholder in every consumer of a shared component |
+| `diff-vs-description` | the description and the diff disagreeing | the description says shared code is unchanged, the diff edits it |
+| `debt` | adding structure that must be paid back | a second data model beside the existing one, a dead branch, a leftover of the old surface |
+| `performance` | making a path slower | every keystroke rebuilds all rows |
+| `cross-pr` | conflicting with another open change | whichever lands second silently drops the other's fix |
+| `blind-test` | a test that cannot see the regression | it uses the one input that works, or pins a neighbour of the changed symbol |
+
+## Evidence
+
+A finding is a claim; evidence is what makes it one. Every non-pre-existing
+minor, major or blocker carries one `evidence_kind`, and `evidence` says what you ran or read:
+
+| Kind | What it is |
+|---|---|
+| `probe` | you ran the code, or a script against it, on head and on base, and the outputs differ |
+| `consumer-trace` | you followed a consumer of the changed symbol to its effect, file by file |
+| `merge-trace` | you merged two heads (or traced the merge) and showed what the second drops |
+| `red-test` | you wrote or named a test that fails on the head and passes on the base |
+| `base-diff` | you read the same path on base and on head and quote both |
+
+`probe`, `red-test` and `merge-trace` run code, so they need `allowed_tools` to include
+`run-tests`. Without it, `consumer-trace` and `base-diff` are still evidence: a trigger and outcome you
+read in the code is a finding, `major` when a user who reaches it gets a wrong, lost or blocked result.
+A question is for what the code cannot answer (a backend reply, data, timing), not for what you did not run.
+
+This is enforced, not requested. `keryx review ingest` lowers a `major` or
+`blocker` of this reviewer that has no `evidence_kind` to `info`, marks it unproven
+and lists it in `scope.md` under `## Degradation evidence screen` with the rule
+`degradation-no-evidence`. A true claim survives, labelled; other reviewers' findings are not touched.
+
+## What you are given
+
+- the diff, and the PR description when there is one;
+- the importers of the module that holds each changed shared export (and of a barrel that re-exports it), from the code graph, under one cap shared by all exports, with what it dropped. Trace those first. If the cap dropped consumers, say so in your summary; do not imply a complete sweep.
+  Where the graph lists no importers for a changed export (a barrel, a re-export, a file it has no node for), search for the users of the symbol, mark them `search-derived` in `enumeration_method`, and name in the summary the exports the graph could not answer;
+- the flow's frozen acceptance criteria, and the previous round's findings.
+
+## How to look
+
+Two passes, in this order. Done when every candidate of the sweep is filed, refuted or placed in a lane with its reason.
+
+1. **Sweep**, no severity floor. Read the diff against the description: anything it calls
+   unchanged and the diff edits is a `diff-vs-description` candidate. For each changed shared
+   symbol, default, stored field, mode or signature, read its consumers before the symbol: the
+   assumption sits at the consumer, and the change moves what the consumer receives. When the
+   change swaps a mechanism (a native attribute for a custom one, a reset on load for a rule, sync
+   for async), list what the old one did implicitly (styling and focus keyed on it, form submit, an
+   event default, a reset of dependent fields) and check the new path still does each. Compare
+   behaviour, not text (an event, a default, a fallback, an ordering, how many times a step runs):
+   show it on head and on base. Count work per trigger (each keystroke, render, request) and what it
+   scales with. For each test the change added or leaned on, ask whether it would fail if the
+   regression were real.
+2. **Refute** every candidate you would file as `blocker`, `major` or suspicion. Try to prove
+   yourself wrong with a `file:line` read: does the base do the same on this path, is there a
+   guard upstream or downstream, does a comment, commit or sibling give a reason (law 4), does
+   the description name it. Put the attempt in `evidence` ("refute: read a.ts:12, no guard").
+   What survives keeps its severity; what falls is dropped or goes to pre-existing.
+
+## Output lanes
+
+Four lanes, no more:
+
+- **Findings**: worse than base, with a class, evidence and `class_scope`.
+- **Suspicions**: `info` with `publication: "question"` when the trigger or the outcome sits
+  outside the code (a backend reply, data, timing) and you cannot show it. `problem` ends with
+  "If true: <major|minor>, <outcome>"; `fix` is "Check: <the one request, test or command that
+  settles it>", which the author can run. Without both it is noise, not a suspicion.
+- **Pre-existing**: `location_class: "pre-existing"`. True, not caused by this change, not blocking.
+- **Verified clean**: in `summary`, one line per thing traced, naming it (the symbol, the consumers, the command).
+
+## Class scope: required for `blocker` and `major`
+
+`class_scope` lists **every** site with the shape, and how you enumerated them. For
+this reviewer the sites are usually consumers; the enumeration is the walk over the
+graph's consumer list. "I checked the others" is not a method.
+
+```yaml
+class_scope:
+  sites: ["src/screens/a.ts:40", "src/screens/b.ts:12"]
+  enumeration_method: "every consumer of the changed component in the payload; 2 of 9 pass no value"
+```
+
+```markdown
+### [F-NNN] Title
+
+- **Severity**: blocker | major | minor | info
+- **Class**: behaviour-delta | default-change | diff-vs-description | debt | performance | cross-pr | blind-test
+- **Evidence kind**: probe | consumer-trace | merge-trace | red-test | base-diff
+- **File**: path/to/file.ts:line
+- **Problem**: what is worse than on base
+- **Why it matters**: impact
+- **Fix**: concrete suggestion
+```
+
+Severity comes from **Severity (canonical)** in `review-orchestrator/SKILL.md` (`blocker` is its four merge-blocking shapes; `major` and `minor` split on the trigger-and-outcome test); no table here. A `diff-vs-description` is `major` at most, `blocker` only when the change it exposes has a blocker shape itself. When dispatched, follow the `reviewer-input.schema.json` payload and return a `REVIEW_RESULT` object compatible with
+`.metaproject/skills/gdskills/review/review-orchestrator/reviewer-finding.schema.json`, then a short summary; `NEEDS_CONTEXT` rather than a guess. On a FIX slice, also return `prior_dispositions: [{id, disposition}]` for every attached finding id.
+
+### 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.
+4. **A deliberate choice is not a defect until its reason is read and shown wrong.** An explicit override, suppression or exemption, a comment or commit giving a reason, or a sibling doing the same is a decision: read its reason (the comment, `git log -L` or `git blame`, the sibling) before you report it, and report it only when you can show that reason wrong. A project rule is checked against accepted platform practice and its known exceptions before a deviation from it is reported.
+
+---
+
+## Red Flags
+
+| Rationalization | Why it is wrong |
+|----------------|-----------------|
+| "My first read is enough for a `major`." | Pass 2 tries to refute it first: the base, a guard, a stated reason. A `major` without a refutation attempt in `evidence` is not ready. |
+| "This code was already messy, and the change sits next to it." | Worse than the base is the question. Pre-existing goes in its own lane, not in findings. |
+| "I will name the consumers I think matter." | The graph's list comes first. A model-chosen set is the sweep that misses the consumer nobody thought of; extra users you find by search are added, labelled `search-derived`. |
+| "I could not run it, so it is a question or a `minor`." | A traced trigger and outcome is a finding without a run, and `major` when a user gets a wrong, lost or blocked result. Ask only what the code cannot answer. |
+| "The new test passes, so the change is covered." | A test that uses the one input that works cannot see the regression. Ask whether it fails when the behaviour is wrong. |
+
+---
+
+## Verification
+
+Report done only once all of these hold:
+
+- Every finding has one `degradation_class` and one `evidence_kind`, and `evidence` says what was run or read.
+- Every `blocker` and `major` carries `class_scope` whose `enumeration_method` is the walk over the graph's consumer list.
+- Every consumer in the payload was traced, or the summary says which were not and why, and whether the cap dropped any.
+- Every `major`, `blocker` and suspicion names its refutation attempt; every suspicion has "If true" and "Check".
+- The summary has a verified-clean line for each thing traced without a finding, naming what was traced.
+
+<!-- keryx:layers-block:start -->
+## Project layers: graph, tests, wiki, memory
+
+Your payload may carry a `layers` block for your files: the files the graph says are affected, symbol neighbours, related tests, the wiki pages that describe the files and the memory entries for their module. It is bounded, and `truncated` names what was cut and the command that fetches the rest. When the diff alone does not settle a question, ask the project. Each command below is read-only and calls no model.
+
+- `keryx gdgraph affected <file>`: who depends on the file. Use it before you call a change contained, and whenever a changed export, signature or behaviour may have callers outside your files.
+- `keryx test related <file>`: the tests that cover the file. Use it before you say a behaviour is untested, and to judge whether a test would fail if the code broke.
+- `keryx wiki ask "<q>"`: what the project wiki says a module is for and which rules bind it. Use it when the intent of the code is unclear and the diff does not state it.
+- `keryx memory search "<q>"`: recorded lessons, decisions and known mistakes. Use it before you report a pattern the project may already have decided on, and when a failure looks like one it has seen.
+
+In a review package, `keryx gdgraph affected <file> --data-dir <package>/layers/graph` reads the graph built at the PR head; the tracked graph may be from another commit. A finding still rests on the code you read: what a layer says is a lead, not evidence. If a layer is empty or a command fails, say so in the report instead of guessing.
+<!-- keryx:layers-block:end -->

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

@@ -270,14 +270,12 @@ bound the round.
 Two channels, and both work:
 
 - `--blast-radius <file>` — always correct, and the one to use.
-- `.metaproject/reviews/blast-radius.json` (or
-  `.metaproject/flows/<flow>/reviews/blast-radius.json` for a flow-attached
-  round) — the handoff slot, read when no flag is passed. The ingest **consumes**
-  it: it is copied into the package it screened and removed from the slot, so a
-  later round cannot be screened against a set nobody recomputed.
+- `.metaproject/reviews/blast-radius.json` (or `.metaproject/flows/<flow>/reviews/blast-radius.json` for a flow-attached round) — the handoff slot, read when no flag is passed. The ingest **consumes** it: copied into the package it screened and removed from the slot, so a later round cannot be screened against a set nobody recomputed.
 
 Do **not** write the record inside the package directory before the ingest. A round that names no `--review-id` has not allocated that directory yet, and creating it makes the ingest take the next free name instead.
 
+`review-degradation` (profile `full`, deep tier) asks what the regression screen does not: is the code worse than on the base, and can that be shown? It reads the diff plus the importers of the module that holds each changed shared export (and of a barrel that re-exports it), which `keryx review blast-radius --degradation [--degradation-cap <n>]` prints from the code graph under one cap shared by all exports; the model never picks the set. It has no severity floor and needs no `--blast-radius` record. A `major` or `blocker` of its with no `evidence_kind` is lowered to `info` at ingest and listed in `scope.md` under `## Degradation evidence screen`. A light round does not dispatch it. A delta round dispatches it on a fix slice that changes a source-code file (not a test, a document or a data file) and on every new deep slice; a fix slice's lines cannot tell whether they sit inside an exported function, so the payload settles it.
+
 `--refuted` takes the findings this round **raised and then dismissed**, in the
 same finding shape, each carrying `disposition: {state, evidence}` with one of
 the `dismissed-*` states. Without it a package keeps only the survivors of an
@@ -775,6 +773,8 @@ sites**? The orchestrator refuses, in code, a finding that is `outside-set`, bel
 `--brief` verbatim so no reviewer spends the round on findings that will be refused. `class_scope`
 names the caller that breaks.
 
+`review-degradation` is told its consumers by the graph, not by its own search: before each dispatch of it (a deep slice, or a delta round's fix or new deep slice), run `keryx review blast-radius --ref "${BASE_SHA}" --package "${PKG}" --degradation` from the worktree root and hand its stdout to the reviewer verbatim as its payload section. It needs no `--blast-radius` record; without the payload the reviewer has no consumers to read.
+
 Recompute scope B on rounds 2..N only when the changed-file set moved, and always on the final round:
 
 ```bash

package/src/gdskills/bundled/skills/review/review-orchestrator/reviewer-finding.schema.json

@@ -131,6 +131,18 @@
             "enum": ["finding", "question", "omit"],
             "description": "How an info finding is shown. question renders under Questions. omit stays in the keryx:findings block and is not published as a finding. Absent means finding. Never changes severity."
           },
+          "degradation_class": {
+            "title": "Which way the change made the code worse than the base branch",
+            "type": "string",
+            "enum": ["behaviour-delta", "default-change", "diff-vs-description", "debt", "performance", "cross-pr", "blind-test"],
+            "description": "Optional, set by `review-degradation`. Closed list: `behaviour-delta` (the diff behaves differently from base), `default-change` (a default or normalisation moved), `diff-vs-description` (the description and the diff disagree), `debt` (structure the change adds), `performance` (a slower path), `cross-pr` (two changes that conflict on merge), `blind-test` (a test that cannot see the regression)."
+          },
+          "evidence_kind": {
+            "title": "What proves a degradation finding",
+            "type": "string",
+            "enum": ["probe", "consumer-trace", "merge-trace", "red-test", "base-diff"],
+            "description": "Optional. Closed list: `probe` (a run that shows the difference), `consumer-trace` (a consumer of the changed symbol followed to its effect), `merge-trace` (the merged result of two heads), `red-test` (a test that fails on the head), `base-diff` (the same path read on base and on head). A `major` or `blocker` from `review-degradation` without it is downgraded to `info` at ingest, not rejected."
+          },
           "class_scope": {
             "title": "Every site of this shape, and how the set was derived",
             "description": "A finding anchored to one file:line is a claim about one site. Repeatedly, a fix repaired that site and left its siblings — one writer of five, one operator instruction of four, six readers of eight — and the next review round found them. Required for blocker and major; optional below, because enumerating the class for every info finding is theatre. Kept identical to src/gdskills/contracts/review-finding.schema.json, which is stricter (additionalProperties: false) and would reject this property if it were declared only here.",

package/src/gdskills/contracts/review-finding.schema.json

@@ -287,6 +287,29 @@
         }
       }
     },
+    "degradation_class": {
+      "title": "Which way the change made the code worse than the base branch",
+      "type": "string",
+      "enum": ["behaviour-delta", "default-change", "diff-vs-description", "debt", "performance", "cross-pr", "blind-test"],
+      "description": "Optional, set by `review-degradation`. Closed list: `behaviour-delta` (the diff behaves differently from base), `default-change` (a default or normalisation moved), `diff-vs-description` (the description and the diff disagree), `debt` (structure the change adds), `performance` (a slower path), `cross-pr` (two changes that conflict on merge), `blind-test` (a test that cannot see the regression)."
+    },
+    "evidence_kind": {
+      "title": "What proves a degradation finding",
+      "type": "string",
+      "enum": ["probe", "consumer-trace", "merge-trace", "red-test", "base-diff"],
+      "description": "Optional. Closed list: `probe` (a run that shows the difference), `consumer-trace` (a consumer of the changed symbol followed to its effect), `merge-trace` (the merged result of two heads), `red-test` (a test that fails on the head), `base-diff` (the same path read on base and on head). A `major` or `blocker` from `review-degradation` without it is downgraded to `info` at ingest, not rejected."
+    },
+    "evidence_screen": {
+      "title": "Written by ingest when it downgraded a finding for missing evidence",
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["rule", "original_severity"],
+      "description": "A reviewer never writes this. It marks a finding as unproven: the original severity is kept here so the downgrade is visible and reversible.",
+      "properties": {
+        "rule": { "type": "string", "const": "degradation-no-evidence" },
+        "original_severity": { "type": "string", "enum": ["blocker", "major"] }
+      }
+    },
     "class_scope": {
       "title": "Every site of this shape, and how the set was derived",
       "description": "A finding anchored to one file:line is a claim about one site. Repeatedly, a fix repaired that site and left its siblings — one writer of five, one operator instruction of four, six readers of eight — and the next review round found them. Required for blocker and major; optional below, because enumerating the class for every info finding is theatre.",