agent-roast 0.9.0 → 0.10.0

package/README.md

@@ -5,7 +5,7 @@
   <img src="docs/assets/logo.svg" alt="agent-roast" width="380">
 </picture>
 
-<h2>Catch coding shortcuts before they ship</h2>
+<h2>Catch weakened tests and quality gates before they ship</h2>
 
 <p>
   <a href="https://github.com/Nari-Ab/agent-roast/actions/workflows/test.yml"><img src="https://github.com/Nari-Ab/agent-roast/actions/workflows/test.yml/badge.svg" alt="CLI tests"></a>
@@ -17,55 +17,85 @@
 
 </div>
 
-**Did the AI fix the code, or just make the checks pass?**
+**Did this change fix the code, or only make the checks pass?**
 
-Coding agents (and tired humans) often get a red build green by changing the *checks*
-instead of the *code*: deleting the failing assertion, weakening it to `toBeDefined()`,
-removing the test, lowering the coverage threshold, switching off `strict`, or letting
-CI steps fail. A linter reading the new file cannot see that, because nothing in the new
-file looks wrong. `agent-roast review` compares the **before and after** of a change and
-flags exactly these moves. It is offline, runs no project code, and needs only Git.
+A red build can be turned green by changing the *checks* instead of the *code*: loosening or
+deleting the failing assertion, removing the test, lowering the coverage threshold, switching
+off `strict`, or letting a CI step fail. Nothing in the new file looks wrong, so a linter
+cannot see it. `agent-roast review` compares the **before and after** of a change and reports
+exactly these moves. It is offline, runs no project code, and needs only Git. It was built to
+review AI-assisted changes, but it cannot tell who wrote a change, and the measurements below
+show these moves are not specific to AI.
 
 ```bash
 npx agent-roast review --base origin/main        # a pull request
 npx agent-roast --staged                         # what you are about to commit
 ```
 
-| Rule | Fires when | Blocks by default |
+| Rule | Fires when | By default |
 | --- | --- | --- |
-| `assertion-weakened` | a test keeps its name but loses assertions, or an exact check becomes `toBeDefined`/`toBeTruthy`/`assert x` | yes |
-| `guard-weakened` | coverage threshold lowered, `strict`/`noImplicitAny` off, lint rule downgraded, CI step may fail or no longer runs tests, test script cannot fail | yes |
-| `test-removed` | a test (or test file) disappears and no identical body appears elsewhere | no, reported |
-| `expectation-rewritten` | an expected value changed, test inputs did not, and production code changed in the same PR | no, reported |
-| `test-skip`, `test-focus`, `trivial-assert`, `swallowed-error`, `type-escape`, `stub-abandonment` | the classic shortcuts, compared before/after so old debt does not block | skip/focus/trivial: yes |
-
-Renames, moved tests, parametrization, and formatter rewraps (prettier, black) are
-recognized and not reported. Intentional cases can be accepted one by one with an
-expiring, reviewed exception (see below). Policy is read from the base branch, so a PR
-cannot switch the rules off for itself.
+| `assertion-weakened` | an exact check is replaced by a weaker one: `toBe(42)` → `toBeDefined()`, `assert x == 1` → `assert x`, `isinstance(...)` → `is not None` | blocks |
+| `guard-weakened` | coverage threshold lowered, `strict`/`noImplicitAny` off, lint rule downgraded, an existing CI step allowed to fail, a workflow that stops running tests or stops running on push and pull requests, a test script that cannot fail | blocks |
+| `assertion-removed` | a test keeps its name but loses assertions | warns |
+| `test-removed` | a test (or test file) disappears and no identical body appears elsewhere | warns |
+| `expectation-rewritten` | an expected value changed, test inputs did not, and production code changed in the same PR | warns |
+| `test-skip`, `test-focus`, `trivial-assert`, `swallowed-error`, `type-escape`, `stub-abandonment` | the classic shortcuts, compared before/after so old debt does not block | skip, focus and trivial-assert block |
+
+Renames, moved tests, parametrization, assertions moved into a new helper, and formatter
+rewraps (prettier, black) are recognized and not reported. Intentional cases can be accepted
+one by one with an expiring, reviewed exception (see below). Policy is read from the base
+branch, so a PR cannot switch the rules off for itself.
 
 ### How well does it work?
 
-Measured, not promised (`npm run build`, then `npm run bench` and `npm run bench:noise`;
-method and raw numbers are in [docs/benchmarks.md](docs/benchmarks.md)):
-
-- **Labeled changes** (`benchmarks/cases.mjs`): 32 cheating edits across JS/TS, Python, Go
-  and CI/config files are caught, and 15 harmless look-alikes (reformat, rename, move,
-  parametrize, snapshot, raised thresholds, CI step split) stay silent. The cases were
-  written together with the detector, so they guard against regressions; they do not prove
-  accuracy. Three known gaps are listed in the file and still open: mocking the module
-  under test, hardcoding the tested value, and vacuous matchers such as `expect.anything()`.
-- **Noise on real human history** (the last 300 commits of commander.js, execa, click,
-  requests and zod; 606 of them touched tests or CI/config): the two blocking rules fired on
-  7 commits (1.2%). Each was read by hand: one was a real defect (a refactor in `requests`
-  dropped the `assert` keyword, leaving a comparison with no effect); the other six were
-  deliberate rewrites a reviewer should still see, such as a test-framework migration,
-  dropping Python 2, or a documented `continue-on-error`. `test-removed` fired on 6.1% and
-  `expectation-rewritten` on 2.8% of those commits, which is why they only report.
-- **Not measured yet:** accuracy on real AI-agent pull requests. The sample above is human
-  history, and it is small. Treat the numbers as a floor for noise, not a guarantee.
-
-It is a **review aid**. It cannot prove who wrote a change or that code is correct, and it
+Measured, not promised; method, corpus and raw numbers are in
+[docs/benchmarks.md](docs/benchmarks.md). **Short version: weakened checks are rare, usually
+deliberate, and not specific to AI. The tool finds them; a person decides.**
+
+- **Labeled changes** (`benchmarks/cases.mjs`): 40 cheating edits across JS/TS, Python, Go and
+  CI/config files are caught and 33 harmless look-alikes (reformat, rename, move, parametrize,
+  helper extraction, raised thresholds, CI restructuring) stay silent. The cases were written
+  together with the detector, so they guard against regressions; they do not prove accuracy.
+  Three known gaps are listed in the file and still open: mocking the module under test,
+  hardcoding the tested value, and vacuous matchers such as `expect.anything()`.
+- **Five mature open-source projects** (commander.js, execa, click, requests, zod; 606 commits
+  that touch tests or CI/config): the blocking rules fired on 3 commits (0.5%), all of them
+  deliberate. `assertion-removed` fired on 5 (0.8%), including one real defect:
+  a refactor in `requests` dropped the `assert` keyword and left a comparison with no effect.
+- **AI-signed commits in 166 public repositories** (signatures from Claude, Copilot, Cursor,
+  Codex, Devin and aider; 12,645 commits that touch tests or CI/config):
+
+  | | AI-signed | Other commits |
+  | --- | ---: | ---: |
+  | Repositories | 160 | 141 |
+  | Commits reviewed | 6,895 | 5,750 |
+  | Blocking rules | 0.3% (20) | 0.3% (16) |
+  | `assertion-removed` (warns) | 2.4% | 2.2% |
+  | `test-removed` (warns) | 15.4% | 12.7% |
+  | `expectation-rewritten` (warns) | 5.7% | 5.5% |
+
+  Compared inside the same repository (135 repositories with both kinds), the odds of a
+  blocking finding in an AI-signed commit are 0.81 times those of another commit (95% CI
+  0.40-1.67): no sign that AI-signed commits weaken checks more often. Claude accounts for
+  5,380 of the AI-signed commits; the other agents are too few to compare.
+- **Hand-read precision.** Findings were read without knowing who wrote the commit (one
+  reader, an AI assistant; not independently verified). On repositories the detector had never
+  seen, the 11 blocking findings were 2 unexplained relaxations (TypeScript strictness switched
+  off in commits titled "Changes"), 7 deliberate and explained changes, and 2 false alarms. Of
+  24 `assertion-removed` warnings, 1 was an unexplained weakening, 12 deliberate, 6 unclear and
+  5 false alarms. So most findings are decisions a reviewer should see rather than mistakes,
+  and roughly one in five is a false alarm. Earlier rounds (76 findings) were used to fix the
+  detector and are not counted here.
+
+Caveats. A signature shows a tool was involved, not how much, and unsigned AI help in the
+"other" group would hide a difference. The repositories came from searching for those
+signatures, so many are small personal projects. This measures what was committed, not what an
+agent tries mid-session: a weakened check fixed before the commit is invisible. Labels are one
+reader's opinion. Three small fixes (assertion helpers, throwing test-library queries,
+scheduled-only workflows) were added after the labeling and have regression cases, but were not
+re-labeled.
+
+It is a **review aid**: it cannot prove who wrote a change or that code is correct, and it
 reads text, not program semantics. A green result is not a quality certificate.
 
 ### Quick start
@@ -145,12 +175,12 @@ regressions) may appear in the report/summary rather than as an inline PR annota
 Use a separate SARIF category for introduced-findings review; it does not represent
 a full scan of all outstanding alerts.
 
-Install 0.9.0: `npx agent-roast@0.9.0 review --base origin/main`. For local development,
+Install 0.10.0: `npx agent-roast@0.10.0 review --base origin/main`. For local development,
 run `npm run build` and use `node dist/cli.js`.
 
 ### Precise exceptions (since 0.8.0)
 
-Use `npx agent-roast@0.9.0 check --format json`, or build this checkout with
+Use `npx agent-roast@0.10.0 check --format json`, or build this checkout with
 `npm run build` and run `node dist/cli.js`.
 
 Some skipped integrations or abstract stubs are intentional. In 0.8.0 you can accept
@@ -386,7 +416,7 @@ jobs:
 
 To pilot the Action without blocking on findings, set `advisory: true`. It passes
 an explicit empty fail-on list; invalid configuration, Git errors and incomplete
-scans still fail. The `v1` Action installs 0.9.0. The CLI equivalent is `--fail-on ''`.
+scans still fail. The `v1` Action installs 0.10.0. The CLI equivalent is `--fail-on ''`.
 
 > **Security Note:** `agent-roast` runs in an isolated runner directory (`$RUNNER_TEMP`) with `--ignore-scripts` to neutralize malicious `.npmrc` files in untrusted pull requests. `pull_request_target` is not supported.
 
@@ -474,7 +504,7 @@ node scripts/verify-user-workflows.mjs dist/cli.js
 against current code. Regression tests use disposable Git repositories. The programmatic
 `auditPullRequest({ staged: true })` API retains the legacy added-lines contract;
 use `reviewStagedChanges()` for the new context comparison and `ReviewResult`.
-The composite Action installs exactly 0.9.0. For local development, use
+The composite Action installs exactly 0.10.0. For local development, use
 `node dist/cli.js --staged` after building.
 
 ### Author & Support

package/dist/{chunk-GMBQNL6Z.js → chunk-NSGANOZ5.js}

@@ -787,11 +787,17 @@ var RULE_GUIDES = {
     example: "throw new Error('Not implemented') \u2192 implement the operation and add a behavior test"
   },
   "assertion-weakened": {
-    title: "Test checks less than before",
-    why: "A test that keeps its name but loses assertions, or has one replaced by a weaker check, still passes while verifying less behavior.",
-    suggestion: "Restore the removed assertion or explain in the PR why that behavior is no longer required. Fix the code under test instead of weakening its check.",
+    title: "Exact check replaced by a weaker one",
+    why: "Swapping an exact assertion for toBeDefined, a truthiness check or `is not None` keeps the test green while it verifies far less.",
+    suggestion: "Restore the exact check, or assert the specific value the code should produce.",
     example: "expect(total).toBe(42) \u2192 expect(total).toBeDefined()  (restore the exact check)"
   },
+  "assertion-removed": {
+    title: "Test checks less than before",
+    why: "A test that keeps its name but loses assertions verifies less behavior. Often the behavior changed on purpose; sometimes a check was dropped to get the suite green.",
+    suggestion: "Confirm the removed checks no longer apply, or restore them. Say so in the PR when the behavior was removed on purpose.",
+    example: "expect(a).toBe(1); expect(b).toBe(2) \u2192 expect(a).toBe(1)  (is the second check still needed?)"
+  },
   "test-removed": {
     title: "Test removed",
     why: "Deleting a failing test makes a suite green without fixing the behavior it covered. Removals are legitimate when the feature itself is gone.",
@@ -832,6 +838,7 @@ var VALID_DETECTORS = [
   "stub-abandonment",
   "test-focus",
   "assertion-weakened",
+  "assertion-removed",
   "test-removed",
   "expectation-rewritten",
   "guard-weakened"
@@ -995,6 +1002,7 @@ var DEFAULT_CONFIG = {
     "trivial-assert": "error",
     "test-focus": "error",
     "assertion-weakened": "error",
+    "assertion-removed": "warn",
     "guard-weakened": "error",
     "test-removed": "warn",
     "expectation-rewritten": "warn",
@@ -2802,7 +2810,7 @@ var JS_TEST_START = /(?<![\w$.])(?:it|test)(?:\s*\.\s*(?:only|skip|concurrent|se
 var PY_TEST_START = /^\s*(?:async\s+)?def\s+(test\w*)\s*\(/;
 var GO_TEST_START = /^func\s+(Test\w+)\s*\(/;
 var JS_ASSERTION = /(?<![\w$.])(?:expect|assert|expectTypeOf)\b(?!\s*\.\s*(?:assertions|hasAssertions|extend|anything|any|objectContaining|arrayContaining|stringContaining|stringMatching)\b)(?:\s*\.\s*\w+)*\s*\(|\.should\b/;
-var PY_ASSERTION = /^\s*assert\b|\bself\s*\.\s*assert\w*\s*\(|\bpytest\s*\.\s*raises\b|\bassertRaises\b/;
+var PY_ASSERTION = /^\s*assert\b|\bself\s*\.\s*assert\w*\s*\(|\bpytest\s*\.\s*raises\b|\bassertRaises\b|(?<!\w)assert_\w+\s*\(/;
 var GO_ASSERTION = /\bt\s*\.\s*(?:Error|Errorf|Fatal|Fatalf|Fail|FailNow)\b|\b(?:assert|require)\s*\.\s*\w+\s*\(/;
 function callEnd(text, from, limit) {
   let depth = 1, quote = "";
@@ -2883,12 +2891,25 @@ function splitStatements(text) {
   pieces.push(text.slice(start));
   return pieces.map((piece) => piece.trim()).filter(Boolean);
 }
+function stripTrailingComment(line, language) {
+  const marker = language === "py" ? "#" : "//";
+  let quote = "";
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (quote) {
+      if (char === "\\") i++;
+      else if (char === quote) quote = "";
+    } else if (char === '"' || char === "'" || char === "`") quote = char;
+    else if (line.startsWith(marker, i) && (i === 0 || /\s/.test(line[i - 1]))) return line.slice(0, i).trimEnd();
+  }
+  return line;
+}
 var CALLBACK_HEADER = /^[,\s]*(?:async\s*)?(?:\([^)]*\)|[\w$]+)\s*=>\s*\{\s*|^[,\s]*(?:async\s+)?function\s*\w*\s*\([^)]*\)\s*\{\s*/;
 function parseTests(text, language) {
   const assertionPattern = language === "js" ? JS_ASSERTION : language === "py" ? PY_ASSERTION : GO_ASSERTION;
   const seen = /* @__PURE__ */ new Map();
   return testBodies(text, language).map((test) => {
-    const body = test.body.split("\n");
+    const body = test.body.split("\n").map((line) => language === "go" ? line : stripTrailingComment(line, language));
     const assertions = [], raw = [], setupLines = [];
     for (let i = 0; i < body.length; i++) {
       if (!assertionPattern.test(body[i])) {
@@ -2913,19 +2934,34 @@ function parseTests(text, language) {
     const bodyHash = createHash3("sha1").update(test.body.replace(/\s+/g, "")).digest("hex");
     const count = (seen.get(test.name) ?? 0) + 1;
     seen.set(test.name, count);
-    return { key: `${test.name}#${count}`, parametrized: test.parametrized, name: test.name, line: test.line, assertions, raw, setup, bodyHash };
+    return { key: `${test.name}#${count}`, parametrized: test.parametrized, name: test.name, line: test.line, assertions, raw, setup, bodyHash, text: test.body };
   });
 }
 function skeleton(assertion) {
   return assertion.replace(/(['"`])(?:\\.|(?!\1)[^\\])*\1/g, "S").replace(/\b\d+(?:\.\d+)?\b/g, "N").replace(/\b(?:true|false|null|undefined|None|True|False|nil)\b/g, "V").replace(/\s+/g, "");
 }
 var WEAK_JS = /\.(?:toBeDefined|toBeTruthy|toBeFalsy|toBeUndefined)\s*\(|\.not\s*\.\s*(?:toBeNull|toBeUndefined|toThrow)\s*\(|\.toBeGreaterThanOrEqual\s*\(\s*0\s*\)/;
-var WEAK_PY = /^\s*assert\s+[\w.()\[\]]+\s*$|^\s*assert\s+.+\sis\s+not\s+None\s*$|^\s*assert\s+True\s*$/;
+var WEAK_PY = /^\s*assert\s+[\w.\[\]]+\s*(?:,.*)?$|^\s*assert\s+.+\bis\s+not\s+None\s*(?:,.*)?$|^\s*assert\s+True\b/;
+var PY_SPECIFIC = /==|!=|<=|>=|\bin\b|\bis\b|\bisinstance\s*\(|\.startswith\s*\(|\.endswith\s*\(|\bcallable\s*\(/;
+var JS_SPECIFIC = /\.(?:toBe|toEqual|toStrictEqual|toHaveLength|toContain|toContainEqual|toMatch|toMatchObject|toHaveProperty|toHaveBeenCalledWith|toHaveBeenCalledTimes|toHaveTextContent|toHaveAttribute|toHaveValue|toThrow\w*|toBeGreaterThan\w*|toBeLessThan\w*)\s*\(/;
+var THROWING_QUERY = /\b(?:get|find)(?:All)?By\w*\s*\(/;
 function isWeaker(oldAssertion, newAssertion, language) {
-  if (language === "js") return WEAK_JS.test(newAssertion) && !WEAK_JS.test(oldAssertion);
-  if (language === "py") return WEAK_PY.test(newAssertion) && !WEAK_PY.test(oldAssertion);
+  if (language === "js") return !THROWING_QUERY.test(newAssertion) && WEAK_JS.test(newAssertion) && !WEAK_JS.test(oldAssertion) && JS_SPECIFIC.test(oldAssertion);
+  if (language === "py") return WEAK_PY.test(newAssertion) && !WEAK_PY.test(oldAssertion) && PY_SPECIFIC.test(oldAssertion);
   return false;
 }
+var GENERIC_ARGUMENT = /^(?:not\.)?(?:be|have|contain|include|exist|match|eq|equal|length|text|value|attr|class|css|visible|checked|disabled|enabled|selected|focus|empty|true|false|null|undefined|deep)(?:\.\w+)*$/;
+function literalTokens(statement) {
+  const tokens = /* @__PURE__ */ new Set();
+  const literal = /(['"`])((?:\\.|(?!\1)[^\\\n])*)\1|(?<=[(,]\s*)\/((?:\\.|[^/\\\n])+)\/[a-z]*/g;
+  for (const match of statement.matchAll(literal)) {
+    for (const token of (match[2] ?? match[3] ?? "").match(/[A-Za-z0-9_:.=@#%-]{4,}/g) ?? []) {
+      if (!GENERIC_ARGUMENT.test(token)) tokens.add(token);
+    }
+  }
+  return [...tokens];
+}
+var HELPER_CALL = /(?<![\w$])((?:expect|assert|verify|check|require)[A-Z]\w*|_{0,2}(?:assert|check|verify|expect|require)_\w+)\s*\(/g;
 function finding(type, file, line, snippet, reason, commit) {
   return { type, file, lineNumber: Math.max(1, line), lineSnippet: snippet, commitHash: commit, commitDate: "", reason, suggestion: RULE_GUIDES[type].suggestion };
 }
@@ -2943,6 +2979,7 @@ function analyzeTestFile(oldPath, newPath, oldText, newText, commit) {
   };
   const oldTotals = tally(before), newTotals = tally(after);
   const beforeKeys = new Set(before.map((test) => test.key));
+  const addedText = after.filter((test) => !beforeKeys.has(test.key)).map((test) => test.text).join("\n");
   const result = { immediate: [], removedTests: [], addedHashes: [], rewritten: [] };
   for (const test of after) if (!beforeKeys.has(test.key)) result.addedHashes.push(test.bodyHash);
   for (const old of before) {
@@ -2966,18 +3003,24 @@ function analyzeTestFile(oldPath, newPath, oldText, newText, commit) {
     const snapshot = (test) => test.raw.some((statement) => /\.toMatch(?:Inline)?Snapshot\b|\.matchSnapshot\b|\bsnapshot\s*\(/.test(statement));
     if (snapshot(current) && !snapshot(old)) continue;
     if (current.assertions.length < old.assertions.length) {
+      if ([...current.text.matchAll(HELPER_CALL)].some((call) => !(oldText ?? "").includes(call[1]))) continue;
       const budget = tally([current]);
-      const lost = old.assertions.filter((assertion) => {
+      const lost = [];
+      old.assertions.forEach((assertion, i) => {
         const left = budget.get(assertion) ?? 0;
-        if (left > 0) {
-          budget.set(assertion, left - 1);
-          return false;
-        }
-        return true;
+        if (left > 0) budget.set(assertion, left - 1);
+        else lost.push({ normalized: assertion, raw: old.raw[i] });
       });
-      if (lost.every((assertion) => (newTotals.get(assertion) ?? 0) >= (oldTotals.get(assertion) ?? 0))) continue;
+      const introduced = `${current.text}
+${addedText}`;
+      const accounted = (item) => {
+        if ((newTotals.get(item.normalized) ?? 0) >= (oldTotals.get(item.normalized) ?? 0)) return true;
+        const tokens = literalTokens(item.raw);
+        return tokens.length > 0 && tokens.every((token) => introduced.includes(token));
+      };
+      if (lost.every(accounted)) continue;
       result.immediate.push(finding(
-        "assertion-weakened",
+        "assertion-removed",
         newPath,
         current.line,
         `${old.name}: ${old.assertions.length} \u2192 ${current.assertions.length} assertions`,
@@ -3044,7 +3087,46 @@ var THRESHOLD_PATTERNS = [
   /(--cov-fail-under)[= ](\d+(?:\.\d+)?)/g
 ];
 var SWITCHES = ["strict", "noImplicitAny", "strictNullChecks", "noImplicitReturns", "useUnknownInCatchVariables"];
-var TEST_COMMAND = /\brun:.*\b(?:tests?|unit|pytest|vitest|jest|mocha|ava|tap|tox|nox|e2e|spec)\b|^\s*-?\s*(?:npm|yarn|pnpm|go|cargo|mvn|gradle|make)\s+(?:run\s+)?(?:\w+\s+)?tests?\b/;
+var CI_RUNNER = new RegExp(
+  String.raw`(?<![\w./-])(?:pytest|vitest|jest|mocha|tox|nox)(?![\w/-])` + String.raw`|(?<![\w./-])(?:npm|yarn|pnpm|bun|go|cargo|mvn|gradle|make|dotnet|flutter)\s+(?:run\s+)?(?:-\S+\s+)*test(?![\w/])` + String.raw`|\brun:.*(?<=\s)(?:tests?|unit|e2e)(?![\w/.-])`
+);
+var CI_FILE = /(?:\.github\/workflows\/|\.gitlab-ci)/;
+var CI_REUSABLE = /^\s*-?\s*uses:\s*\S*\.github\/workflows\/\S+/;
+var CI_GATE = /^\s*(?:pull_request|pull_request_target|push|merge_group)\s*:|^\s*on\s*:\s*(?:\[[^\]]*\b(?:push|pull_request|pull_request_target|merge_group)\b[^\]]*\]|(?:push|pull_request|pull_request_target|merge_group)\s*$)|^\s*-\s*(?:push|pull_request|pull_request_target|merge_group)\s*$/m;
+function gatingTestLines(file, text) {
+  return /\.gitlab-ci/.test(file) || CI_GATE.test(text) ? matchingLines(text, CI_RUNNER) : 0;
+}
+function matchingLines(text, pattern) {
+  return text.split(/\r?\n/).filter((line) => !line.trim().startsWith("#") && pattern.test(line)).length;
+}
+function ciTestSteps(file, oldText, newText) {
+  if (!CI_FILE.test(file) || oldText === null && newText === null) return null;
+  const was = oldText ?? "", now = newText ?? "";
+  const after = gatingTestLines(file, now);
+  return { file, before: gatingTestLines(file, was), after, reusableAfter: matchingLines(now, CI_REUSABLE), ungatedAfter: after === 0 ? matchingLines(now, CI_RUNNER) : 0 };
+}
+function resolveCiTestSteps(counts, commit) {
+  const before = counts.reduce((sum, item) => sum + item.before, 0);
+  const after = counts.reduce((sum, item) => sum + item.after + item.reusableAfter, 0);
+  if (after >= before) return [];
+  return counts.filter((item) => item.before > 0 && item.after === 0 && item.reusableAfter === 0).map((item) => item.ungatedAfter > 0 ? finding("guard-weakened", item.file, 1, "tests no longer run on push or pull_request", "Workflow keeps its tests but no longer runs on pushes or pull requests", commit) : finding("guard-weakened", item.file, 1, "test command no longer runs in CI", "Test step removed from CI", commit));
+}
+var LENIENT = /continue-on-error:\s*true|allow_failure:\s*true/;
+function lenientSteps(text) {
+  const lines = text.split(/\r?\n/);
+  const indentOf = (line) => line.length - line.trimStart().length;
+  const found = /* @__PURE__ */ new Map();
+  lines.forEach((line, i) => {
+    if (line.trim().startsWith("#") || !LENIENT.test(line)) return;
+    let j = i - 1;
+    while (j >= 0 && (!lines[j].trim() || lines[j].trim().startsWith("#") || indentOf(lines[j]) >= indentOf(line))) j--;
+    const identity = j >= 0 ? lines[j].trim() : "";
+    const entry = found.get(identity);
+    if (entry) entry.count++;
+    else found.set(identity, { count: 1, line: i + 1 });
+  });
+  return found;
+}
 function severityOf(value) {
   return /^(?:error|2)$/.test(value) ? 2 : /^(?:warn|1)$/.test(value) ? 1 : 0;
 }
@@ -3071,21 +3153,29 @@ function analyzeGuardFile(file, oldText, newText, commit) {
     }
   }
   if (/eslint/i.test(file)) {
-    const rules = (text) => new Map([...text.matchAll(/["']([@\w/.-]+)["']\s*:\s*(?:\[\s*)?["']?(error|warn|off|[012])["']?/g)].map((match) => [match[1], { level: severityOf(match[2]), index: match.index ?? 0 }]));
-    const before = rules(oldText);
-    for (const [name, now] of rules(newText)) {
+    const rules = (text) => {
+      const found = /* @__PURE__ */ new Map();
+      for (const match of text.matchAll(/["']([@\w/.-]+)["']\s*:\s*(?:\[\s*)?["']?(error|warn|off|[012])["']?/g)) {
+        const level = severityOf(match[2]);
+        const known = found.get(match[1]);
+        if (!known || level > known.level) found.set(match[1], { level, index: match.index ?? 0 });
+      }
+      return found;
+    };
+    const before = rules(oldText), after = rules(newText);
+    for (const [name, now] of after) {
       const previous = before.get(name);
-      if (previous && previous.level === 2 && now.level < 2) add(now.index, `${name}: error \u2192 ${now.level ? "warn" : "off"}`, "Lint rule downgraded");
+      const replaced = [...after].some(([other, setting]) => other !== name && other.endsWith(`/${name}`) && setting.level === 2);
+      if (previous && previous.level === 2 && now.level < 2 && !replaced) add(now.index, `${name}: error \u2192 ${now.level ? "warn" : "off"}`, "Lint rule downgraded");
     }
   }
-  if (/(?:\.github\/workflows\/|\.gitlab-ci)/.test(file)) {
-    const count = (text, pattern) => text.split(/\r?\n/).filter((line) => !line.trim().startsWith("#") && pattern.test(line)).length;
-    const lenient = /continue-on-error:\s*true|allow_failure:\s*true/;
-    if (count(newText, lenient) > count(oldText, lenient)) {
-      add(newText.search(lenient), "continue-on-error: true", "CI step is now allowed to fail");
-    }
-    if (count(newText, TEST_COMMAND) < count(oldText, TEST_COMMAND)) {
-      add(0, "test command no longer runs in CI", "Test step removed from CI");
+  if (CI_FILE.test(file)) {
+    const before = lenientSteps(oldText), existing = new Set(oldText.split(/\r?\n/).map((line) => line.trim()));
+    for (const [identity, now] of lenientSteps(newText)) {
+      if (identity && existing.has(identity) && now.count > (before.get(identity)?.count ?? 0)) {
+        out.push(finding("guard-weakened", file, now.line, "continue-on-error: true", "CI step is now allowed to fail", commit));
+        break;
+      }
     }
   }
   if (/(?:^|\/)package\.json$/i.test(file)) {
@@ -3170,6 +3260,7 @@ async function compareSourceChanges(options) {
   let totalBytes = 0;
   const tamperingFiles = [];
   const guardFindings = [];
+  const ciCounts = [];
   let productionChanged = false;
   const readText = async (mode, oid) => {
     if (mode === "000000") return null;
@@ -3195,6 +3286,8 @@ async function compareSourceChanges(options) {
         const oldText = await readText(change.oldMode, change.oldOid);
         const newText = await readText(change.newMode, change.newOid);
         guardFindings.push(...analyzeGuardFile(change.newPath, oldText, newText, refs.headSha));
+        const ci = ciTestSteps(change.newPath, oldText, newText);
+        if (ci) ciCounts.push(ci);
         result.filesInspected++;
       } catch (error) {
         assertNotAborted(options.signal);
@@ -3252,7 +3345,7 @@ async function compareSourceChanges(options) {
   await staged?.verify();
   result.complete = result.skippedFiles.length === 0;
   const rules = policy.config.rules ?? {};
-  result.infractions.push(...[...resolveTampering(tamperingFiles, productionChanged), ...guardFindings].filter((finding2) => rules[finding2.type] !== "off"));
+  result.infractions.push(...[...resolveTampering(tamperingFiles, productionChanged), ...guardFindings, ...resolveCiTestSteps(ciCounts, refs.headSha)].filter((finding2) => rules[finding2.type] !== "off"));
   const exceptions = applyExceptions(result.infractions, options.ignoreExceptions ? [] : policy.config.exceptions, /* @__PURE__ */ new Date(), existingCounts);
   result.infractions = exceptions.findings;
   result.suppressedFindings = exceptions.suppressedFindings;

package/dist/cli.js

@@ -22,7 +22,7 @@ import {
   roastRepository,
   terminalText,
   writeBaseline
-} from "./chunk-GMBQNL6Z.js";
+} from "./chunk-NSGANOZ5.js";
 
 // src/cli.ts
 import { Command } from "commander";

package/dist/index.d.ts

@@ -32,7 +32,7 @@ interface CommitInfo {
     isAiAttributed: boolean;
     aiSignatures: string[];
 }
-type DetectorType = "test-skip" | "type-escape" | "swallowed-error" | "panic-loop" | "trivial-assert" | "stub-abandonment" | "test-focus" | "assertion-weakened" | "test-removed" | "expectation-rewritten" | "guard-weakened";
+type DetectorType = "test-skip" | "type-escape" | "swallowed-error" | "panic-loop" | "trivial-assert" | "stub-abandonment" | "test-focus" | "assertion-weakened" | "assertion-removed" | "test-removed" | "expectation-rewritten" | "guard-weakened";
 declare const VALID_DETECTORS: readonly DetectorType[];
 interface Infraction {
     fingerprint?: string;

package/dist/index.js

@@ -63,7 +63,7 @@ import {
   unquoteGitPath,
   validateExceptions,
   writeBaseline
-} from "./chunk-GMBQNL6Z.js";
+} from "./chunk-NSGANOZ5.js";
 export {
   CONFIG_FILENAMES,
   ConfigError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-roast",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Offline review for AI-assisted changes: catches weakened tests, lowered quality gates, skipped tests and swallowed errors",
   "type": "module",
   "main": "./dist/index.js",

package/schema.json

@@ -22,6 +22,7 @@
           "stub-abandonment",
           "test-focus",
           "assertion-weakened",
+          "assertion-removed",
           "test-removed",
           "expectation-rewritten",
           "guard-weakened"
@@ -126,6 +127,13 @@
             "warn",
             "off"
           ]
+        },
+        "assertion-removed": {
+          "enum": [
+            "error",
+            "warn",
+            "off"
+          ]
         }
       }
     },