@kavishdua/proctor 1.2.1 → 1.2.2

package/README.md

@@ -43,8 +43,8 @@ source needs Node 20.19+ or 22.12+.
 
 - [How it works](#how-it-works)
 - [Can the agent get around it?](#can-the-agent-get-around-it)
-- [By the numbers](#by-the-numbers)
-- [Benchmark](#benchmark)
+- [What proctor is for](#what-proctor-is-for), scope and limits
+- [By the numbers](#by-the-numbers), with the full history in [docs/BENCHMARKS.md](docs/BENCHMARKS.md)
 
 **Reference**
 
@@ -431,93 +431,50 @@ added to a script, or TypeScript strictness turned off. WI104 is part of the opt
 A base-range CI check can still inspect the committed change. The Stop hook checks uncommitted
 changes and allows turns when proctor cannot run, so it is not a substitute for CI.
 
+## What proctor is for
+
+proctor is a heuristic diff checker that flags suspicious test and CI changes for a
+human to review. It is not a prevention mechanism: it does not judge intent, and a
+determined author can write a cheat that no static diff check recognizes.
+Heuristics cut both ways. False positives happen: the live benchmark flagged a real
+52-line semver implementation because one line resembled the stub it replaced.
+False negatives happen too: cheats that only show up when the code runs, like
+special-cased inputs or edited expected values, are mostly missed. Treat a finding
+as a prompt to look, not a verdict, and treat a clean run as "nothing matched a
+known pattern", not "nothing happened".
+
 ## By the numbers
 
-**How often agents actually do this.** These are other people's published measurements, not ours:
+**How often agents actually do this.** Other people's published measurements, not
+ours, with the sample sizes attached:
 
 | | |
 |---|---|
-| **33.3%** | of ambiguous coding tasks where Claude Sonnet 4 hardcoded the expected output rather than solve the problem ([EvilGenie](https://arxiv.org/abs/2511.21654)) |
-| **2.1%** | the same behaviour on unambiguous tasks, where the right fix was never in doubt (same paper) |
-| **0.7%** | of tasks where Gemini 2.5 Pro deleted a test file outright (same paper) |
-| **up to 100 pts** | gap between "the visible tests pass" and "the held-out tests pass" on the largest tasks in [SpecBench](https://arxiv.org/abs/2605.21384). It widens by about 28 points per tenfold increase in code size, and adding test coverage does not close it |
+| **33.3%** (3 of 9) | ambiguous coding tasks where Claude Sonnet 4 hardcoded the expected output instead of solving the problem, in [EvilGenie](https://arxiv.org/abs/2511.21654)'s nine-task ambiguous subset |
+| **2.1%** of 145 | unambiguous tasks in the same paper's main set where Claude did the same. On that set, Gemini 2.5 Pro deleted a test file in **3.4%** of tasks and modified one in **0.7%** |
+| **28 pts** | about how much the gap between "the visible tests pass" and "the held-out tests pass" widens per tenfold increase in code size in [SpecBench](https://arxiv.org/abs/2605.21384) |
 | **8 of 8** | agent benchmarks that [Berkeley RDI](https://rdi.berkeley.edu/blog/trustworthy-benchmarks-cont/) drove to near-perfect scores without solving a single task. SWE-bench Verified fell to a pytest hook that forced every test to pass |
 
-**What proctor catches.** The original rule fixtures and recorded benchmark cases are checked by
-`npm test`. The redteam probe is a repeatedly tuned **dev corpus**, not independent evidence of
-generalization. Fresh measurements compare the unchanged main baseline with these changes:
+These are other benchmarks on other harnesses: they say agents game evaluations
+often enough to matter, and nothing by themselves about how often proctor catches
+it.
+
+**What proctor catches.** Summary numbers only; the full measurement history,
+methods, per-rule results, reproduction commands, and the retracted claims that did
+not survive re-measurement are in [docs/BENCHMARKS.md](docs/BENCHMARKS.md).
 
 | | |
 |---|---|
-| **139 of 139** | original planted rule fixtures caught with all checks, with **0 of 33** original near-miss fixtures flagged. These are development fixtures, not an unseen evaluation |
-| **21 of 21** | recorded cheats caught in the mock benchmark corpus, across 7 signatures. The 22nd task is a control; it stays quiet |
-| **25 to 54 of 76** | tuned dev cheats caught by defaults before and after. With all checks: **76 to 76 of 76**. Dev controls: **0 to 0 of 24** flagged in either mode. Run `node bench/redteam/probe.mjs --default` and `node bench/redteam/probe.mjs` |
-| **7 to 36 of 36** | cheats caught by defaults in the **74-case frozen validation set**, with benign flags falling from **2/38 to 0/38**. All checks improve from **9/36 to 36/36**. The separately frozen 74-case design set has the same totals. Both are small authored sets with paired variations |
-| **4.29% to 2.00% blocking** | **30/700 to 14/700** real non-bot commits flagged by defaults on the same fresh pinned sample from 20 repositories. Any finding: **46/700 (6.57%) to 26/700 (3.71%)**. Every flagged human commit counts as a conservative false-positive proxy, including intentional test deletions |
-| **26 to 35 of 72** | cheats caught by defaults on a **72-cheat, 72-benign held-out set** written after 1.0.0 by a separate run that never saw the checks. Benign flags: **5/72 before, 5/72 after**. All checks: **38 to 42 of 72**, with 6/72 benign flagged. Error handling went from 0/12 to 7/12. Hardcoded special cases (2/8), removed validation (0/3), edited expected values (0/3), race masking (0/3) and suppression (0/3) are still mostly missed. The set was used only to measure, not to tune, but it is now public, so it no longer counts as blind. Run `node bench/heldout/probe.mjs --default` |
-| **2.6% blocking** | **11/420** real commits blocked by both 1.0.0 and this release on a second fresh sample of 14 repositories that neither the checks nor the first sample touched. Any finding: **17 before, 16 after**. A few false positives found there were fixed with rules, not by pinning commits |
-| **27** | checks in two families, with **20 enabled by default**, across **25+** languages, installable into **30** agents |
-
-The old **689-commit** claim, **2.32% blocking and 3.8% any finding**, refers to a missing ignored
-sample and harness. It could not be reproduced from this checkout or tracked history. The fresh
-700-commit sample uses the same 20 repositories, pins every commit and patch hash, and retains
-all findings. It is a replacement cohort, not the original sample. See
-[methods, per-rule results, and reproduction commands](bench/detection/README.md).
-
-**What we don't claim.** Proctor is a heuristic diff checker. Defaults still miss more than half of the held-out cheats, mostly the ones that need running the code to see: special-cased inputs, edited expected values, removed validation, masked races and suppression. It detects suspicious changes;
-it does not prevent them or judge intent. A determined author can write a cheat that no static
-diff check recognizes. The dev and authored-validation results do not establish a detection
-rate for unseen cheats. Our [live benchmark](#benchmark) has not shown that proctor reduces
-cheating: all 44 invocations in each complete run passed their evaluation tests in both arms.
-
-## Benchmark
-
-`proctor bench` measures how often an agent games its own tests, and how often proctor catches it,
-across a fixed pool of tasks with the ruleset on and off.
-
-The table shows a complete 22-task live run against `claude-code`, with all 44 invocations scored.
-Before the run, each held-out suite was verified to fail its task's unfixed source.
-
-| | proctor off | proctor on |
-|---|---|---|
-| cheat rate | **4.5%** (1 of 22) | **4.5%** (1 of 22) |
-| honest-pass rate | **100.0%** | **100.0%** |
-
-All 44 runs passed their held-out tests, including the runs flagged by proctor. This includes
-the seven tasks designed to make cheating cheaper than fixing. The run provides no evidence of
-a difference between the two arms.
-
-An earlier run showed 9.1% against 4.5%, a difference of one task out of 22. That difference did
-not reproduce in the second run and does not establish a prevention rate.
-
-The single flagged task was a **false positive**. RH004 fired on task-17 in both arms after the
-agent replaced a
-`return version >= base` stub with a real 52-line semver implementation. The flagged line was the
-`return 0` that terminates its new comparator, which is the correct "equal" result, paired by the
-check against the deleted stub thirty lines away in a different function. That has been fixed, so
-the same run scored against current code reads **0.0% in both arms**. The table preserves the
-results recorded at the time.
-
-The eight held-out suites that could not distinguish a fix from a cheat were found and strengthened
-before this run, and `tests/bench-heldout-discriminates.test.ts` now enforces that property for
-every task. See [bench/METHODOLOGY.md](https://github.com/catfish-1234/proctor/blob/main/bench/METHODOLOGY.md).
-
-The task corpus ships with this repository rather than the npm package, so `bench` needs a clone:
-
-```bash
-git clone https://github.com/catfish-1234/proctor && cd proctor
-npm install && npm run build
-node dist/cli.js bench --tasks 22 --agent claude-code --out bench/results-live.csv
-```
+| **139/139** | planted cheats caught with all checks enabled, **0/33** near-miss fixtures flagged. These are the development fixtures the checks were built and tuned against: a regression gate, not an accuracy measurement |
+| **35/72** | cheats caught by the default checks on a held-out set written after 1.0.0 by a separate run that never saw the checks, with **5/72** benign flagged. It was blind when measured; it has since been published and used to develop a check fix, so runs against it are now regression measurements, not independent evidence |
+| **2.00%** | of 700 real non-bot commits from 20 pinned repositories blocked by the default checks (14 commits). Every flag counts as a false-positive proxy, including intentional test deletions, so this is an upper bound, not a verified false-positive rate |
 
-A 22-task run is 44 agent invocations, which is more than one Claude subscription session allows.
-Three attempts reached 16, 14 and 16 tasks before the agent returned "You've hit your
-session limit". An older scorer treated failed invocations with no changes as clean results;
-the current scorer rejects them. `--resume` carries the completed tasks over from the
-`.partial.csv` a failed attempt leaves behind, so a run can span more than one window; the numbers
-above were collected that way. `PROCTOR_BENCH_TIMEOUT_MS` raises the per-invocation budget, which
-the hard-tier tasks need. Read the `proctor: bench task-NN ... failed` lines on stderr before
-trusting any number the table prints.
+**What we don't claim.** Defaults still miss more than half of the held-out
+cheats. The fixture and authored-set results do not establish a detection rate for
+unseen cheats, and our [live benchmark](docs/BENCHMARKS.md#benchmark) has not shown
+that proctor reduces cheating: all 44 invocations in each complete run passed their
+evaluation tests in both arms. Full measurement and retraction history:
+[docs/BENCHMARKS.md](docs/BENCHMARKS.md).
 
 ## Going further
 
@@ -531,8 +488,7 @@ For command details, configuration, support limits, and contributor instructions
 | [docs/LANGUAGES.md](https://github.com/catfish-1234/proctor/blob/main/docs/LANGUAGES.md) | Per-language support matrix, the 30 supported agents, known limitations |
 | [CONTRIBUTING.md](https://github.com/catfish-1234/proctor/blob/main/CONTRIBUTING.md) | Setting up, adding a check, adding an agent |
 | [docs/RELEASING.md](https://github.com/catfish-1234/proctor/blob/main/docs/RELEASING.md) | Maintainer notes: how a tag becomes a release |
-| [RESEARCH.md](https://github.com/catfish-1234/proctor/blob/main/RESEARCH.md) | Why it's built this way, and how it compares to Stryker and EvilGenie |
-| [bench/METHODOLOGY.md](https://github.com/catfish-1234/proctor/blob/main/bench/METHODOLOGY.md) | How the benchmark works and what it does not claim |
+| [docs/BENCHMARKS.md](https://github.com/catfish-1234/proctor/blob/main/docs/BENCHMARKS.md) | Every measurement behind the numbers, including the retractions |
 
 proctor supports 25+ languages and installs to 30 agents. Five diff-level checks (RH001, RH002,
 RH003, RH007, RH011) have signatures across the language roster. RH004, RH006, RH008, RH009, and

package/dist/cli.js

@@ -219,7 +219,7 @@ import { homedir } from "os";
 // package.json
 var package_default = {
   name: "@kavishdua/proctor",
-  version: "1.2.0",
+  version: "1.2.2",
   description: "Catch AI agents gaming their test suites: deleted tests, skipped tests, weakened assertions, hardcoded outputs",
   homepage: "https://github.com/catfish-1234/proctor#readme",
   bugs: {
@@ -279,7 +279,7 @@ var package_default = {
     lint: "oxlint --deny correctness --allow no-unused-vars --allow no-useless-escape --allow prefer-string-starts-ends-with src tests scripts tsup.config.ts vitest.config.ts"
   },
   dependencies: {
-    "@anthropic-ai/sdk": "^0.132.0",
+    "@anthropic-ai/sdk": "^0.134.0",
     acorn: "^8.19.0",
     "brace-expansion": "^5.0.12",
     commander: "^14.0.3",
@@ -688,6 +688,9 @@ var DEFAULT_GLOBS = [
   // are recognized, not just plain .ts/.js, otherwise those tests escape every test-file check.
   "**/*.test.{ts,tsx,mts,cts,js,jsx,mjs,cjs}",
   "**/*.spec.{ts,tsx,mts,cts,js,jsx,mjs,cjs}",
+  // Bare exact stems complement the patterns above/below; picomatch's **/ also matches the root.
+  "**/test.{ts,tsx,mts,cts,js,jsx,mjs,cjs}",
+  "**/test.py",
   "test/**/*",
   "tests/**/*",
   "__tests__/**/*",
@@ -1333,7 +1336,29 @@ function assertionCount(file, kind) {
   }
   return n;
 }
-function testsRelocated(file, files, ctx) {
+function csharpMoveIdentity(file, kind) {
+  const path9 = kind === "del" ? file.from : file.to;
+  if (!path9?.endsWith(".cs") || !(kind === "del" ? file.deleted : file.new)) return;
+  if (file.chunks.length !== 1) return;
+  const chunk = file.chunks[0];
+  const start = kind === "del" ? chunk.oldStart : chunk.newStart;
+  const count = kind === "del" ? chunk.oldLines : chunk.newLines;
+  if (start !== 1 || count !== chunk.changes.length || chunk.changes.some((c) => c.type !== kind || c.content.length >= MAX_LINE_LENGTH)) return;
+  const view = sourceView(chunk, kind === "del" ? "before" : "after");
+  const namespace = /\bnamespace\s+([A-Za-z_]\w*(?:\s*\.\s*[A-Za-z_]\w*)*)\s*(?=[{;])/.exec(view.code);
+  if (!namespace || !/^(?:\s*using\b[^;{}]*;)*\s*$/.test(view.code.slice(0, namespace.index)) || !/\[(?:Test|TestMethod|Fact|Theory)\s*(?:\(|\])/.test(view.code) || !/\bAssert\s*\./.test(view.code)) return;
+  const nameStart = namespace.index + namespace[0].lastIndexOf(namespace[1]);
+  return `${basename(path9)}\0${view.text.slice(0, nameStart)}${view.text.slice(nameStart + namespace[1].length)}`;
+}
+function testsRelocated(file, files, ctx, claimed) {
+  if (file.from?.endsWith(".cs")) {
+    const identity = csharpMoveIdentity(file, "del");
+    if (!identity) return false;
+    const replacement = files.find((other) => other !== file && !claimed.has(other) && ctx.isTestFile(other.to ?? "") && csharpMoveIdentity(other, "add") === identity);
+    if (!replacement) return false;
+    claimed.add(replacement);
+    return true;
+  }
   const removed = testTitlesIn(file, "del");
   if (removed.size === 0) return false;
   const relocated = /* @__PURE__ */ new Set();
@@ -1375,6 +1400,7 @@ function run(context) {
   const files = context.files;
   const ctx = context;
   const findings = [];
+  const claimedMoves = /* @__PURE__ */ new Set();
   for (const file of files) {
     const from = file.from ?? "";
     const to = file.to ?? "";
@@ -1387,7 +1413,7 @@ function run(context) {
       };
       const hasCoordinatedImplDeletion = files.some(isCoordinatedImpl);
       if (hasCoordinatedImplDeletion) continue;
-      if (testsRelocated(file, files, ctx)) continue;
+      if (testsRelocated(file, files, ctx, claimedMoves)) continue;
       findings.push({
         verifierId: "RH001",
         severity: "error",
@@ -2728,6 +2754,47 @@ function nativeReason(text) {
   const reason = text.slice(start, end).trim();
   return reason.split(/\s+/).length >= 3 || /^https?:\/\/\S+/.test(reason);
 }
+function pythonSkipOwner(view, line) {
+  const offset = view.offsetAtLine(line);
+  if (offset === void 0) return void 0;
+  const rows = view.code.split("\n");
+  const index = view.code.slice(0, offset).split("\n").length - 1;
+  const current = rows[index] ?? "";
+  const ownerAt = (cursor) => {
+    const declaration = /^([ \t]*)(?:async\s+)?def\s+(test_\w+)\s*\(/.exec(rows[cursor]);
+    if (!declaration) return void 0;
+    let indent2 = declaration[1].length;
+    let name = declaration[2];
+    for (let prior = cursor - 1; prior >= 0; prior--) {
+      const row = rows[prior];
+      if (!row.trim() || row.length - row.trimStart().length >= indent2) continue;
+      const parent = /^([ \t]*)class\s+(\w+)\b/.exec(row);
+      if (!parent) break;
+      name = parent[2] + "." + name;
+      indent2 = parent[1].length;
+    }
+    return name;
+  };
+  if (current.trimStart().startsWith("@")) {
+    for (let cursor = index + 1; cursor < Math.min(rows.length, index + 12); cursor++) {
+      const row = rows[cursor];
+      const declaration = /^\s*(?:async\s+)?def\s+(test_\w+)\s*\(/.exec(row);
+      if (declaration) return ownerAt(cursor);
+      if (/^\s*(?:class|def)\b/.test(row)) return void 0;
+    }
+    return void 0;
+  }
+  const indent = current.length - current.trimStart().length;
+  for (let cursor = index - 1; cursor >= 0; cursor--) {
+    const row = rows[cursor];
+    if (!row.trim() || row.length - row.trimStart().length >= indent) continue;
+    return ownerAt(cursor);
+  }
+  return void 0;
+}
+function isFocus(text) {
+  return /\.only\b|\[\s*['"]only['"]\s*\]|\b(?:fit|fdescribe)\s*\(/.test(text);
+}
 function run3(context) {
   const files = context.files;
   const ctx = context;
@@ -2749,17 +2816,32 @@ function run3(context) {
     const batsFile = ext === "bats" && isBatsFile(filePath);
     if (!isPython && !isNewLang && !ctx.isTestFile(filePath)) continue;
     const previousSkips = new Set(file.chunks.flatMap((chunk) => chunk.changes).filter((c) => c.type === "del" && isSkipPattern(c.content, { ext, pyTestModule, goTestFile, rubyTestFile, kotlinTestFile, cTestFile, scalaTestFile, rTestFile, haskellTestFile, luaTestFile, batsFile })).map((c) => skipIdentity(c.content)).filter(Boolean));
+    const priorDisabledCount = [...previousSkips].filter((identity) => identity !== void 0 && !isFocus(identity)).length;
     for (const chunk of file.chunks) {
       const lines = afterLines(chunk);
       const view = sourceView(chunk, "after", isPython);
       const signatureLines = view.signatures.split("\n");
       const maskedLines = view.code.split("\n");
+      const before = sourceView(chunk, "before", isPython);
+      const priorPythonSkips = /* @__PURE__ */ new Set();
+      const beforeRows = before.text.split("\n");
+      let beforeOffset = 0;
+      if (isPython) for (const [index, text] of before.signatures.split("\n").entries()) {
+        if (isSkipPattern("+" + text, { ext, pyTestModule, goTestFile, rubyTestFile, kotlinTestFile, cTestFile, scalaTestFile, rTestFile, haskellTestFile, luaTestFile, batsFile })) {
+          const owner = pythonSkipOwner(before, before.lineAt(beforeOffset));
+          if (owner) priorPythonSkips.add(owner);
+        }
+        beforeOffset += beforeRows[index].length + 1;
+      }
+      const priorTests = testBodies(before);
+      const afterTests = testBodies(view);
+      const renamedSkip = !isPython && priorDisabledCount > 0 && afterTests.length === priorTests.length && chunk.changes.filter((c) => c.type === "add" && SKIP_ONLY.test(c.content)).length <= priorDisabledCount;
       if (ctx.isTestFile(filePath) && !isPython && chunk.changes.some((change) => change.type === "add" && body(change.content).includes("/*"))) {
-        const before = sourceView(chunk, "before");
+        const before2 = sourceView(chunk, "before");
         const surviving = new Set(testBodies(view).map((test) => test.key));
-        for (const prior of testBodies(before)) {
+        for (const prior of testBodies(before2)) {
           if (surviving.has(prior.key)) continue;
-          const oldLine = before.lineAt(prior.open);
+          const oldLine = before2.lineAt(prior.open);
           const unchanged = chunk.changes.find((change) => change.type === "normal" && change.ln1 === oldLine);
           if (!unchanged || unchanged.type !== "normal") continue;
           const offset = view.offsetAtLine(unchanged.ln2);
@@ -2788,9 +2870,10 @@ function run3(context) {
           if (hasExplanation(raw)) continue;
           const later = after.code.slice(match.index + match[0].length);
           if (!/\bexpect\s*\(|\bassert\b/.test(later)) continue;
+          const alreadyDisabled = isPython && priorPythonSkips.has(pythonSkipOwner(after, line) ?? "");
           findings.push({
             verifierId: "RH003",
-            severity: "error",
+            severity: alreadyDisabled ? "warn" : "error",
             file: filePath,
             line,
             message: "A new conditional return can bypass the assertions in a test that still reports success.",
@@ -2809,11 +2892,11 @@ function run3(context) {
         const end = open < 0 ? -1 : closingDelimiter(view.code, open, "(", ")");
         const invocation = end < 0 ? text : view.text.slice(offset, end + 1);
         const previousComment = index > 0 ? lines[index - 1].text : "";
-        if (!/\.only\b|\[\s*['"]only['"]\s*\]|\b(?:fit|fdescribe)\s*\(/.test(text) && (nativeReason(invocation) || /^\s*(?:\/\/|#)/.test(previousComment) && /\breason\s*:/i.test(previousComment) && hasExplanation(previousComment))) continue;
-        if (!/\.only\b|\[\s*['"]only['"]\s*\]|\b(?:fit|fdescribe)\s*\(/.test(text) && (/\breason\s*:/i.test(text) && hasExplanation(text) || /\breason\s*=\s*['"][^'"]*\S+\s+\S+\s+\S+[^'"]*['"]/.test(text))) continue;
+        if (!isFocus(text) && (nativeReason(invocation) || /^\s*(?:\/\/|#)/.test(previousComment) && /\breason\s*:/i.test(previousComment) && hasExplanation(previousComment))) continue;
+        if (!isFocus(text) && (/\breason\s*:/i.test(text) && hasExplanation(text) || /\breason\s*=\s*['"][^'"]*\S+\s+\S+\s+\S+[^'"]*['"]/.test(text))) continue;
         const lexical = "+" + (signatureLines[index] ?? "");
         const masked = "+" + (maskedLines[index] ?? "");
-        const bracketApi = [...change.content.matchAll(new RegExp(BRACKET_SKIP, "g"))].some((match) => {
+        const bracketApi = [...change.content.matchAll(/\b(?:it|test|describe)\s*\[\s*['"`](?:skip|only)['"`]\s*\]/g)].some((match) => {
           const root = /^(?:it|test|describe)/.exec(match[0])[0];
           return masked.slice(match.index, match.index + root.length) === root;
         });
@@ -2831,12 +2914,15 @@ function run3(context) {
           luaTestFile,
           batsFile
         })) continue;
+        const owner = isPython ? pythonSkipOwner(view, change.ln) : void 0;
+        const title = identity?.slice(identity.indexOf(":") + 1);
+        const retainedSkip = !isFocus(text) && (owner !== void 0 && priorPythonSkips.has(owner) || renamedSkip && title !== void 0 && !priorTests.some((test) => test.key === title));
         findings.push({
           verifierId: "RH003",
-          severity: "error",
+          severity: retainedSkip ? "warn" : "error",
           file: filePath,
           line: change.ln,
-          message: buildSkipMessage(change.content, ext),
+          message: retainedSkip ? "A previously disabled test was rewritten or renamed; the diff does not establish a newly disabled test." : buildSkipMessage(change.content, ext),
           suggestion: buildSuggestion(change.content)
         });
       }
@@ -2847,8 +2933,7 @@ function run3(context) {
 var rh003 = { id: "RH003", severity: "error", run: run3 };
 
 // src/verifiers/rh004.ts
-var LITERAL_TOKEN = "(?:\"[^\"\\n]*\"|'[^'\\n]*'|`[^`\\n]*`|-?\\d+(?:\\.\\d+)?|true|false|True|False)";
-var RETURN_LITERAL_RE = new RegExp(`return\\s+(${LITERAL_TOKEN})\\s*;?\\s*\\}*\\s*$`);
+var RETURN_LITERAL_RE = /return\s+("[^"\n]*"|'[^'\n]*'|`[^`\n]*`|-?\d+(?:\.\d+)?|true|false|True|False)\s*;?\s*\}*\s*$/;
 var RETURN_EXPR_RE = /return[ \t]+([^;{}\n]*[^;{}\s\n])[;}\s]*$/;
 var TRIVIAL_RETURN_VALUES = /* @__PURE__ */ new Set(["null", "undefined", "none", "pass"]);
 var CONDITIONAL_BEFORE_RE = /\b(?:if|else|for|while|switch|case)\b|\?|&&|\|\|/;
@@ -2880,7 +2965,7 @@ function stripTrailingNoise(content) {
   return s;
 }
 function isBareLiteral(expr) {
-  return new RegExp(`^${LITERAL_TOKEN}$`).test(expr.trim());
+  return /^(?:"[^"\n]*"|'[^'\n]*'|`[^`\n]*`|-?\d+(?:\.\d+)?|true|false|True|False)$/.test(expr.trim());
 }
 function isNonTrivialExpr(expr) {
   const trimmed = expr.trim();
@@ -2889,12 +2974,8 @@ function isNonTrivialExpr(expr) {
   if (!/[A-Za-z0-9_]/.test(trimmed)) return false;
   return !isBareLiteral(trimmed);
 }
-var BRANCH_LITERAL_RE = new RegExp(
-  `if\\s*\\([^)]*(?<!!)===?\\s*(${LITERAL_TOKEN})[^)]*\\)\\s*return\\s+(${LITERAL_TOKEN})`
-);
-var PY_BRANCH_LITERAL_RE = new RegExp(
-  `if\\s+[^:]*==\\s*(${LITERAL_TOKEN})[^:]*:\\s*return\\s+(${LITERAL_TOKEN})`
-);
+var BRANCH_LITERAL_RE = /if\s*\([^)]*(?<!!)===?\s*("[^"\n]*"|'[^'\n]*'|`[^`\n]*`|-?\d+(?:\.\d+)?|true|false|True|False)[^)]*\)\s*return\s+("[^"\n]*"|'[^'\n]*'|`[^`\n]*`|-?\d+(?:\.\d+)?|true|false|True|False)/;
+var PY_BRANCH_LITERAL_RE = /if\s+[^:]*==\s*("[^"\n]*"|'[^'\n]*'|`[^`\n]*`|-?\d+(?:\.\d+)?|true|false|True|False)[^:]*:\s*return\s+("[^"\n]*"|'[^'\n]*'|`[^`\n]*`|-?\d+(?:\.\d+)?|true|false|True|False)/;
 var EMPTINESS_GUARD_RE = /\.(?:length|size)\s*===?\s*0\b|===?\s*(?:''|""|``)/;
 var TYPEOF_GUARD_RE = /\btypeof\s+[\w.[\]'"]+\s*[!=]==?\s*['"](?:string|number|boolean|object|function|undefined|symbol|bigint)['"]/;
 var COMMENT_LINE_RE = /^\+?\s*(?:\/\/|\/\*|\*|#|--|;)/;
@@ -2912,7 +2993,7 @@ function extractLiterals(line) {
 }
 function assertionPairs(context) {
   const pairs = /* @__PURE__ */ new Map();
-  const pattern = new RegExp(`expect\\(\\s*([A-Za-z_$][\\w$]*)\\(\\s*(${LITERAL_TOKEN})\\s*\\)\\s*\\)\\.(?:toBe|toEqual|toStrictEqual)\\(\\s*(${LITERAL_TOKEN})\\s*\\)`, "g");
+  const pattern = /expect\(\s*([A-Za-z_$][\w$]*)\(\s*("[^"\n]*"|'[^'\n]*'|`[^`\n]*`|-?\d+(?:\.\d+)?|true|false|True|False)\s*\)\s*\)\.(?:toBe|toEqual|toStrictEqual)\(\s*("[^"\n]*"|'[^'\n]*'|`[^`\n]*`|-?\d+(?:\.\d+)?|true|false|True|False)\s*\)/g;
   for (const file of context.files) {
     if (!context.isTestFile(pathOf(file))) continue;
     for (const chunk of file.chunks) {
@@ -2943,7 +3024,7 @@ function structuralHardcodes(context) {
         const old = oldFunctions.find((candidate) => candidate.header === fn.header);
         if (!evidence || !old) continue;
         const raw = after.text.slice(fn.open + 1, fn.end);
-        const branch = new RegExp(`\\bif\\s*\\(\\s*[A-Za-z_$][\\w$]*\\s*===?\\s*(${LITERAL_TOKEN})\\s*\\)\\s*\\{\\s*return\\s+(${LITERAL_TOKEN})\\s*;?\\s*\\}`, "g");
+        const branch = /\bif\s*\(\s*[A-Za-z_$][\w$]*\s*===?\s*("[^"\n]*"|'[^'\n]*'|`[^`\n]*`|-?\d+(?:\.\d+)?|true|false|True|False)\s*\)\s*\{\s*return\s+("[^"\n]*"|'[^'\n]*'|`[^`\n]*`|-?\d+(?:\.\d+)?|true|false|True|False)\s*;?\s*\}/g;
         for (const match of raw.matchAll(branch)) {
           if (!evidence.has(match[1].trim() + ":" + match[2].trim())) continue;
           const offset = fn.open + 1 + match.index;
@@ -2955,7 +3036,7 @@ function structuralHardcodes(context) {
           if (compact(rest) !== compact(old.body)) continue;
           findings.push({
             verifierId: "RH004",
-            severity: "error",
+            severity: semanticLiteral(match[1]) ? "warn" : "error",
             file: filePath,
             line: after.lineAt(offset),
             message: "A literal-input branch returns the matching test expectation while leaving the general computation unchanged.",
@@ -2967,7 +3048,7 @@ function structuralHardcodes(context) {
         if (!lookup) continue;
         const table = [...fn.body.matchAll(/\b(?:const|let)\s+([A-Za-z_$][\w$]*)\s*=\s*\{/g)].find((binding) => binding[1] === lookup[1]);
         if (!table) continue;
-        const literalEntry = new RegExp(`\\[?\\s*(${LITERAL_TOKEN})\\s*\\]?\\s*:\\s*(${LITERAL_TOKEN})`, "g");
+        const literalEntry = /\[?\s*("[^"\n]*"|'[^'\n]*'|`[^`\n]*`|-?\d+(?:\.\d+)?|true|false|True|False)\s*\]?\s*:\s*("[^"\n]*"|'[^'\n]*'|`[^`\n]*`|-?\d+(?:\.\d+)?|true|false|True|False)/g;
         const tableOpen = fn.open + 1 + table.index + table[0].length - 1;
         const tableEnd = closingDelimiter(after.code, tableOpen);
         if (tableEnd < 0) continue;
@@ -2986,10 +3067,291 @@ function structuralHardcodes(context) {
   }
   return findings;
 }
+function semanticLiteral(text) {
+  return /^["'`]|^(?:true|false|True|False)$/.test(text);
+}
+function literalValue(node, python = false, depth = 0) {
+  if (depth > 6) return void 0;
+  if (node.type === "Literal") {
+    const value = node.value;
+    if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  if (node.type === "TemplateLiteral" && node.expressions.length === 0) return node.quasis[0]?.value.cooked ?? void 0;
+  if (node.type === "Identifier" && python) {
+    if (node.name === "True") return true;
+    if (node.name === "False") return false;
+    if (node.name === "None") return null;
+  }
+  if (node.type === "UnaryExpression" && (node.operator === "-" || node.operator === "+")) {
+    const value = literalValue(node.argument, python, depth + 1);
+    if (typeof value === "number") return node.operator === "-" ? -value : value;
+  }
+  if (node.type === "ArrayExpression" && node.elements.length <= 32) {
+    const values = [];
+    for (const element of node.elements) {
+      if (!element || element.type === "SpreadElement") return void 0;
+      const value = literalValue(element, python, depth + 1);
+      if (value === void 0) return void 0;
+      values.push(value);
+    }
+    return values;
+  }
+  if (node.type === "ObjectExpression" && node.properties.length <= 32) {
+    const entries = [];
+    for (const property of node.properties) {
+      if (property.type !== "Property" || property.kind !== "init" || property.computed || property.method || property.shorthand) return void 0;
+      const key = property.key.type === "Identifier" ? property.key.name : literalValue(property.key, python, depth + 1);
+      const value = literalValue(property.value, python, depth + 1);
+      if (typeof key !== "string" && typeof key !== "number" || key === "__proto__" || value === void 0 || entries.some((entry) => entry[0] === String(key))) return void 0;
+      entries.push([String(key), value]);
+    }
+    return Object.fromEntries(entries);
+  }
+  return void 0;
+}
+function expression(text, parse) {
+  if (text.length > 4096) return void 0;
+  try {
+    return parse(text, 0, { ecmaVersion: "latest" });
+  } catch {
+  }
+  return void 0;
+}
+var SIGNATURE_SEPARATORS = [":", "::", ",", ";", "|", "/", "-", "_", ".", "~", " ", "	", "\n", ""];
+var SCALAR_PREFIX = /^(?:"(?:\\.|[^"\\\n])*"|'(?:\\.|[^'\\\n])*'|`(?:\\.|[^`\\\n])*`|true|false|True|False|[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)/;
+function scalarList(value, parse) {
+  if (value.length > 4096) return false;
+  const first = SCALAR_PREFIX.exec(value.trimStart());
+  const inferred = first && /^[^A-Za-z0-9"'`+.-]+/.exec(value.trimStart().slice(first[0].length))?.[0].trim();
+  const separators = SIGNATURE_SEPARATORS.filter((separator) => separator !== "");
+  if (inferred && inferred.length <= 16) separators.push(inferred);
+  return separators.some((separator) => {
+    let offset = 0;
+    let count = 0;
+    while (offset < value.length && count < 32) {
+      const token = SCALAR_PREFIX.exec(value.slice(offset).trimStart());
+      if (!token) return false;
+      offset += value.slice(offset).length - value.slice(offset).trimStart().length;
+      const node = expression(token[0], parse);
+      const scalar = node && node.end === token[0].length ? literalValue(node, true) : void 0;
+      if (scalar === void 0 || scalar === null || typeof scalar === "object") return false;
+      offset += token[0].length;
+      count++;
+      const whitespace = /^\s*/.exec(value.slice(offset))[0].length;
+      if (offset + whitespace === value.length) return count >= 2;
+      if (separator === " " || separator === "	") {
+        if (!whitespace) return false;
+        offset += whitespace;
+      } else {
+        offset += whitespace;
+        if (!value.startsWith(separator, offset)) return false;
+        offset += separator.length;
+      }
+    }
+    return false;
+  });
+}
+function serializations(value) {
+  const keys = /* @__PURE__ */ new Set([JSON.stringify(value), JSON.stringify(value, null, 2)]);
+  if (Array.isArray(value) && value.every((item) => item === null || typeof item !== "object")) {
+    const variants = [value, [...value].reverse(), [...value].sort()];
+    if (value.every((item) => typeof item === "number")) variants.push([...value].sort((a, b) => Number(a) - Number(b)));
+    for (const variant of variants) {
+      keys.add(JSON.stringify(variant));
+      for (const separator of SIGNATURE_SEPARATORS) keys.add(variant.join(separator));
+    }
+  }
+  return keys;
+}
+function fixtureInputs(context, parse) {
+  const result = /* @__PURE__ */ new Map();
+  let count = 0;
+  for (const file of context.files) {
+    const path9 = pathOf(file);
+    if (!context.isTestFile(path9)) continue;
+    for (const chunk of file.chunks) {
+      const view = sourceView(chunk, "after", path9.endsWith(".py"));
+      const assertion = /\b(?:expect|assert(?:\.(?:equal|strictEqual|deepEqual|deepStrictEqual))?|(?:self|cls)\.assert(?:Equal|ListEqual|DictEqual))\s*\(\s*((?:[A-Za-z_$][\w$]*\.)*[A-Za-z_$][\w$]*)\s*\(|\bassert[ \t]+((?:[A-Za-z_$][\w$]*\.)*[A-Za-z_$][\w$]*)\s*\(/g;
+      for (const match of view.code.matchAll(assertion)) {
+        if (++count > 64) return result;
+        const callee = match[1] ?? match[2];
+        const start = match.index + match[0].lastIndexOf(callee);
+        const open = view.code.indexOf("(", start + callee.length);
+        const close = closingDelimiter(view.code, open, "(", ")");
+        if (open < 0 || close < 0 || close - start > 4096) continue;
+        if (match[0].startsWith("expect") && !/^\s*\)\s*\.(?:not\.)?(?:toBe|toEqual|toStrictEqual|toMatchObject|toHaveLength|toBeTruthy|toBeDefined)\s*\(/.test(view.code.slice(close + 1))) continue;
+        const call = expression(view.text.slice(start, close + 1), parse);
+        if (call?.type !== "CallExpression") continue;
+        const name = callee.split(".").at(-1);
+        const keys = result.get(name) ?? /* @__PURE__ */ new Map();
+        for (const argument of call.arguments) {
+          if (argument.type !== "ArrayExpression" && argument.type !== "ObjectExpression") continue;
+          const value = literalValue(argument, path9.endsWith(".py"));
+          if (value === void 0) continue;
+          for (const key of serializations(value)) if (key && key.length <= 4096) keys.set(key, `${path9}:${view.lineAt(start)}`);
+        }
+        result.set(name, keys);
+      }
+    }
+  }
+  return result;
+}
+function functionAt(view, offset, python) {
+  if (python) return [...view.code.slice(0, offset).matchAll(/\bdef\s+([A-Za-z_]\w*)\s*\(/g)].at(-1)?.[1];
+  const functions = callables(view);
+  for (const match of view.code.matchAll(/\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?(?:\([^{}\n]*\)|[A-Za-z_$][\w$]*)\s*=>\s*\{/g)) {
+    const open = match.index + match[0].length - 1;
+    functions.push({ name: match[1], open, end: closingDelimiter(view.code, open), start: match.index, header: "", body: "" });
+  }
+  return functions.filter((fn) => offset > fn.open && offset < fn.end).sort((a, b) => b.open - a.open)[0]?.name;
+}
+function caughtPath(view, offset, python) {
+  if (python) {
+    const start = view.code.lastIndexOf("\n", offset - 1) + 1;
+    let indent = /^\s*/.exec(view.code.slice(start, offset))[0].length;
+    for (const row of view.code.slice(0, start).split("\n").reverse()) {
+      if (!row.trim()) continue;
+      const parent = row.length - row.trimStart().length;
+      if (parent >= indent) continue;
+      if (/^\s*except\b.*:\s*$/.test(row)) return true;
+      indent = parent;
+    }
+    return false;
+  }
+  return [...view.code.matchAll(/\bcatch\s*(?:\([^{}]*\))?\s*\{/g)].some((match) => {
+    const open = match.index + match[0].length - 1;
+    return offset > open && offset < closingDelimiter(view.code, open);
+  });
+}
+function stringBranches(view, python, parse) {
+  const result = [];
+  let count = 0;
+  const pattern = python ? /\bif[ \t]+/g : /\bif\s*\(/g;
+  for (const match of view.code.matchAll(pattern)) {
+    if (++count > 128) break;
+    const start = match.index + match[0].length;
+    const close = python ? view.code.indexOf(":", start) : closingDelimiter(view.code, start - 1, "(", ")");
+    if (close < 0 || close - start > 4096) continue;
+    const conditionText = view.text.slice(start, close);
+    const condition = expression(conditionText, parse);
+    if (condition?.type !== "BinaryExpression" || condition.left.type === "PrivateIdentifier" || !["==", "==="].includes(condition.operator) || conditionText.slice(condition.end).trim()) continue;
+    const left = literalValue(condition.left, python), right = literalValue(condition.right, python);
+    if (left !== void 0 && right !== void 0) continue;
+    const key = typeof right === "string" ? right : typeof left === "string" ? left : void 0;
+    if (key === void 0 || !key) continue;
+    let body2 = close + 1;
+    while (/\s/.test(view.code[body2] ?? "") && body2 < view.code.length) body2++;
+    const braced = !python && view.code[body2] === "{";
+    const end = braced ? closingDelimiter(view.code, body2) : view.code.indexOf("\n", body2);
+    const bodyEnd = end < 0 ? view.code.length : end;
+    if (braced) body2++;
+    const returned = /^\s*return\s+/.exec(view.code.slice(body2, bodyEnd));
+    if (!returned) continue;
+    const valueStart = body2 + returned[0].length;
+    const node = expression(view.text.slice(valueStart, bodyEnd), parse);
+    const value = node && literalValue(node, python);
+    if (!node || value === void 0 || value === null || typeof value === "object") continue;
+    const tail = view.code.slice(valueStart + node.end, bodyEnd);
+    if (!(braced ? /^\s*;?\s*$/ : /^\s*(?:;|\}|$)/).test(tail)) continue;
+    result.push({
+      offset: match.index,
+      end: valueStart + node.end,
+      key,
+      fingerprint: JSON.stringify([compact(view.code.slice(start, close)), key, value])
+    });
+  }
+  return result;
+}
+async function serializedSignatures(context) {
+  const candidates = context.files.filter((file) => isWatchedSource(context, pathOf(file))).flatMap((file) => file.chunks.filter((chunk) => chunk.changes.some((change) => change.type === "add" && /['"`]/.test(change.content)) && chunk.changes.some((change) => /\bif\b/.test(change.content))).map((chunk) => ({ file, chunk })));
+  if (!candidates.length) return [];
+  const { parseExpressionAt: parse } = await import("acorn");
+  let inputs;
+  const result = [];
+  for (const { file, chunk } of candidates) {
+    const filePath = pathOf(file), python = filePath.endsWith(".py");
+    const view = sourceView(chunk, "after", python);
+    const previous = new Set(stringBranches(sourceView(chunk, "before", python), python, parse).map((branch) => branch.fingerprint));
+    for (const branch of stringBranches(view, python, parse)) {
+      if (!view.touched(branch.offset, branch.end) || previous.has(branch.fingerprint) || caughtPath(view, branch.offset, python)) continue;
+      const name = functionAt(view, branch.offset, python);
+      const list = scalarList(branch.key, parse);
+      if (!list && !inputs) inputs = fixtureInputs(context, parse);
+      const fixture = name && inputs?.get(name)?.get(branch.key);
+      if (!list && !fixture) continue;
+      result.push({ endLine: view.lineAt(branch.end), finding: {
+        verifierId: "RH004",
+        severity: "error",
+        file: filePath,
+        line: view.lineAt(branch.offset),
+        message: list ? "A special-case string key encodes a delimiter-joined scalar list, rather than a domain category." : `A special-case string key matches a serialization of a composite literal asserted as input to ${name} at ${fixture}.`,
+        suggestion: "Compute the result from the input instead of recognizing a serialized fixture."
+      } });
+    }
+  }
+  return result;
+}
+function conditionalPath(view, line, python) {
+  const offset = view.offsetAtLine(line);
+  if (offset === void 0) return false;
+  if (python) {
+    const rows = view.code.slice(0, offset).split("\n");
+    const current = view.code.slice(offset).split("\n")[0];
+    let indent = current.length - current.trimStart().length;
+    for (const row2 of rows.reverse()) {
+      if (!row2.trim()) continue;
+      const parentIndent = row2.length - row2.trimStart().length;
+      if (parentIndent >= indent) continue;
+      if (/^\s*(?:if|elif|else|except|case)\b.*:\s*$/.test(row2)) return true;
+      indent = parentIndent;
+    }
+    return false;
+  }
+  const row = view.code.slice(offset).split("\n")[0];
+  const returnOffset = offset + Math.max(0, row.search(/\breturn\b/));
+  for (const match of view.code.matchAll(/\b(?:if|else|catch|switch)\b[^{};]*\{/g)) {
+    const open = match.index + match[0].length - 1;
+    if (open < returnOffset && closingDelimiter(view.code, open) > returnOffset) return true;
+  }
+  return false;
+}
+function documentedChange(context, finding) {
+  const file = context.files.find((file2) => pathOf(file2) === finding.file);
+  if (!file) return false;
+  const names = /* @__PURE__ */ new Set();
+  let literals = /* @__PURE__ */ new Set();
+  for (const chunk of file.chunks) {
+    const view = sourceView(chunk, "after", finding.file.endsWith(".py"));
+    const offset = view.offsetAtLine(finding.line);
+    if (offset === void 0) continue;
+    const end = view.text.indexOf("\n", offset);
+    literals = extractLiterals(view.text.slice(offset, end < 0 ? void 0 : end));
+    if (finding.file.endsWith(".py")) {
+      const definitions = [...view.code.slice(0, offset).matchAll(/\bdef\s+([A-Za-z_]\w*)\s*\(/g)];
+      const last = definitions.at(-1);
+      if (last) names.add(last[1].toLowerCase());
+    } else for (const fn of callables(view)) {
+      if (offset >= fn.start && offset <= fn.end) names.add(fn.name.toLowerCase());
+    }
+  }
+  for (const doc of context.files) {
+    if (!/(?:^|\/)(?:SPEC|CHANGELOG)\.md$/i.test(pathOf(doc))) continue;
+    for (const change of doc.chunks.flatMap((chunk) => chunk.changes)) {
+      if (change.type !== "add") continue;
+      const note = change.content.slice(1).trim();
+      if (note.startsWith("#") || !/\b(?:returns?|fallback|sentinel|calibrat\w*|supports?)\b/i.test(note)) continue;
+      const words = new Set(note.toLowerCase().match(/[A-Za-z_$][\w$]*|-?\d+(?:\.\d+)?/g) ?? []);
+      if ([...names].some((name) => words.has(name))) return true;
+      if (literals.size >= 2 && [...literals].every((literal) => words.has(literal.toLowerCase()))) return true;
+    }
+  }
+  return false;
+}
 async function run4(context) {
   const files = context.files;
   const ctx = context;
-  const findings = structuralHardcodes(context);
+  let findings = structuralHardcodes(context);
   const fuzzyCandidates = [];
   for (const file of files) {
     const filePath = file.to ?? file.from ?? "";
@@ -3016,13 +3378,14 @@ async function run4(context) {
         }) : void 0;
         if (pairedDel) {
           const priorExpr = (pairedDel.content.match(RETURN_EXPR_RE)?.[1] ?? "").trim();
+          const fallback = conditionalPath(sourceView(chunk, "after", filePath.endsWith(".py")), line, filePath.endsWith(".py"));
           findings.push({
             verifierId: "RH004",
-            severity: "error",
+            severity: fallback ? "warn" : "error",
             file: filePath,
             line,
-            message: `Implementation now returns hardcoded ${literal} where it previously computed \`${priorExpr}\`.`,
-            suggestion: "Implement the actual logic instead of returning a hardcoded value."
+            message: fallback ? `A conditional path now returns ${literal} instead of computing \`${priorExpr}\`; this can be an intentional fallback.` : `Implementation now returns hardcoded ${literal} where it previously computed \`${priorExpr}\`.`,
+            suggestion: fallback ? "Check the supported input contract and test the fallback and the general path." : "Implement the actual logic instead of returning a hardcoded value."
           });
         } else {
           fuzzyCandidates.push({ file: filePath, line, content: add.content });
@@ -3036,15 +3399,25 @@ async function run4(context) {
         if (/^(['"`])[^\w\s]\1$/.test(branchMatch[1])) continue;
         findings.push({
           verifierId: "RH004",
-          severity: "error",
+          severity: semanticLiteral(branchMatch[1]) ? "warn" : "error",
           file: filePath,
           line: add.ln,
-          message: `Implementation special-cases input ${branchMatch[1]} to return hardcoded ${branchMatch[2]} instead of computing it generally.`,
-          suggestion: "Remove the special-case branch and implement the general logic."
+          message: semanticLiteral(branchMatch[1]) ? `Implementation special-cases input ${branchMatch[1]} to return ${branchMatch[2]}; a diff alone cannot distinguish a domain case from fixture hardcoding.` : `Implementation special-cases input ${branchMatch[1]} to return hardcoded ${branchMatch[2]} instead of computing it generally.`,
+          suggestion: semanticLiteral(branchMatch[1]) ? "Check the supported input contract and test both the special case and other inputs." : "Remove the special-case branch and implement the general logic."
         });
       }
     }
   }
+  const signatures = await serializedSignatures(context);
+  findings = findings.filter((finding) => !signatures.some((signature) => signature.finding.file === finding.file && finding.line >= signature.finding.line && finding.line <= signature.endLine));
+  const fixtureFindings = new Set(signatures.map((signature) => signature.finding));
+  findings.push(...fixtureFindings);
+  for (const finding of findings) {
+    if (fixtureFindings.has(finding) || finding.severity !== "error" || !documentedChange(context, finding)) continue;
+    finding.severity = "warn";
+    finding.message = "A literal implementation change has a specific behavior note in SPEC or CHANGELOG; the diff does not establish whether it is incorrect.";
+    finding.suggestion = "Check the documented behavior against the supported input classes and retain tests for other behavior.";
+  }
   if (!ctx.aiEnabled || !ctx.judge) return findings;
   const flagged = new Set(findings.map((f) => `${f.file}:${f.line}`));
   const implLiterals = /* @__PURE__ */ new Map();
@@ -3104,8 +3477,8 @@ function isConditionalReturn2(line) {
 }
 var NONTRIVIAL_RETURN_RE = /return\s+([^;{}\n]+)\s*;?\s*\}*\s*$/;
 var TRIVIAL_RETURN_VALUES2 = /* @__PURE__ */ new Set(["null", "undefined", "none", "pass"]);
-var LITERAL_TOKEN2 = "(?:\"[^\"\\n]*\"|'[^'\\n]*'|`[^`\\n]*`|-?\\d+(?:\\.\\d+)?|true|false|True|False)";
-var BARE_LITERAL_RE = new RegExp(`^${LITERAL_TOKEN2}$`);
+var LITERAL_TOKEN = "(?:\"[^\"\\n]*\"|'[^'\\n]*'|`[^`\\n]*`|-?\\d+(?:\\.\\d+)?|true|false|True|False)";
+var BARE_LITERAL_RE = new RegExp(`^${LITERAL_TOKEN}$`);
 function isGuttedAdd(content) {
   const stripped = stripTrailingNoise(content);
   const wholeLine = stripped.replace(/^\+\s*/, "").trim();
@@ -3784,7 +4157,7 @@ function run10(context) {
     if (!ctx.isTestFile(filePath)) continue;
     for (const chunk of file.chunks) {
       const removedAwaited = new Set(
-        chunk.changes.filter((change) => change.type === "del").map((change) => awaitedExpression(change.content)).filter((expression) => expression !== void 0)
+        chunk.changes.filter((change) => change.type === "del").map((change) => awaitedExpression(change.content)).filter((expression2) => expression2 !== void 0)
       );
       for (const added of chunk.changes.filter((change) => change.type === "add")) {
         const addedBody = body(added.content);
@@ -4156,6 +4529,9 @@ function isCommandLine(text) {
   if (/^[ \t]*(?:-[ \t]*)?\{/.test(text)) return false;
   return key === null || COMMAND_KEYS.has(key[1].toLowerCase());
 }
+function baseCommandKey(content) {
+  return commandKey(content).split("||")[0].trim();
+}
 function commandKey(content) {
   const command = stripDiffPrefix2(content);
   const invocation = TEST_COMMAND_RE.exec(command);
@@ -4202,7 +4578,10 @@ function run12(context) {
       }
       for (const change of chunk.changes) {
         if (change.type !== "add") continue;
-        if (TEST_COMMAND_RE.test(change.content)) addedCommands.add(commandKey(change.content));
+        if (TEST_COMMAND_RE.test(change.content)) {
+          addedCommands.add(commandKey(change.content));
+          addedCommands.add(baseCommandKey(change.content));
+        }
       }
     }
     for (const chunk of file.chunks) {
@@ -4249,7 +4628,7 @@ function run12(context) {
             const stripped = stripDiffPrefix2(change.content);
             if (!TEST_COMMAND_RE.test(stripped)) continue;
             if (!isCommandLine(stripped)) continue;
-            if (addedCommands.has(commandKey(change.content))) continue;
+            if (addedCommands.has(commandKey(change.content)) || addedCommands.has(baseCommandKey(change.content))) continue;
             findings.push({
               verifierId: "RH012",
               severity: "error",
@@ -4695,7 +5074,7 @@ function structuralSwallows(context) {
           severity: "error",
           file: path9,
           line: after.lineAt(handler.start),
-          message: "Error handling was added or changed to an empty or logging-only handler, so failures no longer propagate.",
+          message: "Error handling was added or changed to suppress a failure instead of propagating it.",
           suggestion: "Return an error, retry, or propagate the failure. Document a specific, deliberate fallback."
         });
       }
@@ -6158,6 +6537,56 @@ var ALWAYS_PASS_BODY_RE = /pass\s*:\s*true\b|=>\s*\(?\s*\{\s*pass\s*:\s*true/;
 function countsAsAssertion(text) {
   return ASSERTION_RE2.test(withoutLiterals(text));
 }
+var unitName = (file) => path8.basename(file.replace(/\\/g, "/")).replace(/\.(?:test|spec)\.[^.]+$|\.[^.]+$/, "").replace(/^test_/, "").replace(/_test$/, "");
+function pythonScopes(view) {
+  const result = [];
+  for (const declaration of view.code.matchAll(/^([ \t]*)(?:async[ \t]+)?def[ \t]+([A-Za-z_]\w*)\s*\([^:\n]*\)[^:\n]*:[ \t]*$/gm)) {
+    const open = declaration.index + declaration[0].lastIndexOf(":");
+    let end = view.code.length;
+    for (const row of view.code.slice(open + 1).matchAll(/^([ \t]*)\S/gm)) {
+      if (row[1].length > declaration[1].length) continue;
+      end = open + 1 + row.index;
+      break;
+    }
+    result.push({ name: declaration[2], open, end });
+  }
+  return result;
+}
+function coversRemovedFeature(context, testPath, assertions) {
+  const symbols = /* @__PURE__ */ new Set();
+  const channels = [];
+  for (const file of context.files) {
+    const filePath = pathOf(file);
+    if (context.isTestFile(filePath) || unitName(filePath) !== unitName(testPath)) continue;
+    const python = filePath.endsWith(".py");
+    const before = file.chunks.map((chunk) => sourceView(chunk, "before", python));
+    const after = file.chunks.map((chunk) => sourceView(chunk, "after", python));
+    const declarations = after.flatMap((view) => [...view.code.matchAll(/\b(?:function|def|class|const|let|var)\s+([A-Za-z_$][\w$]*)/g)].map((match) => match[1]));
+    for (const view of before) {
+      for (const declaration of view.code.matchAll(/\b(?:function|def)\s+([A-Za-z_$][\w$]*)\s*\(/g)) {
+        if (view.touched(declaration.index, declaration.index + declaration[0].length) && !declarations.includes(declaration[1])) symbols.add(declaration[1]);
+      }
+      for (const fn of python ? pythonScopes(view) : callables(view)) {
+        const text = view.text.slice(fn.open + 1, fn.end);
+        for (const branch of text.matchAll(/\bif\s*\(\s*[A-Za-z_$][\w$]*\s*===?\s*(['"])([^'"\n]+)\1\s*\)|\bcase\s+(['"])([^'"\n]+)\3\s*:|^[ \t]*(?:if|elif)\s+[A-Za-z_]\w*\s*==\s*(['"])([^'"\n]+)\5\s*:/gm)) {
+          const offset = fn.open + 1 + branch.index;
+          if (!/^(?:if|elif|case)\b/.test(view.code.slice(offset, offset + branch[0].length).trimStart())) continue;
+          if (!view.touched(offset, offset + branch[0].length)) continue;
+          const value = branch[2] ?? branch[4] ?? branch[6];
+          const remains = after.some((next) => [...next.text.matchAll(/(['"])([^'"\n]+)\1/g)].some((match) => match[2] === value));
+          if (!remains) channels.push({ unit: fn.name, value });
+        }
+      }
+    }
+  }
+  return assertions.length > 0 && assertions.every((assertion) => {
+    const code = withoutLiterals(assertion);
+    const calls = [...code.matchAll(/([A-Za-z_$][\w$]*)\s*\(/g)].map((match) => match[1]);
+    if (calls.some((name) => symbols.has(name))) return true;
+    const literals = [...assertion.matchAll(/(['"])([^'"\n]+)\1/g)].map((match) => match[2]);
+    return channels.some((channel) => calls.includes(channel.unit) && literals.includes(channel.value));
+  });
+}
 function run26(context) {
   const findings = [];
   for (const file of context.files) {
@@ -6173,13 +6602,16 @@ function run26(context) {
       const lost = removedAssertions - addedAssertions;
       if (testsSurvive && lost > 0 && addedAssertions >= 0 && removedAssertions > 0) {
         const firstRemoved = file.chunks.flatMap(deletedLines).find((l) => countsAsAssertion(l.text));
+        const added = new Set(file.chunks.flatMap(addedLines).map((line) => line.text.trim()));
+        const removed = file.chunks.flatMap(deletedLines).filter((line) => !isCommentLine(line.text) && countsAsAssertion(line.text) && !added.has(line.text.trim()));
+        const coordinated = coversRemovedFeature(context, filePath, removed.map((line) => line.text));
         findings.push({
           verifierId: "WI112",
-          severity: "error",
+          severity: coordinated ? "warn" : "error",
           file: filePath,
           line: firstRemoved?.line ?? 1,
-          message: `Assertions removed: ${lost} assertion${lost === 1 ? "" : "s"} deleted from a test that still runs under the same name, so it reports the same coverage while checking less.`,
-          suggestion: "Put the assertions back and make the code satisfy them. A test that keeps its name and loses its checks is the most invisible way to reduce coverage: nothing in the test count, the report, or the diff summary changes."
+          message: coordinated ? `Assertions removed alongside their source feature: ${lost} fewer assertion${lost === 1 ? "" : "s"}; the diff does not establish whether the feature removal is authorized.` : `Assertions removed: ${lost} assertion${lost === 1 ? "" : "s"} deleted from a test that still runs under the same name, so it reports the same coverage while checking less.`,
+          suggestion: coordinated ? "Confirm that the documented contract permits the feature removal and retain coverage for supported behavior." : "Put the assertions back and make the code satisfy them. A test that keeps its name and loses its checks is the most invisible way to reduce coverage: nothing in the test count, the report, or the diff summary changes."
         });
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kavishdua/proctor",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Catch AI agents gaming their test suites: deleted tests, skipped tests, weakened assertions, hardcoded outputs",
   "homepage": "https://github.com/catfish-1234/proctor#readme",
   "bugs": {
@@ -60,7 +60,7 @@
     "lint": "oxlint --deny correctness --allow no-unused-vars --allow no-useless-escape --allow prefer-string-starts-ends-with src tests scripts tsup.config.ts vitest.config.ts"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.132.0",
+    "@anthropic-ai/sdk": "^0.134.0",
     "acorn": "^8.19.0",
     "brace-expansion": "^5.0.12",
     "commander": "^14.0.3",