jules-orchestrator-kit 0.63.0 → 0.64.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 **1015 unit tests across 145 suites passing in < 15.0s**.
+* **Verified Test Suite:** Tested with **1085 unit tests across 150 suites passing in < 15.0s**.
 
 <br/>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jules-orchestrator-kit",
-  "version": "0.63.0",
+  "version": "0.64.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",
@@ -56,7 +56,8 @@
     "jules:doc-sync": "node scripts/doc-sync-check.mjs",
     "release": "node scripts/release.mjs",
     "guard-reach": "node scripts/guard-reach-check.mjs",
-    "lint": "eslint ."
+    "lint": "eslint .",
+    "package-integrity": "node scripts/package-integrity-check.mjs"
   },
   "engines": {
     "node": ">=20.0.0"

package/scripts/guard-reach-check.mjs

@@ -27,7 +27,7 @@
  *
  * Three steps, all in-process, no dependencies, well under a second:
  *
- *   1. POLICY   — the hand-written witness table in test/fixtures/guard-policy.mjs
+ *   1. POLICY   — the hand-written witness table in src/guard-policy.mjs
  *                 must hold. It is derived from what the tool advertises, never
  *                 from the regexes that implement it.
  *   2. CANARIES — every known-bad input must produce the finding it names. A
@@ -52,14 +52,24 @@ import {
   PREDICATE_MUTANTS,
   EMPTY_RUN_CANARIES,
   SCOPE_CANARIES,
-} from "../test/fixtures/guard-policy.mjs";
+  INNOCENT_EDITS,
+  UNREADABLE_DIALECTS,
+} from "../src/guard-policy.mjs";
 
-/** Build a unified diff for one canary. */
+/**
+ * Build a unified diff for one canary.
+ *
+ * The context line carries the comment syntax of the file's own language.
+ * A `//` line in a `.py` fixture is not a comment, and a fixture that lies
+ * about the language under test measures the fixture rather than the guard —
+ * which is how two false results were once read as two defects.
+ */
 function canaryDiff(c) {
-  const lines = [`--- a/${c.file}`, `+++ b/${c.file}`, "@@ -1,20 +1,20 @@", " // context"];
+  const ctx = c.context || "// context";
+  const lines = [`--- a/${c.file}`, `+++ b/${c.file}`, "@@ -1,20 +1,20 @@", ` ${ctx}`];
   for (const l of c.removed) lines.push(`-${l}`);
   for (const l of c.added) lines.push(`+${l}`);
-  lines.push(" // context");
+  lines.push(` ${ctx}`);
   return lines.join("\n");
 }
 
@@ -107,6 +117,7 @@ const canaryResults = new Map();
 {
   const silent = [];
   const noDenominator = [];
+  const noAssertions = [];
   for (const c of TAMPER_CANARIES) {
     const res = checkTestTampering(canaryDiff(c));
     const hit = (res.violations || []).some((v) => v.type === c.expect);
@@ -114,12 +125,51 @@ const canaryResults = new Map();
     if (!hit) silent.push(`${c.id} expected ${c.expect}, got ${JSON.stringify((res.violations || []).map((v) => v.type))}`);
     // A finding with no denominator is the shape this script exists to reject.
     if (hit && !(res.inputsSeen > 0)) noDenominator.push(c.id);
+    // Counting lines was not enough: a JUnit diff reported one input examined
+    // and a clean PASS while every assertion in it went unrecognised. A rule
+    // about assertions has to say how many assertions it actually read.
+    if (hit && c.expect !== "TEST_SKIP_INJECTION" && !(res.assertionsSeen > 0)) {
+      noAssertions.push(`${c.id} (${res.assertionsSeen} assertions parsed)`);
+    }
   }
   add("canaries: every tamper rule still fires", silent.length === 0, silent.length ? silent.join("; ") : `${TAMPER_CANARIES.length} canaries red as required`);
   add("canaries: every finding carries a denominator", noDenominator.length === 0, noDenominator.length ? noDenominator.join(", ") : "inputsSeen > 0 on every hit");
+  add("canaries: assertion rules parsed an assertion", noAssertions.length === 0, noAssertions.length ? noAssertions.join(", ") : "assertionsSeen > 0 on every assertion finding");
+}
+
+// --- 3. The opposite failure: flagging what is innocent ---------------------
+{
+  const noisy = [];
+  for (const e of INNOCENT_EDITS) {
+    const res = checkTestTampering(canaryDiff(e));
+    const types = (res.violations || []).map((v) => v.type);
+    if (types.length > 0) noisy.push(`${e.id} → ${JSON.stringify(types)} (${e.why})`);
+  }
+  add(
+    "innocent edits stay silent",
+    noisy.length === 0,
+    noisy.length
+      ? noisy.join("; ")
+      : `${INNOCENT_EDITS.length} ordinary edits produce no finding`
+  );
+}
+
+{
+  const quiet = [];
+  for (const d of UNREADABLE_DIALECTS) {
+    const res = checkTestTampering(canaryDiff(d));
+    if (res.status !== "UNREADABLE") quiet.push(`${d.id} → ${res.status} (${d.why})`);
+  }
+  add(
+    "an unparsable dialect says so",
+    quiet.length === 0,
+    quiet.length
+      ? `${quiet.join("; ")} — coverage ending is fine, ending silently is not`
+      : `${UNREADABLE_DIALECTS.length} unsupported dialects reported, not passed`
+  );
 }
 
-// --- 3. Predicate mutants ---------------------------------------------------
+// --- 4. Predicate mutants ---------------------------------------------------
 {
   const survivors = [];
   for (const mutant of PREDICATE_MUTANTS) {

package/scripts/package-integrity-check.mjs

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+
+/**
+ * Does the package we publish actually work?
+ *
+ * Every test in this repository runs against the source tree, where every
+ * file is present by definition. What users install is a tarball built from
+ * the `files` list in package.json, and nothing checked that the two agreed.
+ *
+ * They did not. v0.63.0 shipped `scripts/guard-reach-check.mjs` — the check
+ * whose entire purpose is to prove no guard has silently gone missing —
+ * while leaving behind the policy contract it imports. Unpacked and run, it
+ * threw ERR_MODULE_NOT_FOUND. The CLI was fine, 1015 tests were green, nine
+ * CI cells passed, and the published artefact still had a hole in it,
+ * because every one of those signals was measured somewhere the file existed.
+ *
+ * This asks the packer what it would ship, and then resolves the import
+ * graph inside that answer.
+ *
+ * Usage: node scripts/package-integrity-check.mjs [--json]
+ * Exit codes: 0 = the tarball is self-contained, 1 = it is not.
+ */
+
+import { execFileSync } from "node:child_process";
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, dirname, relative, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { IMPORT_EXTRACTION_CASES } from "../src/guard-policy.mjs";
+
+const root = fileURLToPath(new URL("..", import.meta.url));
+
+/**
+ * Mark every character that sits inside a string literal or a comment.
+ *
+ * Without this, an import quoted *inside* a fixture string reads as an
+ * import of the file itself — this check's first run reported six broken
+ * imports in the policy contract, all of them example text. A guard that
+ * cries wolf about its own fixtures gets switched off in a week.
+ *
+ * Approximate on purpose, and biased on purpose: a regex literal holding a
+ * quote can open a phantom string, so the counts reported below exist to
+ * make a mask that swallowed the file visible rather than silent.
+ */
+function stringMask(src) {
+  const mask = new Uint8Array(src.length);
+  let i = 0;
+  let quote = null;
+  let comment = null;
+  while (i < src.length) {
+    const c = src[i];
+    const d = src[i + 1];
+    if (comment === "line") {
+      if (c === "\n") comment = null;
+      else mask[i] = 1;
+      i++;
+      continue;
+    }
+    if (comment === "block") {
+      mask[i] = 1;
+      if (c === "*" && d === "/") {
+        mask[i + 1] = 1;
+        comment = null;
+        i += 2;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (quote !== null) {
+      mask[i] = 1;
+      if (c === "\\") {
+        if (i + 1 < src.length) mask[i + 1] = 1;
+        i += 2;
+        continue;
+      }
+      if (c === quote) quote = null;
+      i++;
+      continue;
+    }
+    if (c === "/" && d === "/") { comment = "line"; mask[i] = 1; i++; continue; }
+    if (c === "/" && d === "*") { comment = "block"; mask[i] = 1; i++; continue; }
+    // A regex literal holding a quote — `/["']/` — opens a string that never
+    // closes, and everything after it is misread. This file's own subject
+    // matter is regexes full of quote characters, so the mask desynchronised
+    // and a `require("./calc")` written inside a comment was reported as a
+    // missing module. Deciding regex-versus-division on the previous token is
+    // the same approximation the diff scanner already makes.
+    if (c === "/") {
+      let k = i - 1;
+      while (k >= 0 && /\s/.test(src[k])) k--;
+      const prev = k >= 0 ? src[k] : "";
+      if (prev === "" || "(,=:[!&|?{};+-*%~^<>".includes(prev)) {
+        mask[i] = 1;
+        let j = i + 1;
+        let cls = false;
+        while (j < src.length) {
+          const e = src[j];
+          mask[j] = 1;
+          if (e === "\\") { if (j + 1 < src.length) mask[j + 1] = 1; j += 2; continue; }
+          if (e === "[") cls = true;
+          else if (e === "]") cls = false;
+          else if (e === "/" && !cls) { j++; break; }
+          else if (e === "\n") break;
+          j++;
+        }
+        i = j;
+        continue;
+      }
+    }
+    if (c === '"' || c === "'" || c === "`") { quote = c; mask[i] = 1; i++; continue; }
+    i++;
+  }
+  return mask;
+}
+
+/**
+ * Every module specifier in a source file.
+ *
+ * Deliberately newline-tolerant. A matcher bounded by `[^;\n]*?` cannot see
+ * a multi-line named import, which is exactly the import that was missing
+ * from the tarball, so the first version of this check certified the broken
+ * package as sound. The extraction cases in the policy contract exist to
+ * keep that from being a private mistake twice.
+ */
+export function extractSpecifiers(src, { skipQuoted = true } = {}) {
+  const mask = skipQuoted ? stringMask(src) : null;
+  const found = new Set();
+  const collect = (re) => {
+    for (const m of src.matchAll(re)) {
+      // What decides is the token immediately before the specifier — the
+      // `from`, or the `(` of a call. In a real import it is code; in a
+      // fixture it is the middle of a string. Testing the *keyword* instead
+      // was not enough: `export const CASES = [` at the top of a file
+      // matched lazily forward into the first `from "…"` inside an example,
+      // so a genuine keyword lent its authority to quoted text.
+      if (mask) {
+        let j = m.indices[1][0] - 2;
+        while (j >= 0 && /\s/.test(src[j])) j--;
+        if (j >= 0 && mask[j]) continue;
+      }
+      found.add(m[1]);
+    }
+  };
+  collect(/(?:^|[\s;}])(?:import|export)\s[\s\S]{0,500}?from\s*["']([^"']+)["']/gd);
+  collect(/(?:^|[\s;}])import\s*["']([^"']+)["']/gd);
+  collect(/\bimport\s*\(\s*["']([^"']+)["']/gd);
+  collect(/\brequire\s*\(\s*["']([^"']+)["']/gd);
+  return [...found];
+}
+
+/**
+ * Run every integrity check and return the result.
+ *
+ * Exported as a function rather than run on import: a module that checks the
+ * package must not exit the process of anything that merely imports it.
+ */
+export function checkPackageIntegrity() {
+  const failures = [];
+  const checks = [];
+  const add = (name, ok, detail) => {
+    checks.push({ name, ok, detail });
+    if (!ok) failures.push(`${name}: ${detail}`);
+  };
+
+  // --- 1. The extractor must be able to see what it claims to look for -------
+  {
+    const wrong = [];
+    for (const c of IMPORT_EXTRACTION_CASES) {
+      const got = extractSpecifiers(c.src).sort();
+      const want = [...c.expect].sort();
+      if (JSON.stringify(got) !== JSON.stringify(want)) {
+        wrong.push(`${c.id}: found ${JSON.stringify(got)}, contract says ${JSON.stringify(want)}`);
+      }
+    }
+    add("extractor: every import form is visible", wrong.length === 0, wrong.length ? wrong.join("; ") : `${IMPORT_EXTRACTION_CASES.length} forms found`);
+  }
+
+  // --- 2. Ask the packer what it would actually ship -------------------------
+  let shipped = new Set();
+  try {
+    const out = execFileSync("npm", ["pack", "--dry-run", "--json"], { cwd: root, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+    shipped = new Set(JSON.parse(out)[0].files.map((f) => f.path.split(/[\\/]/).join("/")));
+  } catch (err) {
+    add("packer: `npm pack --dry-run` answers", false, err.message);
+  }
+  add("packer: the tarball is not empty", shipped.size > 0, `${shipped.size} files`);
+
+  // --- 3. Resolve the import graph inside the tarball ------------------------
+  {
+    const broken = [];
+    let resolved = 0;
+    let scanned = 0;
+
+    for (const file of shipped) {
+      if (!/\.(mjs|cjs|js)$/.test(file)) continue;
+      let src;
+      try {
+        src = readFileSync(resolve(root, file), "utf-8");
+      } catch {
+        continue;
+      }
+      scanned++;
+      for (const spec of extractSpecifiers(src)) {
+        if (!spec.startsWith(".")) continue; // bare and node: specifiers are not ours to resolve
+        resolved++;
+        const target = relative(root, resolve(dirname(resolve(root, file)), spec)).split(sep).join("/");
+        if (!shipped.has(target)) {
+          broken.push(`${file} imports ${spec} — ${target} is not in the tarball (on disk: ${existsSync(resolve(root, target)) ? "yes" : "no"})`);
+        }
+      }
+    }
+
+    add(
+      "tarball: every relative import resolves",
+      broken.length === 0,
+      broken.length ? broken.join("; ") : `${resolved} relative imports across ${scanned} shipped modules`
+    );
+    // A resolver that resolved nothing would report the same clean line.
+    add("tarball: the graph was actually walked", resolved > 0 && scanned > 0, `${scanned} modules, ${resolved} relative imports`);
+  }
+
+  // --- 4. Every advertised entry point has to be in the box ------------------
+  {
+    const pkg = JSON.parse(readFileSync(resolve(root, "package.json"), "utf-8"));
+    const entries = [...Object.values(pkg.bin || {}), pkg.main, pkg.module].filter(Boolean);
+    const missing = entries.map((e) => e.replace(/^\.\//, "")).filter((e) => !shipped.has(e));
+    add("entry points: every bin and main ships", missing.length === 0, missing.length ? missing.join(", ") : `${entries.length} entry points present`);
+  }
+
+  return { ok: failures.length === 0, checks, failures };
+}
+
+const isMain = process.argv[1] && process.argv[1].endsWith("package-integrity-check.mjs");
+if (isMain) {
+  const { ok, checks: rows, failures: bad } = checkPackageIntegrity();
+  if (process.argv.includes("--json")) {
+    console.log(JSON.stringify({ ok, checks: rows }, null, 2));
+  } else {
+    console.log("\n📦 Package Integrity Check (what we actually publish)");
+    console.log("-------------------------------------------------------");
+    for (const c of rows) console.log(`  ${c.ok ? "✅" : "❌"} ${c.name.padEnd(46)} ${c.detail}`);
+    console.log("-------------------------------------------------------");
+    console.log(
+      ok
+        ? "✅ The published package is self-contained.\n"
+        : `\n❌ ${bad.length} problem(s). The tarball is not what the source tree looks like.\n`
+    );
+  }
+  process.exit(ok ? 0 : 1);
+}

package/scripts/release.mjs

@@ -58,6 +58,22 @@ try {
   process.exit(1);
 }
 
+// Step 1a proved the guards work here. Here is not where users run them.
+//
+// Every signal so far was measured in the source tree, where every file
+// exists by construction. What ships is a tarball built from the `files`
+// list, and v0.63.0 published the guard-reach check without the policy
+// contract it imports — green suite, green matrix, green release, and a
+// module that threw ERR_MODULE_NOT_FOUND the moment anyone installed it.
+console.log("1a-2. Verifying the package we would publish is self-contained...");
+try {
+  execSync("node scripts/package-integrity-check.mjs", { cwd: root, stdio: "inherit" });
+  console.log("");
+} catch (_) {
+  console.error("\n❌ Release Aborted: the tarball is not what the source tree looks like.");
+  process.exit(1);
+}
+
 // 1b. Documentation / version consistency gate (blocking).
 console.log("1b. Verifying documentation is in sync with package.json & test suite...");
 {

package/src/assertions.mjs

@@ -561,12 +561,28 @@ export function assertTestIntegrity(config = {}, root = process.cwd()) {
   const res = checkTestTampering(diffStr, config);
   const diagnostics = (res.violations || []).map((v) => v.reason);
 
+  // A clean result from a guard that could not read the dialect is not a
+  // clean result, and it must not be reported as one. This does not fail the
+  // check — an unlisted assertion library is the user's normal, not their
+  // fault — but they get to know the guard is not covering them.
+  for (const u of res.unreadable || []) {
+    diagnostics.push(
+      `Test Tamper Guard: ${u.count} assertion-shaped line(s) in ${u.file} matched no known dialect, ` +
+        `so this file was not checked for tampering (e.g. ${JSON.stringify(u.samples[0])}). ` +
+        `The guard reports what it could not read rather than passing silently.`
+    );
+  }
+
   return {
     ok: res.ok,
     violations: res.violations || [],
     diagnostics,
     metrics: {
       violationCount: res.violations?.length || 0,
+      assertionsSeen: res.assertionsSeen ?? 0,
+      filesSeen: res.filesSeen ?? 0,
+      unreadableFiles: (res.unreadable || []).length,
+      status: res.status,
     },
   };
 }

package/src/guard-policy.mjs

@@ -0,0 +1,481 @@
+/**
+ * The policy this kit claims to enforce, written by hand.
+ *
+ * Every entry here is derived from what the tool *advertises* — the stacks
+ * `detectStack` declares, the layouts each ecosystem actually uses — and never
+ * from the regexes, path lists or registries that implement the checks. That
+ * separation is the whole point: a contract generated from the implementation
+ * makes the implementation its own oracle, and an implementation that is its
+ * own oracle cannot be wrong.
+ *
+ * This is what the substring bug in the file classifier cost. `isTestFile`
+ * matched `/test/`, which does not occur in `tests/test_calc.py`, so the entire
+ * tamper guard was off for the standard pytest, Rust and RSpec layouts — and
+ * every mechanism that should have caught it (a large suite, a doc-sync gate,
+ * a nine-way CI matrix, two cold reviews, a blocking release) was sampling the
+ * same distribution the implementation was written from. Nine runs of
+ * `test/foo.test.js` do not explore `tests/test_calc.py`.
+ *
+ * Adding a stack to `detectStack` is not finished until it has a row here.
+ */
+
+/**
+ * Paths the policy says are test files, and near-misses it says are not.
+ *
+ * The near-misses matter as much as the hits: a predicate that answers "yes"
+ * to everything also has no denominator.
+ */
+export const TEST_PATH_CASES = [
+  // Node / JavaScript
+  { path: "test/calc.test.js", expected: true, why: "node, conventional" },
+  { path: "src/calc.spec.ts", expected: true, why: "co-located spec" },
+  { path: "src/__tests__/calc.js", expected: true, why: "jest convention" },
+  // Python
+  { path: "tests/test_calc.py", expected: true, why: "pytest, repository root — the reported gap" },
+  { path: "test/test_calc.py", expected: true, why: "pytest, singular directory" },
+  { path: "backend/tests/test_api.py", expected: true, why: "pytest, nested" },
+  // Go
+  { path: "internal/calc/calc_test.go", expected: true, why: "go, co-located with the code" },
+  { path: "cmd/api/main_test.go", expected: true, why: "go, command package" },
+  // Rust
+  { path: "tests/integration.rs", expected: true, why: "rust integration tests" },
+  // Ruby
+  { path: "spec/models/user_spec.rb", expected: true, why: "rspec" },
+  { path: "test/user_test.rb", expected: true, why: "minitest" },
+  // JVM / .NET / PHP
+  { path: "src/test/java/com/x/CalcTest.java", expected: true, why: "maven layout" },
+  { path: "tests/Unit/CalcTest.php", expected: true, why: "phpunit" },
+  // Solidity
+  { path: "test/Token.t.sol", expected: true, why: "foundry" },
+  // Monorepo position
+  { path: "packages/api/test/handler.test.js", expected: true, why: "monorepo package" },
+
+  // Near-misses: segment match, not substring
+  { path: "latest/build.js", expected: false, why: "`latest` is not `test`" },
+  { path: "contest/result.js", expected: false, why: "`contest` is not `test`" },
+  { path: "lib/myspec/render.js", expected: false, why: "`myspec` is not `spec`" },
+  { path: "src/attestation.js", expected: false, why: "contains 'test', is not one" },
+  { path: "src/index.js", expected: false, why: "ordinary source" },
+  { path: "docs/testing-guide.md", expected: false, why: "documentation about testing" },
+];
+
+/**
+ * Known-bad diffs, one per guard rule, each with the finding it MUST produce.
+ *
+ * A canary that comes back clean is not a passing test — it is proof that the
+ * rule it names has stopped being reachable. `layout` is deliberately varied
+ * across ecosystems so that a canary set cannot be green by only ever handing
+ * the guard the layout the implementation was written from.
+ */
+export const TAMPER_CANARIES = [
+  {
+    id: "skip-injection/node",
+    file: "test/calc.test.js",
+    removed: [],
+    added: ['it.skip("adds", () => { assert.equal(add(1,2), 3); });'],
+    expect: "TEST_SKIP_INJECTION",
+  },
+  {
+    id: "vacuous/node",
+    file: "test/calc.test.js",
+    removed: ["assert.equal(add(1, 2), 3);"],
+    added: ["assert.ok(true);"],
+    expect: "VACUOUS_ASSERTION",
+  },
+  {
+    id: "commented/node",
+    file: "test/calc.test.js",
+    removed: ["assert.equal(add(1, 2), 3);"],
+    added: ["// assert.equal(add(1, 2), 3);"],
+    expect: "COMMENTED_ASSERTION",
+  },
+  {
+    id: "removal/node",
+    file: "test/calc.test.js",
+    removed: ["assert.equal(add(1, 2), 3);", "assert.equal(add(2, 2), 4);"],
+    added: [],
+    expect: "ASSERTION_REMOVAL",
+  },
+  {
+    id: "weakening/node",
+    file: "test/calc.test.js",
+    removed: ["assert.strictEqual(add(1, 2), 3);"],
+    added: ["assert.ok(add(1, 2) !== undefined);"],
+    expect: "ASSERTION_WEAKENED",
+  },
+  {
+    id: "expectation/node",
+    file: "test/calc.test.js",
+    removed: ["assert.equal(add(1, 2), 3);"],
+    added: ["assert.equal(add(1, 2), -1);"],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+  // The same attacks, in the layouts the classifier used to be blind to.
+  // These are the canaries that were silent when the classifier matched a
+  // substring instead of a path segment.
+  {
+    id: "expectation/pytest-root",
+    file: "tests/test_calc.py",
+    removed: ["    self.assertEqual(add(1, 2), 3)"],
+    added: ["    self.assertEqual(add(1, 2), -1)"],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+  {
+    id: "skip-injection/pytest-root",
+    file: "tests/test_calc.py",
+    removed: [],
+    added: ["@pytest.mark.skip", "def test_add():"],
+    expect: "TEST_SKIP_INJECTION",
+  },
+  {
+    id: "expectation/rust",
+    file: "tests/integration.rs",
+    removed: ["    assert_eq!(add(1, 2), 3);"],
+    added: ["    assert_eq!(add(1, 2), -1);"],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+  {
+    id: "expectation/go-colocated",
+    file: "internal/calc/calc_test.go",
+    removed: ['\t\tt.Errorf("got %d want %d", got, 3)'],
+    added: ['\t\tt.Errorf("got %d want %d", got, 999)'],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+  {
+    id: "removal/monorepo",
+    file: "packages/api/test/handler.test.js",
+    removed: ["expect(handler(req)).toBe(200);", "expect(handler(bad)).toBe(400);"],
+    added: [],
+    expect: "ASSERTION_REMOVAL",
+  },
+  // Dialects the guard was measured silent on. `assertEqual` matched only
+  // because the pattern's optional dot and case-insensitive flag happened to
+  // line up; `assertEquals` — one letter longer — did not, and neither did
+  // RSpec's `.to eq(`, PHPUnit's `$this->assertSame`, Minitest's
+  // `assert_equal` or XCTest's `XCTAssertEqual`. Every one of them returned
+  // PASS with a non-zero denominator, which is the exact shape this file
+  // exists to reject, one level down inside the mechanism built to catch it.
+  {
+    id: "expectation/junit",
+    file: "src/test/java/com/x/CalcTest.java",
+    removed: ["        assertEquals(3, calc.add(1, 2));"],
+    added: ["        assertEquals(-1, calc.add(1, 2));"],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+  {
+    id: "expectation/rspec",
+    file: "spec/models/user_spec.rb",
+    removed: ["    expect(user.age).to eq(30)"],
+    added: ["    expect(user.age).to eq(-1)"],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+  {
+    id: "expectation/phpunit",
+    file: "tests/Unit/CalcTest.php",
+    removed: ["        $this->assertSame(3, $c->add(1, 2));"],
+    added: ["        $this->assertSame(-1, $c->add(1, 2));"],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+  {
+    id: "expectation/minitest",
+    file: "test/user_test.rb",
+    removed: ["    assert_equal(3, add(1, 2))"],
+    added: ["    assert_equal(-1, add(1, 2))"],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+  {
+    id: "expectation/xctest",
+    file: "Tests/CalcTests/CalcTests.swift",
+    removed: ["        XCTAssertEqual(add(1, 2), 3)"],
+    added: ["        XCTAssertEqual(add(1, 2), -1)"],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+  {
+    id: "weakening/junit",
+    file: "src/test/java/com/x/CalcTest.java",
+    removed: ["        assertEquals(3, calc.add(1, 2));"],
+    added: ["        assertTrue(calc.add(1, 2) != null);"],
+    expect: "ASSERTION_WEAKENED",
+  },
+  {
+    id: "removal/phpunit",
+    file: "tests/Unit/CalcTest.php",
+    removed: ["        $this->assertSame(3, $c->add(1, 2));", "        $this->assertSame(4, $c->add(2, 2));"],
+    added: [],
+    expect: "ASSERTION_REMOVAL",
+  },
+  {
+    id: "vacuous/xctest",
+    file: "Tests/CalcTests/CalcTests.swift",
+    removed: ["        XCTAssertEqual(add(1, 2), 3)"],
+    added: ["        XCTAssertTrue(true)"],
+    expect: "VACUOUS_ASSERTION",
+  },
+  // Skip injection is the same blindness in the other five ecosystems: a
+  // suite that never runs cannot fail, and `@Disabled` is as effective as
+  // `it.skip` at making that happen.
+  {
+    id: "skip-injection/junit",
+    file: "src/test/java/com/x/CalcTest.java",
+    removed: [],
+    added: ["    @Disabled(\"flaky\")", "    void addsTwoNumbers() {"],
+    expect: "TEST_SKIP_INJECTION",
+  },
+  {
+    id: "skip-injection/rspec",
+    file: "spec/models/user_spec.rb",
+    removed: [],
+    added: ["  xit \"computes the age\" do"],
+    expect: "TEST_SKIP_INJECTION",
+  },
+  {
+    id: "skip-injection/phpunit",
+    file: "tests/Unit/CalcTest.php",
+    removed: [],
+    added: ["        $this->markTestSkipped(\"later\");"],
+    expect: "TEST_SKIP_INJECTION",
+  },
+  {
+    id: "skip-injection/xctest",
+    file: "Tests/CalcTests/CalcTests.swift",
+    removed: [],
+    added: ["        throw XCTSkip(\"not now\")"],
+    expect: "TEST_SKIP_INJECTION",
+  },
+];
+
+
+/**
+ * Mutants of the applicability predicate.
+ *
+ * Each one must kill at least one canary. A mutant that survives means no
+ * canary ever required the guard to *activate* — the suite would stay green if
+ * the guard silently stopped looking, which is precisely the defect.
+ *
+ * These are hand-written rather than generated: the original bug was not an
+ * untested branch, it was a branch nobody wrote, and no mutation operator
+ * invents the case the code never handled.
+ */
+export const PREDICATE_MUTANTS = [
+  { id: "alwaysFalse", fn: () => false, why: "the guard looks at nothing" },
+  { id: "rootBlind", fn: (p) => String(p).includes("/test/"), why: "the original substring bug" },
+  { id: "nodeOnly", fn: (p) => /\.(test|spec)\.[jt]sx?$/.test(String(p)), why: "only the layout the code was written from" },
+  { id: "caseSensitive", fn: (p) => String(p) === String(p).toLowerCase() && /(^|\/)tests?\//.test(String(p)), why: "case and separator drift" },
+];
+
+/** Runner outputs that state zero collected tests, per ecosystem. */
+export const EMPTY_RUN_CANARIES = [
+  { id: "pytest", output: "collected 0 items\n\nno tests ran in 0.01s" },
+  { id: "jest", output: "No tests found, exiting with code 0" },
+  { id: "vitest", output: "No test files found, exiting with code 0" },
+  { id: "cargo", output: "running 0 tests\ntest result: ok. 0 passed" },
+  { id: "mocha", output: "  0 passing (1ms)" },
+  { id: "go", output: "?   example.com/app\t[no test files]" },
+  { id: "surefire", output: "Tests run: 0, Failures: 0, Errors: 0, Skipped: 0" },
+  { id: "gradle", output: "> Task :test NO-SOURCE" },
+  { id: "phpunit", output: "No tests executed!" },
+  { id: "rspec", output: "0 examples, 0 failures" },
+  { id: "dotnet", output: "Total tests: 0" },
+  { id: "xctest", output: "Executed 0 tests" },
+  { id: "ctest", output: "No tests were found!!!" },
+];
+
+/** Paths the policy says an agent must never modify without an override. */
+export const SCOPE_CANARIES = [
+  { path: ".github/workflows/ci.yml", rule: "deny", why: "runs with repo credentials" },
+  { path: ".gitlab-ci.yml", rule: "deny", why: "same, another forge" },
+  { path: "Jenkinsfile", rule: "deny", why: "same, another forge" },
+  { path: ".envrc", rule: "deny", why: "direnv executes it on cd" },
+  { path: "package-lock.json", rule: "protect", why: "decides which code installs" },
+  { path: "Cargo.lock", rule: "protect", why: "same, another ecosystem" },
+  { path: "conftest.py", rule: "protect", why: "runs before every pytest collection" },
+  { path: "jest.config.js", rule: "protect", why: "decides which tests run" },
+  { path: "CODEOWNERS", rule: "protect", why: "decides who must approve" },
+];
+
+/**
+ * Edits that must produce no finding at all.
+ *
+ * A guard that answers "yes" to everything has no more discrimination than
+ * one that answers "no" to everything, and it is worse in practice: the
+ * operator learns to pass the override without reading it, and the day it
+ * reports something real, nobody looks. Every entry here is an edit an
+ * honest agent makes constantly.
+ *
+ * The first two are not hypothetical. `//` begins with a division sign, so a
+ * comment line matched the operator-continuation test and folded itself into
+ * the assertion above it — which meant *adding* an assertion next to a
+ * comment was reported as rewriting an expectation. Python was immune,
+ * because `#` is not an operator, so the fixtures this project was written
+ * from never showed it.
+ */
+export const INNOCENT_EDITS = [
+  {
+    id: "add-assertion-beside-comment/node",
+    file: "test/calc.test.js",
+    context: "// arithmetic",
+    removed: ["  assert.equal(add(1, 2), 3);"],
+    added: ["  assert.equal(add(1, 2), 3);", "  assert.equal(add(2, 2), 4);"],
+    why: "adding a test is the behaviour the gate exists to encourage",
+  },
+  {
+    id: "add-assertion-beside-comment/rust",
+    file: "tests/integration.rs",
+    context: "// arithmetic",
+    removed: ["    assert!(add(1, 2) == 3);"],
+    added: ["    assert!(add(1, 2) == 3);", "    assert!(add(2, 2) == 4);"],
+    why: "same edit, same comment syntax, another ecosystem",
+  },
+  {
+    id: "reorder-assertions/pytest",
+    file: "tests/test_calc.py",
+    context: "# arithmetic",
+    removed: ["    assert a() == 1", "    assert b() == 2"],
+    added: ["    assert b() == 2", "    assert a() == 1"],
+    why: "moving an assertion changes nothing it checks",
+  },
+  {
+    id: "reindent/pytest",
+    file: "tests/test_calc.py",
+    context: "# arithmetic",
+    removed: ["    assert add(1, 2) == 3"],
+    added: ["        assert add(1, 2) == 3"],
+    why: "a formatter run must not read as tampering",
+  },
+  {
+    id: "reword-message/rspec",
+    file: "spec/models/user_spec.rb",
+    context: "# age",
+    removed: ['    expect(u.age).to eq(30), "wrong"'],
+    added: ['    expect(u.age).to eq(30), "unexpected age"'],
+    why: "RSpec writes the message outside the call, where an argument check cannot see it",
+  },
+  {
+    id: "reword-message/minitest",
+    file: "test/user_test.rb",
+    context: "# age",
+    removed: ['    assert_equal 3, add(1, 2), "wrong"'],
+    added: ['    assert_equal 3, add(1, 2), "unexpected sum"'],
+    why: "same, with the message in argument position and no parentheses",
+  },
+  {
+    id: "reword-message/node",
+    file: "test/calc.test.js",
+    context: "// arithmetic",
+    removed: ['  assert.equal(add(1, 2), 3, "wrong");'],
+    added: ['  assert.equal(add(1, 2), 3, "unexpected sum");'],
+    why: "rewording a failure message says nothing about what is checked",
+  },
+  {
+    id: "rename-test/junit",
+    file: "src/test/java/com/x/CalcTest.java",
+    context: "// arithmetic",
+    removed: ["    void addsNumbers() {"],
+    added: ["    void addsTwoNumbers() {"],
+    why: "a test name is not an expectation",
+  },
+  {
+    id: "change-import/node",
+    file: "test/calc.test.js",
+    context: "// setup",
+    removed: ['const calc = require("./calc");'],
+    added: ['const calc = require("../src/calc");'],
+    why: "`require(` is an import, not a claim — the loose net must not read it as one",
+  },
+  {
+    id: "rename-helper/node",
+    file: "test/calc.test.js",
+    context: "// setup",
+    removed: ["  const shouldRetry = false;"],
+    added: ["  const shouldRetry = true;"],
+    why: "`shouldRetry` and `expected` are identifiers; reading them as assertions makes the dialect warning worthless",
+  },
+];
+
+/**
+ * Dialects the guard genuinely cannot parse, which it must say out loud.
+ *
+ * This is the case the whole denominator exists for. A JUnit diff used to
+ * return `PASS` with `inputsSeen: 1` while not one assertion in it had been
+ * recognised — a verdict indistinguishable from a clean Node suite. Coverage
+ * will always end somewhere; what must never happen again is that the edge
+ * is silent.
+ */
+export const UNREADABLE_DIALECTS = [
+  {
+    id: "hspec",
+    file: "tests/CalcSpec.hs",
+    context: "-- arithmetic",
+    removed: ["    calc `shouldBe` 3"],
+    added: ["    calc `shouldBe` (-1)"],
+    why: "an infix assertion with no parentheses anywhere near it",
+  },
+  {
+    id: "googletest",
+    file: "tests/calc_test.cc",
+    context: "// arithmetic",
+    removed: ["  EXPECT_EQ(add(1, 2), 3);"],
+    added: ["  EXPECT_EQ(add(1, 2), -1);"],
+    why: "a macro dialect the pattern list does not cover",
+  },
+];
+
+/**
+ * Import forms the package-integrity extractor must find.
+ *
+ * The first pass of that check reported "every relative import resolves" on
+ * a package whose newest script could not start: its matcher was written as
+ * `[^;\n]*?from`, and the import it needed to see spanned several lines. The
+ * check was confidently green about a file that threw ERR_MODULE_NOT_FOUND
+ * on load — the same failure the tool exists to prevent, committed by the
+ * tool's own integrity check.
+ *
+ * Every entry is a source fragment and the specifiers it must yield.
+ */
+export const IMPORT_EXTRACTION_CASES = [
+  { id: "single-line named", src: 'import { a, b } from "./one.mjs";', expect: ["./one.mjs"] },
+  {
+    id: "multi-line named",
+    src: 'import {\n  a,\n  b,\n} from "./two.mjs";',
+    expect: ["./two.mjs"],
+    why: "the form the first version of the check could not see",
+  },
+  { id: "default", src: 'import three from "./three.mjs";', expect: ["./three.mjs"] },
+  { id: "namespace", src: 'import * as four from "./four.mjs";', expect: ["./four.mjs"] },
+  { id: "side-effect only", src: 'import "./five.mjs";', expect: ["./five.mjs"] },
+  { id: "re-export", src: 'export { six } from "./six.mjs";', expect: ["./six.mjs"] },
+  { id: "re-export all", src: 'export * from "./seven.mjs";', expect: ["./seven.mjs"] },
+  { id: "dynamic", src: 'const m = await import("./eight.mjs");', expect: ["./eight.mjs"] },
+  { id: "require", src: 'const nine = require("./nine.js");', expect: ["./nine.js"] },
+  { id: "single quotes", src: "import ten from './ten.mjs';", expect: ["./ten.mjs"] },
+  {
+    id: "bare specifiers are not files",
+    src: 'import { readFileSync } from "node:fs";\nimport x from "some-package";',
+    expect: ["node:fs", "some-package"],
+    why: "found, then ignored by the resolver — never resolved against the tarball",
+  },
+];
+
+// Cases that exercise the mask rather than the matcher. Appended separately
+// because each one is a fixture *about* fixtures: the check has to tell a
+// module reference from a picture of one.
+IMPORT_EXTRACTION_CASES.push(
+  {
+    id: "regex holding a quote, then a real import",
+    src: 'const q = /["\']/;\nimport x from "./after-regex.mjs";',
+    expect: ["./after-regex.mjs"],
+    why: "the phantom string this file's own subject matter opens",
+  },
+  {
+    id: "an import quoted inside a string",
+    src: 'const example = \'import a from "./not-real.mjs";\';',
+    expect: [],
+    why: "a picture of an import is not an import",
+  },
+  {
+    id: "an import written in a comment",
+    src: '// import a from "./commented.mjs";\nconst x = 1;',
+    expect: [],
+    why: "same, in the other place examples live",
+  }
+);

package/src/security.mjs

@@ -1155,14 +1155,42 @@ function locateFindingLine(lines, type, file = null) {
 // (`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.
+// The dialect list is not decoration. `assertEqual` was recognised only
+// because `\.?` made the dot optional and the `i` flag let `Equal` match
+// `equal`; `assertEquals`, one letter longer, fell out of the pattern and
+// took JUnit, PHPUnit, Minitest, RSpec and XCTest with it. The weak forms
+// — assertTrue, assertNotNull, XCTAssertTrue — are deliberately absent:
+// they state no expected value, so their arrival in place of one of these
+// is a weakening, which is a finding of its own.
 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!",
+    // The bare comparison form. `assert add(1, 2) == 3` is how pytest is
+    // actually written, and Rust's `assert!(a == b)` and Elixir's
+    // `assert f(x) == 3` follow it; none of them name a comparison
+    // function, so a list of function names could never reach them.
+    // Equality only. `assert!(x != 0)` names no expected value — it is the
+    // weaker claim you arrive at by giving one up, and counting it as
+    // specific would make the downgrade from `assert_eq!(x, 5)` invisible to
+    // the weakening check.
+    "\\bassert\\s+[^\\n]*(?:===|==)(?!=)",
+    "\\bassert!\\s*\\([^\\n]*==(?!=)",
     "\\bt\\.(?:Errorf|Fatalf)\\s*\\(",
     "\\brequire\\.(?:Equal|NotEqual|Len|Contains|Error|NoError)\\s*\\(",
+    // Python unittest, stated rather than inherited from the optional dot.
+    "\\bassert(?:Equal|NotEqual|AlmostEqual|NotAlmostEqual|Regex|NotRegex|Raises|In|NotIn|Is|IsNot|ListEqual|DictEqual|SetEqual|TupleEqual|CountEqual|Greater|Less|GreaterEqual|LessEqual)\\s*\\(",
+    // JUnit / TestNG / PHPUnit
+    "\\bassert(?:Equals|NotEquals|Same|NotSame|ArrayEquals|IterableEquals|LinesMatch|Count|StringContainsString|StringEqualsFile|InstanceOf|Contains|Throws)\\s*\\(",
+    "\\bassertThat\\s*\\([\\s\\S]{0,240}?\\)\\s*\\.(?:isEqualTo|isSameAs|contains|containsExactly|hasSize|isCloseTo|matches)\\s*\\(",
+    // Minitest
+    "\\b(?:assert|refute)_(?:equal|includes|match|nil|same|in_delta|in_epsilon|raises|empty|operator|predicate)\\b",
+    // RSpec
+    "\\bexpect\\s*\\([\\s\\S]{0,240}?\\)\\s*\\.(?:to|not_to|to_not)\\s+(?:eq|eql|equal|be|be_within|match|include|contain_exactly|match_array|have_attributes|raise_error|start_with|end_with)\\b",
+    // XCTest
+    "\\bXCTAssert(?:Equal|NotEqual|EqualWithAccuracy|Identical|NotIdentical|GreaterThan|LessThan|GreaterThanOrEqual|LessThanOrEqual|ThrowsError|NoThrow)\\s*\\(",
   ].join("|"),
   "i"
 );
@@ -1203,6 +1231,15 @@ const TEST_LANG_BY_EXT = new Map([
   [".py", "python"], [".pyi", "python"],
   [".go", "go"],
   [".rs", "rust"],
+  // Approximations, chosen for comment and continuation syntax rather than
+  // for kinship: the C-like family reads correctly under the `js` scanner,
+  // and Ruby under the `python` one because both end a comment at `#` and a
+  // statement at the newline. Naming them beats falling through to `js` by
+  // default, which is how a `#` comment came to be read as code.
+  [".java", "js"], [".kt", "js"], [".kts", "js"], [".scala", "js"], [".groovy", "js"],
+  [".swift", "js"], [".cs", "js"], [".php", "js"], [".c", "js"], [".cc", "js"],
+  [".cpp", "js"], [".h", "js"], [".hpp", "js"], [".m", "js"], [".sol", "js"],
+  [".rb", "python"],
 ]);
 
 function langForTestFile(file) {
@@ -1540,6 +1577,21 @@ function stripComments(text, lang) {
 const CONTINUATION_START = /^[)\],.]/;
 const CONTINUATION_OP_START = /^[+\-*/%<>=&|^:]/;
 
+// A comment is not a continuation, however much it looks like one.
+//
+// `//` begins with a division sign and `--` with a minus, so both matched
+// CONTINUATION_OP_START and folded the following comment line into the
+// statement above it. The cost was a false accusation on a virtuous act:
+// adding an assertion next to a `// ...` line made the new assertion absorb
+// the comment, stop matching its unchanged twin, and get reported as a
+// rewritten expectation. Python was unaffected only because `#` is not an
+// operator — which is why the same fixture passed in pytest and failed in
+// Jest, and why it survived every suite written against the pytest layout.
+//
+// A comment inside an open delimiter still joins: `cur.delta > 0` decides
+// that before this test is ever reached.
+const COMMENT_LINE_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.
@@ -1578,14 +1630,15 @@ function assembleStatements(sliceLines, lang) {
 
   for (const L of sliceLines) {
     const trimmed = L.text.replace(/^\s+/, "");
+    const startsComment = COMMENT_LINE_START.test(trimmed);
     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));
+        (!startsComment &&
+          (CONTINUATION_START.test(trimmed) || CONTINUATION_OP_START.test(trimmed))));
 
     if (
       joins &&
@@ -1648,7 +1701,17 @@ function splitAssertionArgs(clean, lang) {
   const m = SPECIFIC_ASSERTION.exec(clean);
   if (!m) return null;
 
-  let i = m.index + m[0].length; // just past the opening paren
+  // Not every branch of SPECIFIC_ASSERTION ends at an opening paren:
+  // `assert_eq!`, `assert_equal` and RSpec's `.to eq` all match a bare name.
+  // Starting the walk one character early made every argument boundary wrong,
+  // so a reworded message read as a rewritten value.
+  let i = m.index + m[0].length;
+  if (clean[i - 1] !== "(") {
+    let j = i;
+    while (j < clean.length && /\s/.test(clean[j])) j++;
+    if (clean[j] !== "(") return null;
+    i = j + 1;
+  }
   let depth = 1;
   let quote = null;
   let triple = false;
@@ -1740,7 +1803,45 @@ function messageArgIndices(args) {
  * every time somebody improved the wording of a failure. Firing on that is
  * how an operator learns to pass the override without reading it.
  */
+/**
+ * Split a statement at a trailing `, "message"` written outside the call.
+ *
+ * RSpec puts the message there — `expect(x).to eq(3), "explain"` — and so do
+ * Ruby and Elixir assertions generally. An argument-position check can never
+ * see it, so rewording one read as a rewritten expectation.
+ */
+function splitTrailingMessage(clean) {
+  let depth = 0;
+  let quote = null;
+  let lastComma = -1;
+  for (let i = 0; i < clean.length; i++) {
+    const c = clean[i];
+    if (quote !== null) {
+      if (c === "\\") { i += 1; continue; }
+      if (c === quote) quote = null;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") { quote = c; continue; }
+    if (c === "(" || c === "[" || c === "{") depth++;
+    else if (c === ")" || c === "]" || c === "}") depth--;
+    else if (c === "," && depth === 0) lastComma = i;
+  }
+  if (lastComma === -1) return { head: clean, msg: null };
+  const tail = clean.slice(lastComma + 1).trim();
+  if (!isPureStringLiteral(tail)) return { head: clean, msg: null };
+  return { head: clean.slice(0, lastComma), msg: tail };
+}
+
 function differsOnlyInMessage(cleanRemoved, cleanAdded, lang) {
+  const ta = splitTrailingMessage(cleanRemoved);
+  const tb = splitTrailingMessage(cleanAdded);
+  if (
+    (ta.msg !== null || tb.msg !== null) &&
+    ta.head.replace(/\s+/g, "") === tb.head.replace(/\s+/g, "")
+  ) {
+    return true;
+  }
+
   const a = splitAssertionArgs(cleanRemoved, lang);
   const b = splitAssertionArgs(cleanAdded, lang);
   if (!a || !b || a.length !== b.length || a.length === 0) return false;
@@ -1988,7 +2089,9 @@ export function resolveAllowedTamperKinds(options = {}) {
  * @param {string} diffOrText - Unified git diff
  * @param {Object} [options]
  * @param {boolean} [options.allowTestModifications=false]
- * @returns {{ ok: boolean, violations: Array<object>, inputsSeen: number, status: "PASS"|"FAIL"|"NOT_APPLICABLE" }}
+ * @returns {{ ok: boolean, violations: Array<object>, inputsSeen: number, filesSeen: number,
+ *            assertionsSeen: number, unreadable: Array<{file: string, count: number, samples: string[]}>,
+ *            status: "PASS"|"FAIL"|"UNREADABLE"|"NOT_APPLICABLE" }}
  *   `status` distinguishes "checked and clean" from "nothing was checked";
  *   `ok: true` alone cannot, and that ambiguity is the defect class this
  *   field exists to make visible.
@@ -2024,9 +2127,24 @@ export function checkTestTampering(diffOrText = "", options = {}) {
     { pattern: /#\[ignore\]/i, desc: "Injected Rust test ignore attribute (#[ignore])" },
     { pattern: /\/\/\s*@ts-ignore/i, desc: "Injected TypeScript ignore comment (// @ts-ignore)" },
     { pattern: /\/\/\s*@ts-nocheck/i, desc: "Injected TypeScript nocheck directive (// @ts-nocheck)" },
+    // A suite that never runs cannot fail, and `@Disabled` is exactly as
+    // effective at arranging that as `it.skip` is.
+    { pattern: /@Disabled\b/, desc: "Injected JUnit 5 disable annotation (@Disabled)" },
+    { pattern: /@Ignore\b/, desc: "Injected JUnit 4 / TestNG ignore annotation (@Ignore)" },
+    { pattern: /@Test\s*\([^)]*enabled\s*=\s*false/i, desc: "Injected TestNG disabled test (enabled = false)" },
+    { pattern: /@unittest\.skip/i, desc: "Injected unittest skip decorator (@unittest.skip)" },
+    { pattern: /\bmarkTest(?:Skipped|Incomplete)\s*\(/i, desc: "Injected PHPUnit skip (markTestSkipped())" },
+    { pattern: /\bXCTSkip(?:If|Unless|IfNot)?\s*\(/, desc: "Injected XCTest skip (XCTSkip())" },
+    { pattern: /\b(?:xit|xdescribe|xcontext|xspecify)\b\s*["\x27]/i, desc: "Injected RSpec disabled example (xit)" },
+    { pattern: /,\s*skip:\s*(?:true|["\x27])/i, desc: "Injected RSpec skip metadata (skip:)" },
+    { pattern: /^\s*(?:skip|pending)\s*(?:["\x27(]|$)/i, desc: "Injected Minitest/RSpec skip statement" },
   ];
 
-  const COMMENTED_ASSERTION = /^\+\s*(?:\/\/|\/\*)\s*(?:expect\(|assert\.|assert\(|t\.expect|t\.assert)/i;
+  // `#` and `--` belong here for the same reason the dialects belong in
+  // ASSERTION_PATTERN: a Ruby or Python assertion commented out is exactly
+  // as gone as a JavaScript one, and was previously not looked for.
+  const COMMENTED_ASSERTION =
+    /^\+\s*(?:\/\/|\/\*|#|--)\s*(?:expect\s*\(|assert(?!ion|ing|ed\b|s\b)[a-zA-Z0-9_$]*\s*[.(]|assert\s|refute_|XCTAssert|t\.expect|t\.assert)/i;
 
   const VACUOUS_ASSERTIONS = [
     { pattern: /\bassert(?:\.ok)?\s*\(\s*true\s*(?:,[^)]*)?\)/i, desc: "Vacuous truth assertion (assert.ok(true))" },
@@ -2037,11 +2155,44 @@ export function checkTestTampering(diffOrText = "", options = {}) {
     { pattern: /\bexpect\s*\(\s*false\s*\)\s*\.toBeFalsy\s*\(/i, desc: "Vacuous falsity expectation (expect(false).toBeFalsy())" },
     { pattern: /\bassert\.(?:isTrue|isOk)\s*\(\s*true\s*(?:,[^)]*)?\)/i, desc: "Vacuous truth assertion (assert.isTrue(true))" },
     { pattern: /\bassert\.(?:isFalse|isNotOk)\s*\(\s*false\s*(?:,[^)]*)?\)/i, desc: "Vacuous falsity assertion (assert.isFalse(false))" },
+    { pattern: /\b(?:XCT)?assertTrue\s*\(\s*true\s*[,)]/i, desc: "Vacuous truth assertion (assertTrue(true))" },
+    { pattern: /\b(?:XCT)?assertFalse\s*\(\s*false\s*[,)]/i, desc: "Vacuous falsity assertion (assertFalse(false))" },
+    { pattern: /\b(?:assertEquals|assertSame|XCTAssertEqual)\s*\(\s*([^,]+?)\s*,\s*\1\s*[,)]/i, desc: "Vacuous identity assertion (assertEquals(X, X))" },
+    { pattern: /\bassert_equal\s*\(?\s*([^,]+?)\s*,\s*\1\s*\)?\s*$/i, desc: "Vacuous identity assertion (assert_equal X, X)" },
+    { pattern: /\bexpect\s*\(\s*true\s*\)\s*\.to\s+be(?:\s+true)?\b/i, desc: "Vacuous truth expectation (expect(true).to be true)" },
   ];
 
-  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;
+  // Broad on purpose: this is the denominator, not the verdict. A word
+  // boundary immediately after `assert` never falls in `assertEquals`,
+  // `assert_equal` or `XCTAssertEqual`, so five ecosystems contributed no
+  // assertions to count at all and a gutted JUnit suite was arithmetically
+  // indistinguishable from an untouched one. The lookahead keeps prose and
+  // identifiers — `assertion`, `asserts`, `asserted` — out of the count.
+  const ASSERTION_PATTERN =
+    /(?:\b(?:assert(?!ion|ing|ed\b|s\b)[a-zA-Z0-9_$]*(?:\.[a-zA-Z0-9_$]+)?|refute[a-zA-Z0-9_$]*|XCTAssert[a-zA-Z0-9_$]*|XCTFail|expect|t\.(?:assert|expect|is|equal|true|false|Errorf|Fatalf)|require\.[a-zA-Z0-9_$]+)\b|assert!|assert_eq!|assert_ne!)/i;
+  // The loose net. Not a verdict and never a block — its only job is to
+  // notice that a line was plainly an assertion in *some* dialect that
+  // ASSERTION_PATTERN did not recognise. Without it, adding the seventh
+  // ecosystem is indistinguishable from having covered it all along: the
+  // guard returns the same clean PASS either way. This is the denominator
+  // for the denominator.
+  // Deliberately not call-shaped. Haskell's `x `shouldBe` 3` is an
+  // assertion with no parentheses anywhere near it, and a net that only
+  // catches `name(` reports the same confident PASS on it as on a clean
+  // Node suite. `require` and `check` are absent on purpose: in a
+  // CommonJS test file `require("./calc")` is an import, not a claim.
+  const ASSERTION_SHAPED =
+    /\b(?:assert(?!ion|ing|ed\b|s\b)|expect(?!ed\b|ation)|refute)[a-zA-Z0-9_$]*\b|`\s*should[a-zA-Z0-9_$]*\s*`|\b(?:should|must|verify|ensure|confirm)[a-zA-Z0-9_$]*\s*[(!]|\.\s*(?:should|to|to_not|not_to|must)\b|\bBOOST_[A-Z_]+\s*\(|\b[A-Z]+_(?:EQ|NE|TRUE|FALSE|THAT)\s*\(/;
   const isCommentLine = (str) => /^\s*(?:\/\/|\/\*|\*|#|--|;)/.test(str);
 
+  /** Book-keeping only: what this run looked at, before deciding anything. */
+  const countExamined = (stats, text) => {
+    if (!text.trim() || isCommentLine(text)) return;
+    stats.examined++;
+    if (ASSERTION_PATTERN.test(text)) stats.recognised++;
+    else if (ASSERTION_SHAPED.test(text) && stats.unreadable.length < 5) stats.unreadable.push(text.trim().slice(0, 120));
+  };
+
   const fileAssertions = new Map();
   let pendingHunk = false;
 
@@ -2077,7 +2228,7 @@ export function checkTestTampering(diffOrText = "", options = {}) {
     }
 
     if (!fileAssertions.has(currentFile)) {
-      fileAssertions.set(currentFile, { removed: [], added: 0, addedTexts: [], removedSpecific: [], addedSpecific: 0, hunks: [] });
+      fileAssertions.set(currentFile, { removed: [], added: 0, addedTexts: [], removedSpecific: [], addedSpecific: 0, hunks: [], examined: 0, recognised: 0, unreadable: [] });
     }
     const fileStats = fileAssertions.get(currentFile);
     if (pendingHunk) {
@@ -2089,6 +2240,7 @@ export function checkTestTampering(diffOrText = "", options = {}) {
     if (line.startsWith("-") && !line.startsWith("---")) {
       const deletedText = line.slice(1);
       if (hunk) hunk.lines.push({ kind: "-", text: deletedText, oldNo: currentOldLineNo, newNo: null });
+      countExamined(fileStats, deletedText);
       if (!isCommentLine(deletedText) && ASSERTION_PATTERN.test(deletedText)) {
         fileStats.removed.push({ line: currentOldLineNo, text: deletedText });
         if (isSpecificAssertion(deletedText)) {
@@ -2099,6 +2251,7 @@ export function checkTestTampering(diffOrText = "", options = {}) {
     } else if (line.startsWith("+") && !line.startsWith("+++")) {
       const addedText = line.slice(1);
       if (hunk) hunk.lines.push({ kind: "+", text: addedText, oldNo: null, newNo: currentNewLineNo });
+      countExamined(fileStats, addedText);
       let isVacuous = false;
 
       // Check skip injections
@@ -2225,17 +2378,44 @@ export function checkTestTampering(diffOrText = "", options = {}) {
   // `ok: true` from a guard that looked at everything and approved it. That
   // ambiguity is how a substring bug in the file classifier switched this
   // entire guard off for the standard pytest, Rust and RSpec layouts while
-  // every signal stayed green. A verdict without a denominator is not a
-  // verdict, so `inputsSeen` reports the number of test files this run
-  // actually reasoned about, and `status` distinguishes "nothing to check"
-  // from "checked and clean".
-  const inputsSeen = fileAssertions.size;
+  // every signal stayed green.
+  //
+  // Counting *files* was not enough. A JUnit diff that rewrote an expected
+  // value produced `inputsSeen: 1` and a clean PASS while not one assertion
+  // in it had been recognised — the same ambiguity, one level down, inside
+  // the mechanism built to remove it. So the denominator is now the thing
+  // the rules actually consume: lines examined, and of those, assertions
+  // understood. `UNREADABLE` is the state that has no business being silent
+  // — assertion-shaped lines were present and none of them parsed, which
+  // means this repository speaks a dialect the guard does not.
+  let examined = 0;
+  let assertionsSeen = 0;
+  const unreadable = [];
+  for (const [file, stats] of fileAssertions.entries()) {
+    examined += stats.examined;
+    assertionsSeen += stats.recognised;
+    if (stats.unreadable.length > 0) {
+      unreadable.push({ file, count: stats.unreadable.length, samples: stats.unreadable.slice(0, 3) });
+    }
+  }
+
+  const status =
+    reported.length > 0
+      ? "FAIL"
+      : assertionsSeen === 0 && unreadable.length > 0
+        ? "UNREADABLE"
+        : examined > 0
+          ? "PASS"
+          : "NOT_APPLICABLE";
 
   return {
     ok: reported.length === 0,
     violations: reported,
-    inputsSeen,
-    status: reported.length > 0 ? "FAIL" : inputsSeen > 0 ? "PASS" : "NOT_APPLICABLE",
+    inputsSeen: examined,
+    filesSeen: fileAssertions.size,
+    assertionsSeen,
+    unreadable,
+    status,
   };
 }