jules-orchestrator-kit 0.58.0 → 0.60.0

package/README.md

@@ -204,7 +204,7 @@ To maximize PR merge rates, dispatch tasks according to deterministic boundaries
 * **Fail-Closed Security & Secret Redaction:** Evaluates explicit Deny rules before Allow rules against canonicalized, case-folded paths. Redacts high-entropy keys and base64-encoded credentials (such as Kubernetes `Secret` manifests).
 * **Complexity & Cost Router:** Zero-dependency heuristic classifier (`src/router.mjs`) routing mechanical tasks to lightweight models while reserving primary models for complex refactors, with a `node --check` syntax-verification gate that transparently escalates a FAST-tier result to the primary provider if it left broken JS on disk.
 * **Terminal UI & Diagnostic Matrix (`agentctl doctor`):** Interactive terminal dashboard, task sidecar manager, and automated transactional self-repair.
-* **Verified Test Suite:** Tested with **895 unit tests across 128 suites passing in < 15.0s**.
+* **Verified Test Suite:** Tested with **957 unit tests across 134 suites passing in < 15.0s**.
 
 <br/>
 
@@ -237,7 +237,7 @@ To maximize PR merge rates, dispatch tasks according to deterministic boundaries
 | `doctor` | `agentctl doctor [--probe] [--json]` | Diagnostic check runner. `--probe` additionally starts the configured provider's CLI to confirm it answers, rather than only finding it on `PATH`. | `0` (Healthy), `1` (Failures) |
 | `queue` | `agentctl queue [--dag] [--concurrency <n>] [--dry-run] [--json]` | Consumes and executes task envelopes in `.agent/jules-queue/` with Kahn's DAG dependency resolution. Non-task files (manifests, `README.md`) are skipped, and `--dry-run` previews without moving anything. | `0` (Complete) |
 | `swarm` | `agentctl swarm [--json]` | Runs parallel multi-agent swarm across worker slots with PID liveness detection. | `0` (Complete) |
-| `check` / `gate` / `audit`| `agentctl check [--mode working-tree] [--fix] [--allow-protected] [--allow-test-modifications] [--json] [--json-report <path>]` | Runs security, secret scanning, rules budget audit, and tiered verification gates (with declarative assertion support) against working tree or branch. | `0` (Approved), `1` (Budget/Arg), `3` (Scope), `4` (Verify), `5` (Diff >75K), `6` (Secret), `8` (Flaky) |
+| `check` / `gate` / `audit`| `agentctl check [--mode working-tree] [--fix] [--allow-protected] [--allow-test-change <kind>] [--json] [--json-report <path>]` | Runs security, secret scanning, rules budget audit, and tiered verification gates (with declarative assertion support) against working tree or branch. | `0` (Approved), `1` (Budget/Arg), `3` (Scope), `4` (Verify), `5` (Diff >75K), `6` (Secret), `8` (Flaky) |
 | `mutate` / `mutation` | `agentctl mutate [--min-score <n>] [--max-mutants <n>] [--cmd <testCmd>] [--json]` | Runs zero-dependency diff mutation testing harness on changed hunks with operator inversion and safety rollback. | `0` (Passed), `1` (Score Low) |
 | `coverage` | `agentctl coverage [--min <pct>] [--cmd <testCmd>] [--base <ref>] [--json]` | Runs native zero-dependency V8 diff coverage check against added diff lines. | `0` (Passed), `1` (Low Coverage) |
 | `probe` / `stability` | `agentctl probe [--repeat <n>] [--min <passRate>] [--cmd <testCmd>] [--json]` | Probes test suite flakiness across N consecutive iterations with oscillation detection. | `0` (Passed), `1` (Flaky) |

package/bin/agentctl.mjs

@@ -388,7 +388,12 @@ async function main() {
           // of spec, which necessarily rewrites what a test expects, hit a
           // CRITICAL finding at exit 6 with no documented way past it. A guard
           // with no override is not a guard, it is an outage.
+          //
+          // This one is the blunt form and turns off all six checks. Prefer
+          // `--allow-test-change <kind>`: answering one finding should not
+          // silence five other checks nobody looked at.
           "allow-test-modifications": { type: "boolean" },
+          "allow-test-change": { type: "string", multiple: true },
           json: { type: "boolean", short: "j" },
           "json-report": { type: "string" },
           "dry-run": { type: "boolean", short: "d" },
@@ -409,6 +414,7 @@ async function main() {
         fix: values.fix,
         allowProtected: values["allow-protected"],
         allowTestModifications: values["allow-test-modifications"],
+        allowTestChanges: values["allow-test-change"],
         jsonReport: values["json-report"],
       });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jules-orchestrator-kit",
-  "version": "0.58.0",
+  "version": "0.60.0",
   "description": "Zero-dependency safety gatekeeper, test oracle generator, and multi-agent coordination protocol for autonomous coding agents — Google Jules, Claude Code, Codex and Gemini CLI.",
   "repository": {
     "type": "git",

package/src/coverage.mjs

@@ -1,4 +1,5 @@
 import { readFileSync, readdirSync, mkdtempSync, rmSync, existsSync, realpathSync } from "node:fs";
+import { isTestPath } from "./test-paths.mjs";
 import { join, resolve, relative, isAbsolute } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
@@ -18,12 +19,7 @@ export function isExcludedFromCoverage(filePath = "") {
     norm.startsWith(".agent/") ||
     norm.startsWith(".github/") ||
     norm.startsWith(".git/") ||
-    norm.startsWith("test/") ||
-    norm.startsWith("tests/") ||
-    norm.includes("/__tests__/") ||
-    norm.includes(".test.") ||
-    norm.includes(".spec.") ||
-    norm.includes("_test.") ||
+    isTestPath(norm) ||
     norm.endsWith(".md") ||
     norm.endsWith(".json") ||
     norm.endsWith(".yml") ||

package/src/engine.mjs

@@ -1,4 +1,5 @@
 import { loadConfig, parseYaml, normalizeScope } from "./config.mjs";
+import { isTestPath } from "./test-paths.mjs";
 import { checkScope, scanDiff, scanBinaryPayloads, redactSecrets } from "./security.mjs";
 import { changedFiles, diffBytes, diffText, binaryDiffEntries, symlinkChanges, showFromOrigin, runCmd } from "./git.mjs";
 import { createProvider, ProviderRateLimitError, ProviderUnavailableError } from "./provider.mjs";
@@ -274,7 +275,11 @@ export async function gate(opts = {}) {
   }
 
   // Phase 3: Diff Secret Scanner & Security Checks
-  const secretResult = scanDiff(diffStr, { root, allowTestModifications: opts.allowTestModifications === true });
+  const secretResult = scanDiff(diffStr, {
+    root,
+    allowTestModifications: opts.allowTestModifications === true,
+    allowTestChanges: opts.allowTestChanges,
+  });
   // A binary file reaches the scanner as one summary line, so its contents were
   // never looked at — a NUL byte in front of a token was enough to hide it.
   // Inspect those files directly and fold the verdict in.
@@ -494,10 +499,7 @@ export async function gate(opts = {}) {
   const postTestHash = postTestHashResult.treeHash;
   let testTampered = false;
   if (config.evidence?.strictTestLock && !opts.allowTestModifications && preTestHashResult.fileCount > 0) {
-    const changedTestFile = files.find((f) => {
-      const lower = f.toLowerCase();
-      return lower.startsWith("test/") || lower.startsWith("tests/") || lower.includes(".test.") || lower.includes(".spec.");
-    });
+    const changedTestFile = files.find((f) => isTestPath(f));
     if (changedTestFile && preTestHash !== postTestHash) {
       testTampered = true;
     }

package/src/evidence.mjs

@@ -14,6 +14,7 @@ import {
 import { join, resolve, relative, isAbsolute, sep, extname } from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import { execSync } from "node:child_process";
+import { isTestPath } from "./test-paths.mjs";
 
 /**
  * Normalizes file path to POSIX slashes.
@@ -164,20 +165,7 @@ export function computeDirectoryHash(root, options = {}) {
 
   // Filter test files if specifically looking for test suites
   if (options.testOnly) {
-    fileList = fileList.filter((f) => {
-      const lower = f.toLowerCase();
-      return (
-        lower.startsWith("test/") ||
-        lower.startsWith("tests/") ||
-        lower.startsWith("__tests__/") ||
-        lower.startsWith("spec/") ||
-        lower.includes(".test.") ||
-        lower.includes(".spec.") ||
-        lower.includes("_test.") ||
-        lower.endsWith("test.sol") ||
-        lower.endsWith(".t.sol")
-      );
-    });
+    fileList = fileList.filter((f) => isTestPath(f));
   }
 
   const fileHashes = {};

package/src/mutation.mjs

@@ -1,4 +1,5 @@
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { isTestPath } from "./test-paths.mjs";
 import { resolve, isAbsolute } from "node:path";
 import { createHash } from "node:crypto";
 import { diffText, runCmd } from "./git.mjs";
@@ -195,14 +196,7 @@ export function isExcludedFromMutation(filePath = "") {
   const normalized = filePath.replace(/\\/g, "/").toLowerCase();
 
   // Exclude test files
-  if (
-    normalized.includes(".test.") ||
-    normalized.includes(".spec.") ||
-    normalized.includes("_test.") ||
-    normalized.includes("/test/") ||
-    normalized.includes("/tests/") ||
-    normalized.includes("/__tests__/")
-  ) {
+  if (isTestPath(normalized)) {
     return true;
   }
 

package/src/security.mjs

@@ -1,4 +1,5 @@
 import { openSync, readFileSync, writeSync, fsyncSync, closeSync, renameSync, realpathSync, existsSync, lstatSync, unlinkSync } from "node:fs";
+import { isTestPath } from "./test-paths.mjs";
 import { dirname, join, basename } from "node:path";
 import { randomBytes } from "node:crypto";
 import { canonicalizePath, isWindowsAbsolutePath } from "./config.mjs";
@@ -1101,6 +1102,886 @@ function locateFindingLine(lines, type, file = null) {
   return null;
 }
 
+// ---------------------------------------------------------------------------
+// Statement-level expectation-rewrite detection (multi-line aware)
+// ---------------------------------------------------------------------------
+//
+// The original pairing ran on physical lines. That caught
+// `assert.equal(add(1, 2), 3);` becoming `assert.equal(add(1, 2), -1);`, but
+// the same edit walked straight through the moment it was wrapped across
+// lines — which every formatter does the day a line runs long, and which an
+// agent doing an ordinary reformat does on its own:
+//
+//   -assert.equal(
+//   -  add(1, 2),
+//   -  3
+//   -);
+//   +assert.equal(
+//   +  add(1, 2),
+//   +  -1
+//   +);
+//
+// The value lives on a line that carries no assertion keyword, so neither
+// side ever paired, and the suite went from checking that addition works to
+// certifying that it is broken. The statement, not the line, is the unit an
+// agent rewrites, so the pairing now runs on reassembled statements: a run
+// of physical lines joined while its delimiters are unbalanced, one of its
+// strings or comments is still open, a Python line-continuation is pending,
+// or the next line cannot start a statement of its own. The hunk's context
+// lines belong to both images and are what make the reassembly possible;
+// when they are absent (a zero-context diff) the only pair that can survive
+// is the one where each image is a single fragment, and that pair is taken
+// too, requiring a literal placeholder so a code change cannot masquerade as
+// a value change.
+//
+// The pairing rule is unchanged in spirit: the two sides must be the *same*
+// assertion — identical once every literal is blanked out — with different
+// values. That does not distinguish an attack from a deliberate change of
+// spec; nothing can, from a diff alone. This reports rather than decides,
+// and `--allow-test-change expectation` is the answer when the new
+// expectation is the correct one. Narrow on purpose: the blunt
+// `--allow-test-modifications` turns off the other five checks too, and a
+// check that can only be answered by disabling its neighbours ends up
+// disabling its neighbours.
+
+// An assertion that states a *specific* expected value. Counting assertions
+// alone let a test be gutted while looking untouched: swapping
+// `assert.strictEqual(add(2,3), 5)` for `assert.ok(add(2,3) !== undefined)`
+// removes one and adds one, so `removed > added` stayed false and the guard
+// said nothing — while the suite stopped checking the answer.
+//
+// The `expect` argument span is a bounded lazy match rather than `[^)]*` so
+// that a call split across lines with a nested call in its arguments
+// (`expect(\n  formatInvoice(bill)\n).toBe(…`) still recognises the chain.
+// The bound is a guess: an argument list longer than 240 characters is
+// rarer than a missed chain.
+const SPECIFIC_ASSERTION = new RegExp(
+  [
+    "\\bassert(?:\\.strict)?\\.?(?:strictEqual|deepStrictEqual|deepEqual|notStrictEqual|notDeepStrictEqual|equal|notEqual|match|doesNotMatch|throws|rejects|doesNotThrow)\\s*\\(",
+    "\\bexpect\\s*\\([\\s\\S]{0,240}?\\)\\s*\\.(?:toBe|toEqual|toStrictEqual|toMatch|toMatchObject|toContain|toHaveBeenCalledWith|toThrow|toHaveLength|toBeCloseTo)\\s*\\(",
+    "\\bassert\\.(?:equals|deepEquals|include|lengthOf)\\s*\\(",
+    "assert_eq!|assert_ne!",
+    "\\bt\\.(?:Errorf|Fatalf)\\s*\\(",
+    "\\brequire\\.(?:Equal|NotEqual|Len|Contains|Error|NoError)\\s*\\(",
+  ].join("|"),
+  "i"
+);
+const isSpecificAssertion = (str) => SPECIFIC_ASSERTION.test(str);
+
+/**
+ * An assertion with every literal value replaced by a placeholder.
+ *
+ * Two lines that normalize to the same string are the same assertion about
+ * the same expression; whatever differs between them is a value.
+ *
+ * The number form covers hex, octal, binary, underscores and exponents: the
+ * original decimal-only regex never blanked `0xFF`, so an expectation
+ * rewritten from `0xFF` to `0xFE` normalized to two *different* shapes and
+ * the pair was never formed.
+ */
+const blankLiterals = (str) =>
+  str
+    .replace(/(['"`])(?:\\.|(?!\1)[^\\])*\1/g, "\u0000S")
+    // The sign belongs to the literal: without it `3` and `-1` normalized to
+    // different shapes and the rewritten expectation was never paired.
+    .replace(
+      /(?<![\w$])(?:0[xX][0-9a-fA-F_]+|0[bB][01_]+|0[oO][0-7_]+|-?\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?)/g,
+      "\u0000N"
+    )
+    .replace(/\b(?:true|false|null|undefined|None|True|False|nil)\b/g, "\u0000B")
+    // Whitespace is dropped, not collapsed: the shape is compared for
+    // equality only, and a reformatted statement must normalize to the same
+    // shape as the original — ` <N> );` and ` <N>);` are the same assertion.
+    .replace(/\s+/g, "");
+
+// The test languages the gate runs over. The scanner below is written for
+// these four and nothing else; an unrecognised extension falls back to `js`,
+// which is the strictest of the four for line joining.
+const TEST_LANG_BY_EXT = new Map([
+  [".js", "js"], [".mjs", "js"], [".cjs", "js"], [".jsx", "js"],
+  [".ts", "js"], [".mts", "js"], [".cts", "js"], [".tsx", "js"],
+  [".py", "python"], [".pyi", "python"],
+  [".go", "go"],
+  [".rs", "rust"],
+]);
+
+function langForTestFile(file) {
+  const n = String(file || "").toLowerCase();
+  const dot = n.lastIndexOf(".");
+  if (dot === -1) return "js";
+  return TEST_LANG_BY_EXT.get(n.slice(dot)) || "js";
+}
+
+function freshScanState() {
+  // str: the open string, or null.
+  //   q         the quote character
+  //   tri       Python triple-quoted
+  //   raw       raw string, no escapes (Go backtick)
+  //   rawHashes Rust raw string r#"…"#: terminator is " plus that many #
+  // block: depth of an open /* … */ (nested only in Rust)
+  // accDelta: counted delimiters still open in the current statement
+  // specialStack: counted depth recorded at each non-joining call (see below)
+  return { str: null, block: 0, accDelta: 0, specialStack: [] };
+}
+
+// A call whose opening paren must not join lines: the test name is not the
+// expectation. Without this, `it("old name", () => { expect(f()).toBe(3); })`
+// would pair against its renamed copy, because a name is a string and so
+// blanks to the same placeholder as any value change would. The closer of a
+// non-joining paren is recognised by the depth it was opened at, so the
+// running balance stays exact.
+const NON_JOINING_CALL = /\b(?:it|test|describe|context)\s*\($|\bt\.Run\s*\($/;
+
+/**
+ * Scan one physical line of source.
+ *
+ * Returns { delta, trailingBackslash }. `delta` is the net number of
+ * still-open ( [ { delimiters outside strings and comments; a statement
+ * continues to the next physical line while it is positive, while a string
+ * or block comment is open (tracked on `state`), or on a Python line
+ * continuation.
+ *
+ * This is not a parser, and the approximations are deliberate: JS regex
+ * literals are detected with a one-token look-behind (a `/` that cannot
+ * follow an identifier, number, `)` or `]` starts one), template
+ * interpolation is treated as opaque string content, and Rust lifetimes are
+ * told apart from char literals by shape alone. `stripComments` below
+ * walks the same constructs, so the two must stay in lock-step.
+ */
+function scanSourceLine(text, lang, state) {
+  let delta = 0;
+  let lastSig = "\n";
+  const n = text.length;
+  let i = 0;
+
+  while (i < n) {
+    const c = text[i];
+    const c2 = i + 1 < n ? text[i + 1] : "";
+
+    if (state.str) {
+      const s = state.str;
+      let closed = false;
+      if (s.rawHashes !== undefined) {
+        if (c === '"') {
+          let j = i + 1;
+          let h = 0;
+          while (j < n && text[j] === "#") { h++; j++; }
+          if (h >= s.rawHashes) { i = j; closed = true; }
+        }
+      } else if (s.raw) {
+        closed = c === s.q;
+      } else if (c === "\\") {
+        i += s.tri ? 1 : 2;
+        continue;
+      } else if (c === s.q) {
+        if (s.tri) {
+          if (text[i + 1] === s.q && text[i + 2] === s.q) { i += 3; closed = true; }
+          else { i += 1; }
+        } else {
+          i += 1;
+          closed = true;
+        }
+      }
+      if (closed) { state.str = null; lastSig = s.q; continue; }
+      i += 1;
+      continue;
+    }
+
+    if (state.block > 0) {
+      if (c === "/" && c2 === "*") {
+        if (lang === "rust") state.block += 1;
+        i += 2;
+        continue;
+      }
+      if (c === "*" && c2 === "/") {
+        state.block -= 1;
+        i += 2;
+        lastSig = "/";
+        continue;
+      }
+      i += 1;
+      continue;
+    }
+
+    // A line comment ends the line.
+    if (c === "/" && c2 === "/") break;
+    if (lang === "python" && c === "#") break;
+
+    if (c === "/" && c2 === "*") {
+      state.block = 1;
+      i += 2;
+      continue;
+    }
+
+    // JS regex literal, best effort. Delimiters inside are not counted.
+    if ((lang === "js" || lang === "ts") && c === "/" && !/[\w$)\]}]/.test(lastSig)) {
+      i += 1;
+      let inClass = false;
+      while (i < n) {
+        const rc = text[i];
+        if (rc === "\\") { i += 2; continue; }
+        if (rc === "[") inClass = true;
+        else if (rc === "]") inClass = false;
+        else if (rc === "/" && !inClass) { i += 1; break; }
+        i += 1;
+      }
+      while (i < n && /[a-z]/i.test(text[i])) i += 1; // flags
+      lastSig = "/";
+      continue;
+    }
+
+    if (c === '"' || c === "'" || (lang === "go" && c === "`")) {
+      if (lang === "python" && c2 === c && text[i + 2] === c) {
+        state.str = { q: c, tri: true };
+        i += 3;
+      } else if (lang === "rust" && c === '"') {
+        if (i > 0 && text[i - 1] === "r") {
+          let j = i - 1;
+          let h = 0;
+          while (j >= 1 && text[j - 1] === "#") { h++; j--; }
+          state.str = { q: '"', rawHashes: h };
+          i += 1;
+        } else {
+          state.str = { q: c };
+          i += 1;
+        }
+      } else if (lang === "rust" && c === "'") {
+        // A char literal is 'X' or '\X' within four characters; anything
+        // else starting with a quote is a lifetime and only the quote is
+        // skipped, or the next line would see a string that never closed.
+        if (c2 === "\\") {
+          const end = text.indexOf("'", i + 2);
+          if (end !== -1 && end - i <= 4) { i = end + 1; lastSig = "'"; continue; }
+        } else if (text[i + 2] === "'" && c2 !== "'") {
+          i += 3;
+          lastSig = "'";
+          continue;
+        }
+        i += 1;
+        continue;
+      } else {
+        state.str = { q: c };
+        i += 1;
+      }
+      lastSig = c;
+      continue;
+    }
+
+    // A backslash on the very last character is a Python line continuation.
+    if (c === "\\" && i + 1 === n) {
+      return { delta, trailingBackslash: true };
+    }
+
+    if (c === "(") {
+      // `before` ends with the paren itself; NON_JOINING_CALL matches on it.
+      const before = text.slice(0, i + 1).replace(/\s+$/, "");
+      if (NON_JOINING_CALL.test(before)) state.specialStack.push(state.accDelta);
+      else { delta += 1; state.accDelta += 1; }
+      lastSig = c;
+      i += 1;
+      continue;
+    }
+    if (c === "[") { delta += 1; state.accDelta += 1; lastSig = c; i += 1; continue; }
+    if (c === "{") {
+      // Go joins braces: the `if got != want { t.Errorf(…) }` block is the
+      // idiomatic Go assertion, and the value lives on its first line. The
+      // other three languages get no brace joining, so a rename of a test
+      // inside a block cannot pair as a value change on its own.
+      if (lang === "go") { delta += 1; state.accDelta += 1; }
+      lastSig = c;
+      i += 1;
+      continue;
+    }
+    if (c === ")") {
+      const top = state.specialStack[state.specialStack.length - 1];
+      if (top === state.accDelta) state.specialStack.pop();
+      else { delta -= 1; state.accDelta -= 1; }
+      lastSig = c;
+      i += 1;
+      continue;
+    }
+    if (c === "]") { delta -= 1; state.accDelta -= 1; lastSig = c; i += 1; continue; }
+    if (c === "}") {
+      if (lang === "go") { delta -= 1; state.accDelta -= 1; }
+      lastSig = c;
+      i += 1;
+      continue;
+    }
+
+    if (!/\s/.test(c)) lastSig = c;
+    i += 1;
+  }
+
+  return { delta, trailingBackslash: false };
+}
+
+/**
+ * The same source with every comment blanked out, strings and line
+ * structure untouched. Shapes and keywords are computed on this text so a
+ * commented-out `expect(…)` cannot make a block an assertion, and a number
+ * changed inside a comment cannot pair as a value change.
+ */
+function stripComments(text, lang) {
+  const state = freshScanState();
+  return text.split("\n").map((line) => {
+    let out = "";
+    let pending = 0;
+    const copyCode = (to) => {
+      out += line.slice(pending, to);
+      pending = to;
+    };
+    let i = 0;
+    const n = line.length;
+
+    while (i < n) {
+      const c = line[i];
+      const c2 = i + 1 < n ? line[i + 1] : "";
+
+      if (state.block > 0) {
+        if (c === "/" && c2 === "*") {
+          if (lang === "rust") state.block += 1;
+          i += 2;
+          continue;
+        }
+        if (c === "*" && c2 === "/") {
+          state.block -= 1;
+          i += 2;
+          if (state.block === 0) pending = i;
+          continue;
+        }
+        i += 1;
+        continue;
+      }
+
+      if (state.str) {
+        const s = state.str;
+        let closed = false;
+        if (s.rawHashes !== undefined) {
+          if (c === '"') {
+            let j = i + 1;
+            let h = 0;
+            while (j < n && line[j] === "#") { h++; j++; }
+            if (h >= s.rawHashes) { i = j; closed = true; }
+          }
+        } else if (s.raw) {
+          closed = c === s.q;
+        } else if (c === "\\") {
+          i += s.tri ? 1 : 2;
+          continue;
+        } else if (c === s.q) {
+          if (s.tri) {
+            if (line[i + 1] === s.q && line[i + 2] === s.q) { i += 3; closed = true; }
+            else { i += 1; }
+          } else {
+            i += 1;
+            closed = true;
+          }
+        }
+        if (closed) {
+          state.str = null;
+          copyCode(i);
+          continue;
+        }
+        i += 1;
+        continue;
+      }
+
+      if (c === "/" && c2 === "/") { copyCode(i); break; }
+      if (lang === "python" && c === "#") { copyCode(i); break; }
+      if (c === "/" && c2 === "*") {
+        copyCode(i);
+        state.block = 1;
+        i += 2;
+        continue;
+      }
+      if (c === '"' || c === "'" || (lang === "go" && c === "`")) {
+        copyCode(i);
+        if (lang === "python" && c2 === c && line[i + 2] === c) {
+          state.str = { q: c, tri: true };
+          i += 3;
+        } else if (lang === "rust" && c === '"') {
+          if (i > 0 && line[i - 1] === "r") {
+            let j = i - 1;
+            let h = 0;
+            while (j >= 1 && line[j - 1] === "#") { h++; j--; }
+            state.str = { q: '"', rawHashes: h };
+            i += 1;
+          } else {
+            state.str = { q: c };
+            i += 1;
+          }
+        } else if (lang === "rust" && c === "'") {
+          if (c2 === "\\") {
+            const end = line.indexOf("'", i + 2);
+            if (end !== -1 && end - i <= 4) { i = end + 1; copyCode(i); continue; }
+          } else if (line[i + 2] === "'" && c2 !== "'") {
+            i += 3;
+            copyCode(i);
+            continue;
+          }
+          i += 1;
+          copyCode(i);
+          continue;
+        } else {
+          state.str = { q: c };
+          i += 1;
+        }
+        continue;
+      }
+      i += 1;
+    }
+    copyCode(n);
+    return out;
+  }).join("\n");
+}
+
+// A line that cannot start a statement of its own continues the previous
+// statement: a closing delimiter, a member-access, or an operator.
+const CONTINUATION_START = /^[)\],.]/;
+const CONTINUATION_OP_START = /^[+\-*/%<>=&|^:]/;
+
+// A scanner miscount (an unbalanced delimiter inside a regex literal is the
+// usual cause) must not be able to merge a whole file into one statement,
+// which would pair *any* literal change anywhere in the file.
+const MAX_STATEMENT_LINES = 100;
+const MAX_STATEMENT_CHARS = 12000;
+
+/**
+ * Reassemble physical lines into statements.
+ *
+ * `sliceLines` is one image of a hunk in file order: context lines plus the
+ * removed (or added) lines. Context lines are ordinary file text; a
+ * statement spans them freely, which is exactly what makes a value edit
+ * inside a formatter-wrapped assertion visible to the pairing.
+ *
+ * @param {Array<{ kind: string, text: string, oldNo: number|null, newNo: number|null }>} sliceLines
+ * @param {string} lang
+ * @returns {Array<{ text: string, firstOld: number|null, lastOld: number|null, firstNew: number|null, lastNew: number|null, removedLines: Array, addedLines: Array }>}
+ */
+function assembleStatements(sliceLines, lang) {
+  const stmts = [];
+  let cur = null;
+
+  const flush = () => {
+    if (!cur) return;
+    stmts.push({
+      text: cur.lines.join("\n"),
+      firstOld: cur.firstOld,
+      lastOld: cur.lastOld,
+      firstNew: cur.firstNew,
+      lastNew: cur.lastNew,
+      removedLines: cur.removedLines,
+      addedLines: cur.addedLines,
+    });
+    cur = null;
+  };
+
+  for (const L of sliceLines) {
+    const trimmed = L.text.replace(/^\s+/, "");
+    const joins =
+      cur !== null &&
+      (cur.delta > 0 ||
+        cur.state.str !== null ||
+        cur.state.block > 0 ||
+        cur.trailingBackslash ||
+        CONTINUATION_START.test(trimmed) ||
+        CONTINUATION_OP_START.test(trimmed));
+
+    if (
+      joins &&
+      cur.lines.length < MAX_STATEMENT_LINES &&
+      cur.chars + L.text.length + 1 <= MAX_STATEMENT_CHARS
+    ) {
+      cur.lines.push(L.text);
+      cur.chars += L.text.length + 1;
+      const sc = scanSourceLine(L.text, lang, cur.state);
+      cur.delta += sc.delta;
+      cur.trailingBackslash = sc.trailingBackslash;
+      cur.lastOld = L.oldNo;
+      cur.lastNew = L.newNo;
+      if (L.kind === "-") cur.removedLines.push(L);
+      else if (L.kind === "+") cur.addedLines.push(L);
+    } else {
+      flush();
+      const st = freshScanState();
+      const sc = scanSourceLine(L.text, lang, st);
+      cur = {
+        lines: [L.text],
+        chars: L.text.length,
+        firstOld: L.oldNo,
+        lastOld: L.oldNo,
+        firstNew: L.newNo,
+        lastNew: L.newNo,
+        delta: sc.delta,
+        state: st,
+        trailingBackslash: sc.trailingBackslash,
+        removedLines: L.kind === "-" ? [L] : [],
+        addedLines: L.kind === "+" ? [L] : [],
+      };
+    }
+  }
+  flush();
+  return stmts;
+}
+
+const hasLiteralPlaceholder = (shape) =>
+  shape.includes("\u0000S") || shape.includes("\u0000N") || shape.includes("\u0000B");
+
+const collapseWhitespace = (s) => s.replace(/\s+/g, " ").trim();
+const shorten = (s) => (s.length > 160 ? `${s.slice(0, 157)}…` : s);
+
+/**
+ * Split the argument list of the outermost assertion call in `clean`.
+ *
+ * Comments are already stripped by the caller, so only string state has to be
+ * tracked. Returns null whenever the shape is not confidently understood — a
+ * truncated fragment, an unbalanced hunk, a quoting form not handled here —
+ * because every caller uses this to *suppress* a finding, and failing to
+ * understand a statement must never become a reason to stay quiet about it.
+ *
+ * @param {string} clean - comment-stripped statement text
+ * @param {string} lang
+ * @returns {string[] | null} top-level arguments, trimmed
+ */
+function splitAssertionArgs(clean, lang) {
+  SPECIFIC_ASSERTION.lastIndex = 0;
+  const m = SPECIFIC_ASSERTION.exec(clean);
+  if (!m) return null;
+
+  let i = m.index + m[0].length; // just past the opening paren
+  let depth = 1;
+  let quote = null;
+  let triple = false;
+  const args = [];
+  let start = i;
+
+  while (i < clean.length) {
+    const c = clean[i];
+
+    if (quote !== null) {
+      if (c === "\\") { i += 2; continue; }
+      if (triple && c === quote && clean[i + 1] === quote && clean[i + 2] === quote) {
+        quote = null; triple = false; i += 3; continue;
+      }
+      if (!triple && c === quote) { quote = null; i += 1; continue; }
+      i += 1;
+      continue;
+    }
+
+    if (c === '"' || c === "'" || c === "`") {
+      if (lang === "python" && clean[i + 1] === c && clean[i + 2] === c) {
+        quote = c; triple = true; i += 3; continue;
+      }
+      quote = c; i += 1; continue;
+    }
+
+    if (c === "(" || c === "[" || c === "{") { depth += 1; i += 1; continue; }
+    if (c === ")" || c === "]" || c === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        args.push(clean.slice(start, i).trim());
+        return args;
+      }
+      i += 1;
+      continue;
+    }
+    if (c === "," && depth === 1) {
+      args.push(clean.slice(start, i).trim());
+      start = i + 1;
+      i += 1;
+      continue;
+    }
+    i += 1;
+  }
+  return null; // never closed: an unbalanced fragment, so no suppression
+}
+
+/** One plain string literal and nothing else. */
+const PURE_STRING_LITERAL = new RegExp(
+  [
+    "^'(?:\\\\.|[^'\\\\])*'$",
+    '^"(?:\\\\.|[^"\\\\])*"$',
+    "^`(?:\\\\.|[^`\\\\])*`$",
+    '^"""[\\s\\S]*"""$',
+    "^'''[\\s\\S]*'''$",
+  ].join("|")
+);
+
+function isPureStringLiteral(arg) {
+  if (!arg) return false;
+  return PURE_STRING_LITERAL.test(arg.trim());
+}
+
+/**
+ * Argument positions that carry a message for a human rather than an expected
+ * value.
+ *
+ * Trailing, for `assert.equal(got, want, "message")` and
+ * `assert_eq!(a, b, "message")`; leading, for Go's
+ * `t.Errorf("got %d want %d", got, want)`. Two arguments is the classic
+ * `(actual, expected)` shape, so a string in last position *there* is the
+ * expected value: `assert.equal(name, "Alice")` must still be judged when
+ * "Alice" becomes "Bob".
+ */
+function messageArgIndices(args) {
+  const idx = new Set();
+  if (args.length >= 3 && isPureStringLiteral(args[args.length - 1])) idx.add(args.length - 1);
+  if (args.length >= 2 && isPureStringLiteral(args[0])) idx.add(0);
+  return idx;
+}
+
+/**
+ * True when two assertions differ only in text written to be read by a person.
+ *
+ * Rewording the message on a failing assertion is among the most common edits
+ * any test file receives, and it says nothing whatsoever about what the suite
+ * checks. But a message is a literal, so blanking literals made the two
+ * statements the same shape and the pairing reported a rewritten expectation
+ * every time somebody improved the wording of a failure. Firing on that is
+ * how an operator learns to pass the override without reading it.
+ */
+function differsOnlyInMessage(cleanRemoved, cleanAdded, lang) {
+  const a = splitAssertionArgs(cleanRemoved, lang);
+  const b = splitAssertionArgs(cleanAdded, lang);
+  if (!a || !b || a.length !== b.length || a.length === 0) return false;
+
+  const msgIdx = messageArgIndices(a);
+  if (msgIdx.size === 0) return false;
+
+  let sawDifference = false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i].replace(/\s+/g, "") === b[i].replace(/\s+/g, "")) continue;
+    // A difference outside a message position, or in a position that stopped
+    // being a plain string, is a real change.
+    if (!msgIdx.has(i) || !isPureStringLiteral(b[i])) return false;
+    sawDifference = true;
+  }
+  return sawDifference;
+}
+
+/**
+ * Pair rewritten expectations across the removed and added images of every
+ * hunk of one file, and report each pair.
+ *
+ * A statement is only a candidate when it actually contains a removed
+ * (resp. added) line: a context-only statement is unchanged text on both
+ * sides, and letting it pair would flag a genuinely new assertion that
+ * merely has the same shape as one that stayed put.
+ *
+ * @param {string} file
+ * @param {Array<{ lines: Array }>} hunks
+ * @param {object} stats - per-file stats; the paired physical lines are
+ *   spliced out of the count pools so the count-based checks below do not
+ *   report the same edit a second time.
+ * @param {Array} violations
+ * @returns {Array<{ r: object, a: object }>} the pairs, for the caller
+ */
+function detectExpectationRewrites(file, hunks, stats, violations) {
+  const lang = langForTestFile(file);
+  const allPairs = [];
+
+  for (const hunk of hunks) {
+    const oldSlice = [];
+    const newSlice = [];
+    for (const L of hunk.lines) {
+      if (L.kind !== "+") oldSlice.push(L);
+      if (L.kind !== "-") newSlice.push(L);
+    }
+    const oldStmts = assembleStatements(oldSlice, lang);
+    const newStmts = assembleStatements(newSlice, lang);
+
+    // Candidate statements in file order, per image.
+    const oldCands = [];
+    for (const s of oldStmts) {
+      if (s.removedLines.length === 0) continue;
+      const clean = stripComments(s.text, lang);
+      if (!isSpecificAssertion(clean)) continue;
+      oldCands.push({ s, clean, shape: blankLiterals(clean), canon: clean.replace(/\s+/g, "") });
+    }
+    const newCands = [];
+    for (const s of newStmts) {
+      if (s.addedLines.length === 0) continue;
+      const clean = stripComments(s.text, lang);
+      if (!isSpecificAssertion(clean)) continue;
+      newCands.push({ s, clean, shape: blankLiterals(clean), canon: clean.replace(/\s+/g, "") });
+    }
+
+    // The t-th removed candidate of a shape pairs with the t-th added
+    // candidate of the same shape. Position alignment is what keeps a
+    // formatter run over a block of same-shape assertions silent: a greedy
+    // "first different text" pairing would match a re-indented
+    // `assert.equal(f(0), 0)` against its neighbour's value and report a
+    // rewrite that did not happen. It also keeps the pairing linear in the
+    // number of statements, which a 4000-line same-shape table would not
+    // survive as a square of comparisons.
+    const oldByShape = new Map();
+    const newByShape = new Map();
+    for (const c of oldCands) {
+      let arr = oldByShape.get(c.shape);
+      if (!arr) arr = oldByShape.set(c.shape, []).get(c.shape);
+      arr.push(c);
+    }
+    for (const c of newCands) {
+      let arr = newByShape.get(c.shape);
+      if (!arr) arr = newByShape.set(c.shape, []).get(c.shape);
+      arr.push(c);
+    }
+
+    const pairs = [];
+    for (const [shape, olds] of oldByShape) {
+      const news = newByShape.get(shape) || [];
+
+      // Cancel the assertions that are byte-identical on both sides before
+      // aligning anything.
+      //
+      // Reordering two assertions removes both and adds both back unchanged.
+      // Positional alignment then matched the first removed against the first
+      // added — a different assertion — and reported two rewritten
+      // expectations for an edit that changed no expected value at all. The
+      // same happened to an assertion that simply moved within its block.
+      // What is present unchanged on both sides did not change; only the
+      // residue can have been rewritten.
+      const survivingNew = news.slice();
+      const survivingOld = [];
+      for (const o of olds) {
+        const twin = survivingNew.findIndex((n) => n.canon === o.canon);
+        if (twin === -1) survivingOld.push(o);
+        else survivingNew.splice(twin, 1);
+      }
+
+      const k = Math.min(survivingOld.length, survivingNew.length);
+      for (let t = 0; t < k; t++) {
+        const r = survivingOld[t];
+        const a = survivingNew[t];
+        if (r.canon === a.canon) continue;
+        if (differsOnlyInMessage(r.clean, a.clean, lang)) continue;
+        pairs.push({ r: r.s, a: a.s });
+      }
+    }
+
+    // Zero-context hunk: each image is a single fragment and the assertion
+    // keyword may sit outside the hunk entirely. The fragment pair is taken
+    // only when both sides normalize to the same shape *and* that shape
+    // holds a literal — a code change cannot fake it.
+    if (pairs.length === 0 && oldStmts.length === 1 && newStmts.length === 1) {
+      const r = oldStmts[0];
+      const a = newStmts[0];
+      if (r.removedLines.length > 0 && a.addedLines.length > 0) {
+        const sr = blankLiterals(stripComments(r.text, lang));
+        const sa = blankLiterals(stripComments(a.text, lang));
+        if (sr === sa && hasLiteralPlaceholder(sr)) {
+          const clr = stripComments(r.text, lang);
+          const cla = stripComments(a.text, lang);
+          if (clr.replace(/\s+/g, "") !== cla.replace(/\s+/g, "") && !differsOnlyInMessage(clr, cla, lang)) {
+            pairs.push({ r, a });
+          }
+        }
+      }
+    }
+
+    for (const p of pairs) {
+      allPairs.push(p);
+      const addedNo = p.a.addedLines.length > 0 ? p.a.addedLines[0].newNo : (p.r.removedLines[0] ? p.r.removedLines[0].oldNo : null);
+      violations.push({
+        file,
+        line: addedNo,
+        type: "ASSERTION_EXPECTATION_CHANGED",
+        reason:
+          `Test Tamper Guard: Expected value rewritten in ${file}${addedNo ? `:${addedNo}` : ""} — ` +
+          `"${shorten(collapseWhitespace(p.r.text))}" became "${shorten(collapseWhitespace(p.a.text))}". ` +
+          `A deliberately changed spec looks identical to a test bent to match broken ` +
+          `output, and a diff alone cannot tell the two apart, so this is flagged for ` +
+          `review rather than assumed. If the new expectation is the correct one, ` +
+          `re-run with --allow-test-change expectation — which allows exactly this ` +
+          `check and leaves the skip, vacuous, commented, removal and weakening ` +
+          `checks doing their job.`,
+      });
+
+      // Both sides are accounted for here, so they must not also feed the
+      // count-based checks below — the same line reported twice under two
+      // names tells the operator nothing extra. Consumption is symmetric so
+      // a statement that absorbed two old assertion lines but only one new
+      // one still leaves the surplus to the removal check.
+      const removedMatches = p.r.removedLines.filter(
+        (L) => stats.removed.some((e) => e.line === L.oldNo && e.text === L.text)
+      );
+      const addedMatches = p.a.addedLines.filter(
+        (L) => stats.addedTexts.some((e) => e.line === L.newNo && e.text === L.text)
+      );
+      const take = Math.min(removedMatches.length, addedMatches.length);
+      for (let k = 0; k < take; k++) {
+        const L = removedMatches[k];
+        const idx = stats.removed.findIndex((e) => e.line === L.oldNo && e.text === L.text);
+        if (idx === -1) continue;
+        const entry = stats.removed.splice(idx, 1)[0];
+        const rsIdx = stats.removedSpecific.indexOf(entry);
+        if (rsIdx !== -1) {
+          stats.removedSpecific.splice(rsIdx, 1);
+          stats.addedSpecific--;
+        }
+        stats.added--;
+      }
+    }
+  }
+
+  return allPairs;
+}
+
+/**
+ * The tamper checks, by the name an operator uses to allow one of them.
+ *
+ * There was one override for all six, and it was a switch marked "off". A
+ * deliberate change of spec rewrites what a test expects, which is
+ * indistinguishable from bending a test to match broken output — so the honest
+ * answer to that finding is sometimes an override. But reaching for it also
+ * silenced injected `.skip()`, `expect(true).toBe(true)`, commented-out
+ * assertions and outright deletions, none of which the operator had looked at.
+ * The check with the highest firing rate therefore set the ceiling for every
+ * other check in the bundle: the more useful this one became, the more often
+ * it would be used to turn the others off.
+ */
+export const TAMPER_KINDS = new Map([
+  ["TEST_SKIP_INJECTION", "skip"],
+  ["VACUOUS_ASSERTION", "vacuous"],
+  ["COMMENTED_ASSERTION", "commented"],
+  ["ASSERTION_REMOVAL", "removal"],
+  ["ASSERTION_WEAKENED", "weakening"],
+  ["ASSERTION_EXPECTATION_CHANGED", "expectation"],
+]);
+
+/** Every kind name, for CLI validation and help text. */
+export const TAMPER_KIND_NAMES = Object.freeze([...new Set(TAMPER_KINDS.values())].sort());
+
+/**
+ * Which tamper checks this run is allowed to stay quiet about.
+ *
+ * @param {object} options
+ * @param {boolean} [options.allowTestModifications] - the blunt form: all of them.
+ * @param {string|string[]} [options.allowTestChanges] - kind names, comma-separated or an array.
+ * @returns {{ all: boolean, kinds: Set<string>, unknown: string[] }}
+ */
+export function resolveAllowedTamperKinds(options = {}) {
+  if (options.allowTestModifications === true) {
+    return { all: true, kinds: new Set(TAMPER_KIND_NAMES), unknown: [] };
+  }
+  const raw = options.allowTestChanges;
+  const list = (Array.isArray(raw) ? raw : [raw])
+    .flatMap((v) => String(v == null ? "" : v).split(","))
+    .map((v) => v.trim().toLowerCase())
+    .filter(Boolean);
+
+  if (list.includes("all")) {
+    return { all: true, kinds: new Set(TAMPER_KIND_NAMES), unknown: [] };
+  }
+  const kinds = new Set();
+  const unknown = [];
+  for (const name of list) {
+    if (TAMPER_KIND_NAMES.includes(name)) kinds.add(name);
+    else unknown.push(name);
+  }
+  return { all: false, kinds, unknown };
+}
+
 /**
  * Detects test file assertion tampering, weakening, or test skips.
  *
@@ -1111,7 +1992,8 @@ function locateFindingLine(lines, type, file = null) {
  */
 export function checkTestTampering(diffOrText = "", options = {}) {
   if (!diffOrText || typeof diffOrText !== "string") return { ok: true, violations: [] };
-  if (options.allowTestModifications === true) return { ok: true, violations: [] };
+  const allowed = resolveAllowedTamperKinds(options);
+  if (allowed.all) return { ok: true, violations: [] };
 
   const violations = [];
   const lines = diffOrText.split("\n");
@@ -1120,18 +2002,7 @@ export function checkTestTampering(diffOrText = "", options = {}) {
   let currentOldLineNo = null;
   let currentNewLineNo = null;
 
-  const isTestFile = (f) => {
-    if (!f) return false;
-    const n = f.replace(/\\/g, "/").toLowerCase();
-    return (
-      n.includes(".test.") ||
-      n.includes(".spec.") ||
-      n.includes("_test.") ||
-      n.includes("/test/") ||
-      n.includes("/tests/") ||
-      n.includes("/__tests__/")
-    );
-  };
+  const isTestFile = isTestPath;
 
   const SKIP_INJECTIONS = [
     { pattern: /\b(?:it|test|describe|context)\.skip\s*\(/i, desc: "Injected test skip (.skip())" },
@@ -1159,41 +2030,8 @@ export function checkTestTampering(diffOrText = "", options = {}) {
   const ASSERTION_PATTERN = /(?:\b(?:assert(?:\.[a-zA-Z0-9_$]+)?|expect|t\.(?:assert|expect|is|equal|true|false|Errorf|Fatalf)|require\.[a-zA-Z0-9_$]+)\b|assert!|assert_eq!|assert_ne!)/i;
   const isCommentLine = (str) => /^\s*(?:\/\/|\/\*|\*|#|--|;)/.test(str);
 
-  // An assertion that states a *specific* expected value. Counting assertions
-  // alone let a test be gutted while looking untouched: swapping
-  // `assert.strictEqual(add(2,3), 5)` for `assert.ok(add(2,3) !== undefined)`
-  // removes one and adds one, so `removed > added` stayed false and the guard
-  // said nothing — while the suite stopped checking the answer.
-  const SPECIFIC_ASSERTION = new RegExp(
-    [
-      "\\bassert(?:\\.strict)?\\.?(?:strictEqual|deepStrictEqual|deepEqual|notStrictEqual|notDeepStrictEqual|equal|notEqual|match|doesNotMatch|throws|rejects|doesNotThrow)\\s*\\(",
-      "\\bexpect\\s*\\([^)]*\\)\\s*\\.(?:toBe|toEqual|toStrictEqual|toMatch|toMatchObject|toContain|toHaveBeenCalledWith|toThrow|toHaveLength|toBeCloseTo)\\s*\\(",
-      "\\bassert\\.(?:equals|deepEquals|include|lengthOf)\\s*\\(",
-      "assert_eq!|assert_ne!",
-      "\\bt\\.(?:Errorf|Fatalf)\\s*\\(",
-      "\\brequire\\.(?:Equal|NotEqual|Len|Contains|Error|NoError)\\s*\\(",
-    ].join("|"),
-    "i"
-  );
-  const isSpecificAssertion = (str) => SPECIFIC_ASSERTION.test(str);
-
-  /**
-   * An assertion with every literal value replaced by a placeholder.
-   *
-   * Two lines that normalize to the same string are the same assertion about
-   * the same expression; whatever differs between them is a value.
-   */
-  const blankLiterals = (str) =>
-    str
-      .replace(/(['"`])(?:\\.|(?!\1)[^\\])*\1/g, "\u0000S")
-      // The sign belongs to the literal: without it `3` and `-1` normalized to
-      // different shapes and the rewritten expectation was never paired.
-      .replace(/(?<![\w$])-?\d+(?:\.\d+)?\b/g, "\u0000N")
-      .replace(/\b(?:true|false|null|undefined|None|True|False|nil)\b/g, "\u0000B")
-      .replace(/\s+/g, " ")
-      .trim();
-
   const fileAssertions = new Map();
+  let pendingHunk = false;
 
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
@@ -1209,6 +2047,7 @@ export function checkTestTampering(diffOrText = "", options = {}) {
       currentFile = target && target !== "/dev/null" ? target : lastOldFile;
       currentOldLineNo = null;
       currentNewLineNo = null;
+      pendingHunk = false;
       continue;
     }
 
@@ -1216,20 +2055,28 @@ export function checkTestTampering(diffOrText = "", options = {}) {
     if (hunkMatch) {
       currentOldLineNo = Number(hunkMatch[1]);
       currentNewLineNo = Number(hunkMatch[2]);
+      pendingHunk = true;
       continue;
     }
 
     if (!currentFile || !isTestFile(currentFile)) {
+      pendingHunk = false;
       continue;
     }
 
     if (!fileAssertions.has(currentFile)) {
-      fileAssertions.set(currentFile, { removed: [], added: 0, addedTexts: [], removedSpecific: [], addedSpecific: 0 });
+      fileAssertions.set(currentFile, { removed: [], added: 0, addedTexts: [], removedSpecific: [], addedSpecific: 0, hunks: [] });
     }
     const fileStats = fileAssertions.get(currentFile);
+    if (pendingHunk) {
+      fileStats.hunks.push({ lines: [] });
+      pendingHunk = false;
+    }
+    const hunk = fileStats.hunks.length > 0 ? fileStats.hunks[fileStats.hunks.length - 1] : null;
 
     if (line.startsWith("-") && !line.startsWith("---")) {
       const deletedText = line.slice(1);
+      if (hunk) hunk.lines.push({ kind: "-", text: deletedText, oldNo: currentOldLineNo, newNo: null });
       if (!isCommentLine(deletedText) && ASSERTION_PATTERN.test(deletedText)) {
         fileStats.removed.push({ line: currentOldLineNo, text: deletedText });
         if (isSpecificAssertion(deletedText)) {
@@ -1239,6 +2086,7 @@ export function checkTestTampering(diffOrText = "", options = {}) {
       if (currentOldLineNo !== null) currentOldLineNo++;
     } else if (line.startsWith("+") && !line.startsWith("+++")) {
       const addedText = line.slice(1);
+      if (hunk) hunk.lines.push({ kind: "+", text: addedText, oldNo: null, newNo: currentNewLineNo });
       let isVacuous = false;
 
       // Check skip injections
@@ -1287,6 +2135,13 @@ export function checkTestTampering(diffOrText = "", options = {}) {
 
       if (currentNewLineNo !== null) currentNewLineNo++;
     } else if (!line.startsWith("\\")) {
+      // Context line. It is file text in both images, so the statement
+      // assembler needs it to reassemble assertions that span a changed
+      // line; `diff --git`/`index` lines that sneak in here are not
+      // diff body and are not collected.
+      if (hunk && (line.startsWith(" ") || line === "")) {
+        hunk.lines.push({ kind: " ", text: line.slice(1), oldNo: currentOldLineNo, newNo: currentNewLineNo });
+      }
       if (currentOldLineNo !== null) currentOldLineNo++;
       if (currentNewLineNo !== null) currentNewLineNo++;
     }
@@ -1297,53 +2152,14 @@ export function checkTestTampering(diffOrText = "", options = {}) {
     //
     // Counting assertions cannot see this one: `assert.equal(add(1,2), 3)`
     // becoming `assert.equal(add(1,2), -1)` takes one specific assertion out
-    // and puts one specific assertion back, so every total stayed level and the
-    // guard said nothing — while the suite went from checking that addition
-    // works to certifying that it is broken. It is the single cheapest way to
-    // make a red suite green, and the one this tool exists to refuse.
-    //
-    // The signal is that the two lines are the *same assertion* with different
-    // values in it: identical once every literal is blanked out, different
-    // before. That does not distinguish an attack from a deliberate change of
-    // spec — nothing can, from the diff alone — so this reports rather than
-    // decides, and `--allow-test-modifications` is the answer when the new
-    // expectation is the correct one.
-    // Shapes are computed once per added line, not once per (removed, added)
-    // pair: a large test refactor is O(n²) comparisons and the normalisation is
-    // the expensive half of each one.
-    const unpairedAdded = stats.addedTexts
-      .filter((a) => isSpecificAssertion(a.text))
-      .map((a) => ({ ...a, shape: blankLiterals(a.text) }));
-    for (const removedItem of stats.removed.slice()) {
-      if (!isSpecificAssertion(removedItem.text)) continue;
-      const shape = blankLiterals(removedItem.text);
-      const idx = unpairedAdded.findIndex(
-        (a) => a.shape === shape && a.text.trim() !== removedItem.text.trim()
-      );
-      if (idx === -1) continue;
-      const addedItem = unpairedAdded.splice(idx, 1)[0];
-
-      violations.push({
-        file,
-        line: addedItem.line ?? removedItem.line,
-        type: "ASSERTION_EXPECTATION_CHANGED",
-        reason:
-          `Test Tamper Guard: Expected value rewritten in ${file}${addedItem.line ? `:${addedItem.line}` : ""} — ` +
-          `"${removedItem.text.trim()}" became "${addedItem.text.trim()}". ` +
-          `If the new value is the correct one, re-run with --allow-test-modifications.`,
-      });
-
-      // Both sides are accounted for here, so they must not also feed the
-      // count-based checks below — the same line reported twice under two
-      // names tells the operator nothing extra.
-      stats.removed.splice(stats.removed.indexOf(removedItem), 1);
-      const rsIdx = stats.removedSpecific.indexOf(removedItem);
-      if (rsIdx !== -1) {
-        stats.removedSpecific.splice(rsIdx, 1);
-        stats.addedSpecific--;
-      }
-      stats.added--;
-    }
+    // and puts one specific assertion back, so every total stayed level and
+    // the guard said nothing — while the suite went from checking that
+    // addition works to certifying that it is broken. It is the single
+    // cheapest way to make a red suite green, and the one this tool exists
+    // to refuse. The line-based version of this pairing could only see the
+    // single-line spelling of the edit; the reassembled-statement version
+    // above sees every spelling, and explains why on the way.
+    detectExpectationRewrites(file, stats.hunks, stats, violations);
 
     if (stats.removed.length > stats.added) {
       const unreplaced = stats.removed.slice(stats.added);
@@ -1383,9 +2199,17 @@ export function checkTestTampering(diffOrText = "", options = {}) {
     }
   }
 
+  // A kind the operator has already looked at and accepted is dropped here
+  // rather than never being computed, so the reasoning above stays one code
+  // path regardless of what any given run allows.
+  const reported =
+    allowed.kinds.size === 0
+      ? violations
+      : violations.filter((v) => !allowed.kinds.has(TAMPER_KINDS.get(v.type)));
+
   return {
-    ok: violations.length === 0,
-    violations,
+    ok: reported.length === 0,
+    violations: reported,
   };
 }
 

package/src/test-paths.mjs

@@ -0,0 +1,68 @@
+/**
+ * One answer to "is this path a test file?".
+ *
+ * There were five, in five modules, and they disagreed with each other:
+ *
+ *   - `security.mjs`  matched the substring `/test/`, so a file in the
+ *     repository's own root-level `tests/` directory had no leading slash and
+ *     was not a test file. The entire tamper guard — skip injection, vacuous
+ *     assertions, commented-out assertions, removal, weakening, expectation
+ *     rewrites — was therefore switched off for the standard pytest layout
+ *     (`tests/test_calc.py`), the standard Rust integration layout
+ *     (`tests/integration.rs`) and every RSpec suite (`spec/`).
+ *   - `mutation.mjs`  had the same substring bug, in the opposite direction:
+ *     those same files were not excluded, so the harness mutated operators
+ *     inside the tests themselves and scored the result.
+ *   - `engine.mjs`    never looked for `_test.`, so `strictTestLock` did not
+ *     consider a Go test file to be a test file.
+ *   - `coverage.mjs`  and `evidence.mjs` each had a third and fourth spelling.
+ *
+ * A predicate this load-bearing cannot have five definitions. This is the one
+ * they all use.
+ *
+ * The classification errs toward "yes". Four of the five callers get stricter
+ * when it does — the tamper guard applies, the integrity hash covers more, the
+ * lock triggers — and the fifth (mutation) has nothing to lose, because
+ * mutating an operator inside a test proves nothing about the code under test.
+ */
+
+/**
+ * Directory names that mean "everything below here is a test".
+ *
+ * Matched as whole path segments, not substrings: `latest/` is not `test/`,
+ * and `myspec/` is not `spec/`.
+ */
+const TEST_DIR_SEGMENTS = new Set(["test", "tests", "spec", "specs", "__tests__", "__test__"]);
+
+/**
+ * True when `file` names a test file under any convention the kit supports.
+ *
+ * Covers, by directory: `test/`, `tests/`, `spec/`, `specs/`, `__tests__/` at
+ * any depth including the repository root. By filename: `foo.test.js`,
+ * `foo.spec.ts`, `foo_test.go`, `foo_spec.rb`, `test_calc.py` (pytest),
+ * `spec_helper.rb`, and Foundry's `Foo.t.sol` / `FooTest.sol`.
+ *
+ * @param {string} file - Repo-relative path, either separator.
+ * @returns {boolean}
+ */
+export function isTestPath(file) {
+  if (!file || typeof file !== "string") return false;
+  const segments = file.replace(/\\/g, "/").toLowerCase().split("/").filter(Boolean);
+  if (segments.length === 0) return false;
+
+  for (let i = 0; i < segments.length - 1; i++) {
+    if (TEST_DIR_SEGMENTS.has(segments[i])) return true;
+  }
+
+  const base = segments[segments.length - 1];
+  return (
+    base.includes(".test.") ||
+    base.includes(".spec.") ||
+    base.includes("_test.") ||
+    base.includes("_spec.") ||
+    base.startsWith("test_") ||
+    base.startsWith("spec_") ||
+    base.endsWith("test.sol") ||
+    base.endsWith(".t.sol")
+  );
+}