jules-orchestrator-kit 0.67.0 → 0.69.0

package/src/guard-policy.mjs

@@ -68,6 +68,62 @@ export const TEST_PATH_CASES = [
  * the guard the layout the implementation was written from.
  */
 export const TAMPER_CANARIES = [
+  // Argument order is not a detail. JUnit and PHPUnit document
+  // `assertEquals(expected, actual)`, and Python's containment helpers take
+  // the expected member first — all of which the guard used to read as "a
+  // human message was reworded" and dismiss. Each of these was a silent PASS.
+  {
+    id: "expectation/junit-expected-first",
+    file: "src/test/java/CalcTest.java",
+    removed: ['        assertEquals("Hello World", out);'],
+    added: ['        assertEquals("Hello Tampered", out);'],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+  {
+    id: "expectation/phpunit-expected-first",
+    file: "tests/CalcTest.php",
+    removed: ['        $this->assertSame("Hello World", $out);'],
+    added: ['        $this->assertSame("Hello Tampered", $out);'],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+  {
+    id: "expectation/unittest-assert-in",
+    file: "tests/test_cli.py",
+    removed: ['        self.assertIn("Hello World", result.output)'],
+    added: ['        self.assertIn("Hello Tampered", result.output)'],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+  {
+    id: "expectation/unittest-assert-not-in",
+    file: "tests/test_cli.py",
+    removed: ['        self.assertNotIn("error", result.output)'],
+    added: ['        self.assertNotIn("zzz", result.output)'],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+  // A regex literal is an expected value. It never blanked, so the rewritten
+  // pattern never met its original in a shape bucket and the swap was
+  // reported as neither a change nor a loss.
+  {
+    id: "expectation/jest-to-match-regex",
+    file: "test/cli.test.js",
+    removed: ["  expect(out).toMatch(/Hello World/);"],
+    added: ["  expect(out).toMatch(/Hello Tampered/);"],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+  {
+    id: "expectation/jest-to-throw-regex",
+    file: "test/cli.test.js",
+    removed: ["  expect(fn).toThrow(/permission denied/);"],
+    added: ["  expect(fn).toThrow(/x/);"],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+  {
+    id: "expectation/rspec-match-regex",
+    file: "spec/cli_spec.rb",
+    removed: ["    expect(out).to match(/Hello World/)"],
+    added: ["    expect(out).to match(/Hello Tampered/)"],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
   {
     id: "skip-injection/node",
     file: "test/calc.test.js",
@@ -235,6 +291,42 @@ export const TAMPER_CANARIES = [
     added: ["        $this->markTestSkipped(\"later\");"],
     expect: "TEST_SKIP_INJECTION",
   },
+  // Dialects a second cold-start trial found silent. chai's `.to.equal(` is a
+  // dot chain where RSpec's is a space, so the RSpec branch never reached it;
+  // node-tap's assertions hang off whatever the sub-test callback named its
+  // argument, which is `ct` as often as `t`.
+  {
+    id: "weakening/chai",
+    file: "packages/core/test/signal.test.tsx",
+    context: "// signals",
+    removed: ["    expect(s.value).to.equal(v);"],
+    added: ["    expect(s.value).toBeDefined();"],
+    expect: "ASSERTION_WEAKENED",
+  },
+  {
+    id: "expectation/chai",
+    file: "test/signal.test.js",
+    context: "// signals",
+    removed: ["    expect(s.value).to.equal(3);"],
+    added: ["    expect(s.value).to.equal(-1);"],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+  {
+    id: "expectation/node-tap",
+    file: "tests/test-config.js",
+    context: "// config",
+    removed: ["    ct.equal(process.env.BASIC, 'basic')"],
+    added: ["    ct.equal(process.env.BASIC, 'BROKEN_OVERRIDE')"],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+  {
+    id: "skip-injection/node-tap-options",
+    file: "tests/test-populate.js",
+    context: "// populate",
+    removed: ["t.test('does not write over keys', ct => {"],
+    added: ["t.test('does not write over keys', { skip: true }, ct => {"],
+    expect: "TEST_SKIP_INJECTION",
+  },
   // Skipping from inside the test body, which is how every one of these
   // ecosystems actually does it. The decorator and annotation forms were
   // covered; the standard library's own method was not, so a test could be
@@ -362,6 +454,41 @@ export const SCOPE_CANARIES = [
  * from never showed it.
  */
 export const INNOCENT_EDITS = [
+  // Renaming a test is one of the most ordinary edits there is. On the
+  // one-line form the name blanked to the same shape as its replacement, the
+  // two paired, and the pair was reported as a rewritten expectation.
+  {
+    id: "rename-test-oneline/node",
+    file: "test/calc.test.js",
+    context: "// arithmetic",
+    removed: ['test("adds", () => { assert.strictEqual(add(2, 3), 5); });'],
+    added: ['test("adds positives", () => { assert.strictEqual(add(2, 3), 5); });'],
+    why: "the test name is prose about the test, not a value it asserts",
+  },
+  {
+    id: "rename-test-oneline/jest",
+    file: "test/calc.spec.js",
+    context: "// arithmetic",
+    removed: ['it("adds", () => { expect(add(2, 3)).toBe(5); });'],
+    added: ['it("adds two positives", () => { expect(add(2, 3)).toBe(5); });'],
+    why: "same rename, the dialect a new user is most likely to be in",
+  },
+  {
+    id: "rename-test-oneline/tap",
+    file: "test/calc.test.js",
+    context: "// arithmetic",
+    removed: ['t.test("adds", (ct) => { ct.equal(add(2, 3), 5); ct.end(); });'],
+    added: ['t.test("adds positives", (ct) => { ct.equal(add(2, 3), 5); ct.end(); });'],
+    why: "the receiver is a sub-test callback argument, not an assertion subject",
+  },
+  {
+    id: "reword-junit-message-first",
+    file: "src/test/java/CalcTest.java",
+    context: "// arithmetic",
+    removed: ['        assertEquals("why", expected, out);'],
+    added: ['        assertEquals("why this matters", expected, out);'],
+    why: "JUnit 4 puts the message first — rewording it changes no expectation",
+  },
   {
     id: "add-assertion-beside-comment/node",
     file: "test/calc.test.js",
@@ -443,6 +570,15 @@ export const INNOCENT_EDITS = [
     added: ["    3, // the correct answer", "  );"],
     why: "line comments were never stripped — `copyCode(i)` left `pending` at the comment and the copy after the loop put it back",
   },
+  {
+    id: "reformat-assertion-multiline/python",
+    file: "tests/test_encoding.py",
+    context: "# encoding",
+    lead: ["def test_int_bytes(value, expect):", "    enc = int_to_bytes(value)"],
+    removed: ["    assert enc == expect"],
+    added: ["    assert (", "        enc == expect", "    )"],
+    why: "Black and Ruff do this; `assert (` alone on a line names no value, so a line-level count read a reformat as a weakening",
+  },
   {
     id: "rename-helper/node",
     file: "test/calc.test.js",

package/src/ops/test-collection.mjs

@@ -50,6 +50,27 @@ const COUNT_PATTERNS = [
   { name: "dotnet", re: /\bTotal(?:\s+tests)?:\s*(\d+)/i },
   // swift test / XCTest — "Executed 12 tests"
   { name: "xctest", re: /\bExecuted\s+(\d+)\s+tests?/i },
+  // Every runner below states a count the gate used to read as silence, and
+  // silence is what makes `pnpm -r test` on a workspace with no package-level
+  // test script indistinguishable from a suite that ran. The floor stays
+  // one-sided — an unrecognised runner still passes — so widening the list
+  // only ever converts an "I could not tell" into an answer.
+  // Python unittest — "Ran 12 tests in 0.003s"
+  { name: "unittest", re: /^Ran\s+(\d+)\s+tests?\s+in\b/m },
+  // GoogleTest — "[==========] 12 tests from 3 test suites ran."
+  { name: "gtest", re: /\[=+\]\s+(\d+)\s+tests?\s+from\b/ },
+  // Catch2 — "test cases: 12 | 12 passed"
+  { name: "catch2", re: /\btest cases:\s*(\d+)/i },
+  // deno test — "ok | 12 passed | 0 failed"
+  { name: "deno", re: /\|\s*(\d+)\s+passed\s*\|/ },
+  // bun test — "12 pass"
+  { name: "bun", re: /^\s*(\d+)\s+pass\s*$/m },
+  // ava — "12 tests passed"
+  { name: "ava", re: /^\s*(\d+)\s+tests?\s+passed\s*$/m },
+  // A bare TAP plan, which is how tape, bats and the TAP producers that
+  // print no summary state their count. Last of the count patterns: node:test
+  // emits TAP too, and its own line above is the more specific reading.
+  { name: "tap", re: /^1\.\.(\d+)\s*$/m },
 ];
 
 /** Per-test lines, which `go test` only prints under -v. */

package/src/security.mjs

@@ -1191,6 +1191,15 @@ const SPECIFIC_ASSERTION = new RegExp(
     "\\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*\\(",
+    // chai — a dot chain, where RSpec's is a space. `expect(x).to.equal(3)`
+    // never reached the RSpec branch, so swapping it for `.toBeDefined()`
+    // lost no *specific* assertion and the weakening check stayed quiet.
+    "\\bexpect\\s*\\([\\s\\S]{0,240}?\\)\\s*\\.to(?:\\.[a-z]+)*\\.(?:equal|equals|eql|eqls|closeTo|match|include|contain|members|throw|string|lengthOf|above|below|least|most|within)\\s*\\(",
+    // node-tap and its relatives, where the assertion hangs off whatever the
+    // sub-test callback named its argument — `ct` as often as `t`. Bounded to
+    // a short receiver so `results.match(...)` on an ordinary object is not
+    // mistaken for an assertion; a heuristic, and stated as one.
+    "\\b[a-z_$][a-z0-9_$]{0,2}\\.(?:equal|equals|same|strictSame|deepEqual|notEqual|notSame|match|hasStrict|type|throws|rejects)\\s*\\(",
   ].join("|"),
   "i"
 );
@@ -1210,6 +1219,21 @@ const isSpecificAssertion = (str) => SPECIFIC_ASSERTION.test(str);
 const blankLiterals = (str) =>
   str
     .replace(/(['"`])(?:\\.|(?!\1)[^\\])*\1/g, "\u0000S")
+    // A regex literal is an expected value like any other. Without this,
+    // `toMatch(/Hello World/)` and `toMatch(/Hello Tampered/)` normalized to
+    // two different shapes, never met in a bucket, and the rewrite was
+    // reported as neither a change nor a loss — one specific assertion out,
+    // one in, and silence. Runs after the string pass so a `/` inside a
+    // string is already gone, and before the number pass so a pattern
+    // containing digits collapses whole.
+    //
+    // The lookbehind is what separates a regex from a division: an operand
+    // never precedes `/` here, only an opening paren, a comma, or an
+    // operator, which is where a test's expected pattern actually sits.
+    .replace(
+      /(?<=[(,=:[!&|?{;]\s{0,8})\/(?![*/])(?:\\.|\[(?:\\.|[^\]\\\n])*\]|[^/\\\n])+\/[dgimsuvy]*/g,
+      "\u0000R"
+    )
     // The sign belongs to the literal: without it `3` and `-1` normalized to
     // different shapes and the rewritten expectation was never paired.
     .replace(
@@ -1793,8 +1817,22 @@ function isPureStringLiteral(arg) {
  */
 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);
+  const lastIsMessage = args.length >= 3 && isPureStringLiteral(args[args.length - 1]);
+  if (lastIsMessage) idx.add(args.length - 1);
+
+  // JUnit 4 is the one common dialect that puts the message *first*:
+  // `assertEquals("why this matters", expected, actual)`. It is also
+  // distinguishable, because its trailing argument is the actual value rather
+  // than prose — so a call that already carries a trailing message is not
+  // that shape, whatever its first argument looks like.
+  //
+  // Reading argument 0 as prose whenever it happened to be a string is what
+  // made a whole family of assertions invisible: `assertEquals(expected,
+  // actual)` — JUnit's and PHPUnit's own two-argument order — along with
+  // Python's `assertIn(member, container)` and `assertNotIn`. A rewritten
+  // expectation in any of them was dismissed as a reworded message, and the
+  // guard reported PASS on a check it had not performed.
+  if (!lastIsMessage && args.length >= 3 && isPureStringLiteral(args[0])) idx.add(0);
   return idx;
 }
 
@@ -1837,6 +1875,63 @@ function splitTrailingMessage(clean) {
   return { head: clean.slice(0, lastComma), msg: tail };
 }
 
+// A test declaration whose first argument is the test's name. The name is
+// prose about the test, not a value the test asserts — `test("adds", ...)`
+// renamed to `test("adds positives", ...)` is the rename the diff says it is.
+const TEST_DECL_CALL =
+  /\b(?:it|test|describe|context|suite|specify|bench|scenario)\s*\(|\b[a-z_$][\w$]{0,2}\.(?:test|Run|describe)\s*\(/;
+
+/**
+ * Replace the name argument of a test declaration with a placeholder.
+ *
+ * @param {string} clean - comment-stripped statement text
+ * @returns {string|null} the text with the name blanked, or null when the
+ *   statement is not a test declaration with a literal name.
+ */
+function blankTestName(clean) {
+  const m = TEST_DECL_CALL.exec(clean);
+  if (!m) return null;
+
+  let i = m.index + m[0].length;
+  while (i < clean.length && /\s/.test(clean[i])) i++;
+  const quote = clean[i];
+  if (quote !== '"' && quote !== "'" && quote !== "`") return null;
+
+  let j = i + 1;
+  while (j < clean.length) {
+    if (clean[j] === "\\") { j += 2; continue; }
+    if (clean[j] === quote) break;
+    j += 1;
+  }
+  if (j >= clean.length) return null;
+
+  return clean.slice(0, i) + "\u0000T" + clean.slice(j + 1);
+}
+
+/**
+ * True when the only thing that changed was the test's name.
+ *
+ * A one-line `test("adds", () => { assert.strictEqual(add(2, 3), 5); });`
+ * blanks to the same shape as its renamed copy, so the two pair — and the
+ * pair was then reported as a rewritten expectation, quoting the whole line
+ * back at an author who had renamed a test and nothing else. Renaming a test
+ * is one of the most ordinary edits there is, and a gate that calls it
+ * tampering is a gate that gets switched off.
+ *
+ * The multi-line form was never affected: NON_JOINING_CALL already keeps a
+ * test name from joining to the assertion below it. This is the same rule for
+ * the statements that fit on one line.
+ *
+ * A rename that also moves the expectation still differs after the name is
+ * blanked, so it is still reported.
+ */
+function differsOnlyInTestName(cleanRemoved, cleanAdded) {
+  const a = blankTestName(cleanRemoved);
+  const b = blankTestName(cleanAdded);
+  if (a === null || b === null) return false;
+  return a.replace(/\s+/g, "") === b.replace(/\s+/g, "");
+}
+
 function differsOnlyInMessage(cleanRemoved, cleanAdded, lang) {
   const ta = splitTrailingMessage(cleanRemoved);
   const tb = splitTrailingMessage(cleanAdded);
@@ -1865,6 +1960,17 @@ function differsOnlyInMessage(cleanRemoved, cleanAdded, lang) {
   return sawDifference;
 }
 
+/**
+ * True when a paired difference is something other than a rewritten
+ * expectation — a reworded message, or a renamed test.
+ */
+function isNonExpectationDifference(cleanRemoved, cleanAdded, lang) {
+  return (
+    differsOnlyInMessage(cleanRemoved, cleanAdded, lang) ||
+    differsOnlyInTestName(cleanRemoved, cleanAdded)
+  );
+}
+
 /**
  * Pair rewritten expectations across the removed and added images of every
  * hunk of one file, and report each pair.
@@ -1979,7 +2085,7 @@ function detectExpectationRewrites(file, hunks, stats, violations) {
         pairedOld.add(r);
         pairedNew.add(a);
         if (r.canon === a.canon) continue;
-        if (differsOnlyInMessage(r.clean, a.clean, lang)) continue;
+        if (isNonExpectationDifference(r.clean, a.clean, lang)) continue;
         pairs.push({ r: r.s, a: a.s });
       }
     }
@@ -2009,7 +2115,7 @@ function detectExpectationRewrites(file, hunks, stats, violations) {
         // different assertions that merely resemble each other.
         if (!same(0)) continue;
         if (ra.every((_, i) => same(i))) continue;
-        if (differsOnlyInMessage(r.clean, a.clean, lang)) continue;
+        if (isNonExpectationDifference(r.clean, a.clean, lang)) continue;
         pairs.push({ r: r.s, a: a.s });
         pairedOld.add(r);
         pairedNew.add(a);
@@ -2030,7 +2136,7 @@ function detectExpectationRewrites(file, hunks, stats, violations) {
         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)) {
+          if (clr.replace(/\s+/g, "") !== cla.replace(/\s+/g, "") && !isNonExpectationDifference(clr, cla, lang)) {
             pairs.push({ r, a });
           }
         }
@@ -2194,6 +2300,10 @@ export function checkTestTampering(diffOrText = "", options = {}) {
     { 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:)" },
+    // node-tap, node:test and ava pass it as a property of an options object,
+    // so the comma sits before the brace and not before the key.
+    { pattern: /\{[^}]*\bskip\s*:\s*true/i, desc: "Injected skip option ({ skip: true })" },
+    { pattern: /\{[^}]*\btodo\s*:\s*true/i, desc: "Injected todo option ({ todo: true })" },
     { pattern: /^\s*(?:skip|pending)\s*(?:["\x27(]|$)/i, desc: "Injected Minitest/RSpec skip statement" },
     // Skipping from inside the body, which is how these ecosystems actually
     // do it. Only the decorator and annotation forms were covered, so a test
@@ -2237,7 +2347,7 @@ export function checkTestTampering(diffOrText = "", options = {}) {
   // 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;
+    /(?:\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|[a-z_$][a-z0-9_$]{0,2}\.(?:equal|equals|same|strictSame|deepEqual|notEqual|notSame|match|hasStrict|type|throws|rejects|ok|notOk)|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
@@ -2380,6 +2490,59 @@ export function checkTestTampering(diffOrText = "", options = {}) {
     }
   }
 
+  // An assertion is a statement, not a line.
+  //
+  // Counting `+`/`-` lines missed the commonest shape in every language with
+  // multi-line calls: `self.assertEqual(` sits on an unchanged context line
+  // and only its argument lines are edited. Nothing among the changed lines
+  // matched an assertion pattern, nothing looked assertion-shaped either, so
+  // the guard reported `assertionsSeen: 0` and — because no line looked
+  // suspicious — a clean PASS. A five-element expected list rewritten to one
+  // element to match broken output sailed through five green phases.
+  //
+  // The statement machinery that already exists for pairing knows better:
+  // it assembles context lines together with changed ones. Ask it.
+  for (const [file, stats] of fileAssertions.entries()) {
+    const lang = langForTestFile(file);
+    let touched = 0;
+    let stmtSpecificRemoved = 0;
+    let stmtSpecificAdded = 0;
+    for (const hunk of stats.hunks) {
+      const oldSlice = [];
+      const newSlice = [];
+      for (const L of hunk.lines) {
+        if (L.kind !== "+") oldSlice.push(L);
+        if (L.kind !== "-") newSlice.push(L);
+      }
+      // Specific assertions are counted per side, on the reassembled
+      // statement. The weakening check was still line-based: `assert (` alone
+      // on a line names no value, so Black or Ruff splitting one assertion
+      // across three lines removed one specific assertion and added none, and
+      // a reformat was reported as CRITICAL tampering. Collapsing the joined
+      // statement is what lets the bare-comparison form be recognised at all
+      // — its pattern cannot cross a newline.
+      const sides = [
+        { stmts: assembleStatements(oldSlice, lang), kind: "-" },
+        { stmts: assembleStatements(newSlice, lang), kind: "+" },
+      ];
+      for (const { stmts, kind } of sides) {
+        for (const st of stmts) {
+          const changed = kind === "-" ? (st.removedLines?.length || 0) > 0 : (st.addedLines?.length || 0) > 0;
+          if (!changed) continue;
+          const clean = stripComments(st.text, lang);
+          if (ASSERTION_PATTERN.test(clean)) touched++;
+          if (isSpecificAssertion(collapseWhitespace(clean))) {
+            if (kind === "-") stmtSpecificRemoved++;
+            else stmtSpecificAdded++;
+          }
+        }
+      }
+    }
+    stats.statementAssertions = touched;
+    stats.stmtSpecificRemoved = stmtSpecificRemoved;
+    stats.stmtSpecificAdded = stmtSpecificAdded;
+  }
+
   // Assertions added in some *other* file of this same diff.
   //
   // Tracking is strictly per file, so moving a test from one file to another
@@ -2446,7 +2609,12 @@ export function checkTestTampering(diffOrText = "", options = {}) {
     const alreadyReportedSpecific = stats.removed
       .slice(stats.added)
       .filter((item) => isSpecificAssertion(item.text)).length;
-    const specificLost = Math.max(0, stats.removedSpecific.length - stats.addedSpecific);
+    // Believe whichever unit saw more arrive. A statement is the honest unit,
+    // but the line count still carries cases the statement scanner cannot
+    // assemble, so the loss is only what *both* agree was lost.
+    const lineLost = Math.max(0, stats.removedSpecific.length - stats.addedSpecific);
+    const stmtLost = Math.max(0, (stats.stmtSpecificRemoved || 0) - (stats.stmtSpecificAdded || 0));
+    const specificLost = Math.min(lineLost, stmtLost);
     const weakenedCount = Math.max(0, specificLost - alreadyReportedSpecific);
 
     if (weakenedCount > 0) {
@@ -2485,38 +2653,6 @@ export function checkTestTampering(diffOrText = "", options = {}) {
   // 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.
-  // An assertion is a statement, not a line.
-  //
-  // Counting `+`/`-` lines missed the commonest shape in every language with
-  // multi-line calls: `self.assertEqual(` sits on an unchanged context line
-  // and only its argument lines are edited. Nothing among the changed lines
-  // matched an assertion pattern, nothing looked assertion-shaped either, so
-  // the guard reported `assertionsSeen: 0` and — because no line looked
-  // suspicious — a clean PASS. A five-element expected list rewritten to one
-  // element to match broken output sailed through five green phases.
-  //
-  // The statement machinery that already exists for pairing knows better:
-  // it assembles context lines together with changed ones. Ask it.
-  for (const [file, stats] of fileAssertions.entries()) {
-    const lang = langForTestFile(file);
-    let touched = 0;
-    for (const hunk of stats.hunks) {
-      const oldSlice = [];
-      const newSlice = [];
-      for (const L of hunk.lines) {
-        if (L.kind !== "+") oldSlice.push(L);
-        if (L.kind !== "-") newSlice.push(L);
-      }
-      for (const stmts of [assembleStatements(oldSlice, lang), assembleStatements(newSlice, lang)]) {
-        for (const st of stmts) {
-          const changed = (st.removedLines?.length || 0) + (st.addedLines?.length || 0) > 0;
-          if (changed && ASSERTION_PATTERN.test(stripComments(st.text, lang))) touched++;
-        }
-      }
-    }
-    stats.statementAssertions = touched;
-  }
-
   let examined = 0;
   let assertionsSeen = 0;
   const unreadable = [];
@@ -2617,24 +2753,41 @@ export function scanDiff(diffTextStr = "", options = {}) {
   // dialect warning into the latter meant it reached nobody. The guard
   // computed `UNREADABLE`, and the operator was shown an unblemished pass.
   // A boundary that is not reported is not a boundary.
+  //
+  // And it blocks, because the previous wording was the defect it described.
+  // Printing "this change was NOT checked for tampering ... it is not an
+  // approval either" and then returning APPROVED (Exit 0) is the exact shape
+  // this project exists to refuse: a verdict from a check that examined
+  // nothing, dressed as a pass. A second cold-start trial walked a tampered
+  // test and broken production code straight through on node-tap, and again
+  // on BATS. `verify.tamperGuard: "warn"` is how a repository whose dialect
+  // is genuinely unsupported opts out — deliberately, and on the record.
+  let unreadableBlocks = false;
   if (tamperingRes.status === "UNREADABLE") {
+    const mode = options.tamperGuard === "warn" || options.allowUnreadableTests === true ? "warn" : "block";
+    unreadableBlocks = mode === "block";
     const where = (tamperingRes.unreadable || []).map((u) => u.file);
     const sample = tamperingRes.unreadable?.[0]?.samples?.[0];
     findings.push({
-      severity: "MEDIUM",
+      severity: unreadableBlocks ? "CRITICAL" : "MEDIUM",
       type: "TEST_DIALECT_UNREADABLE",
       file: where[0] ?? null,
       line: null,
       description:
         `Test Tamper Guard: changed ${tamperingRes.inputsSeen} line(s) in ${tamperingRes.filesSeen} test file(s) ` +
         `and recognised no assertion among them${sample ? ` (e.g. ${JSON.stringify(sample)})` : ""}. ` +
-        `This change was NOT checked for tampering. That is not a failure — an unlisted assertion library is ` +
-        `normal — but it is not an approval either, so it is reported rather than passed silently.`,
+        `This change was NOT checked for tampering${unreadableBlocks ? ", so it cannot be approved" : ""}. ` +
+        (unreadableBlocks
+          ? `If this repository's assertion library is genuinely unsupported, say so once in .agent/config.yml ` +
+            `with verify.tamperGuard: "warn", or allow this run with --allow-unreadable-tests. Reporting the ` +
+            `dialect is more useful than either: the guard covers Node, pytest, Go, Rust, JUnit, RSpec, PHPUnit, ` +
+            `Minitest, XCTest, chai and node-tap.`
+          : `Reported only, because verify.tamperGuard is set to "warn".`),
     });
   }
 
   return {
-    ok: secretsOk && edgeRes.ok && crossPkgRes.ok && tamperingRes.ok,
+    ok: secretsOk && edgeRes.ok && crossPkgRes.ok && tamperingRes.ok && !unreadableBlocks,
     findings,
   };
 }

package/src/stack-detector.mjs

@@ -66,10 +66,20 @@ function makefileHasTestTarget(root) {
  * placeholder by this definition, and correctly so: it exits non-zero, which
  * fails loudly rather than certifying nothing.
  */
+// An interpreter handed an empty program: `node -e ""`, `python3 -c ''`,
+// `sh -c ""`. It reads as a test command at a glance and runs nothing.
+//
+// This does not enumerate every way to write a no-op — nothing can, and the
+// collection floor is what reports the general case, one-sidedly and by
+// design. It closes the spellings that look like work.
+const EMPTY_PROGRAM =
+  /^(?:\S*[/\\])?(?:node|nodejs|deno|bun|python[\d.]*|ruby|perl|php|sh|bash|zsh|dash)(?:\s+-{1,2}[\w-]+)*\s+(?:-e|-c|--eval|--execute)(?:\s*(?:""|''|``))?\s*$/;
+
 export function isPlaceholderTestScript(cmd) {
   if (typeof cmd !== "string") return false;
   const trimmed = cmd.trim();
   if (!trimmed) return true;
+  if (EMPTY_PROGRAM.test(trimmed)) return true;
   // Drop the announcements; what matters is what the shell is left doing.
   const remainder = trimmed
     .split(/&&|;/)
@@ -849,6 +859,36 @@ export function resolveWorkspaceBoundary(changedFiles = [], root = process.cwd()
   };
 }
 
+/**
+ * Does this repository contain any JavaScript for a parse oracle to check?
+ *
+ * A `package.json` is not an answer. A CSS library, an icon set or a font
+ * package has one and no JavaScript at all, and `bootstrap` happily wrote a
+ * `node --test .agent/smoke.test.mjs` config into it — so the very next gate
+ * run died on the generated suite's own assertion, "No JavaScript sources
+ * found to verify". The assertion was right; it just arrived after the config
+ * had been written, which left the user deadlocked by the repair advice.
+ */
+function hasJsSources(root, dir = root, depth = 0) {
+  if (depth > 6) return false;
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch (_) {
+    return false;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue;
+    if (["node_modules", "dist", "build", "coverage", "vendor", "target"].includes(entry.name)) continue;
+    if (entry.isDirectory()) {
+      if (hasJsSources(root, join(dir, entry.name), depth + 1)) return true;
+    } else if (/\.(mjs|cjs|jsx?|tsx?)$/.test(entry.name)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 export function bootstrapZeroTestRepo(root = process.cwd(), options = {}) {
   const detected = detectPolyglotStack(root);
   const configPath = join(root, ".agent", "config.yml");
@@ -898,9 +938,24 @@ export function bootstrapZeroTestRepo(root = process.cwd(), options = {}) {
     testCmd = "go vet ./...";
   } else if (existsSync(join(root, "tsconfig.json"))) {
     testCmd = "npx tsc --noEmit";
-  } else {
+  } else if (hasJsSources(root)) {
     const smokePath = generateSmokeTestScript(root);
     testCmd = `node --test ${smokePath}`;
+  } else {
+    // Refuse rather than write a config whose first run cannot pass. Saying
+    // "I cannot build an oracle here" is a usable answer; deadlocking the
+    // user with one that asserts its own impossibility is not.
+    return {
+      bootstrapped: false,
+      reason: "NO_ORACLE_POSSIBLE",
+      testCmd: "",
+      detail:
+        "This repository has no JavaScript sources to parse-check and no recognised " +
+        "test toolchain, so there is nothing an automatic oracle could verify. Set " +
+        "verify.test in .agent/config.yml to a command that checks this project — a " +
+        "linter, a build, a schema validation — or set verify.required: false to run " +
+        "the scope and secret phases only, deliberately.",
+    };
   }
 
   try {