agent-roast 0.23.0 → 0.24.0

package/README.md

@@ -112,7 +112,7 @@ Measured, with the denominators and the caveats in [docs/benchmarks.md](docs/ben
 deliberate, and not specific to AI. agent-roast is a tripwire that asks about them. On repositories it had not seen, between a quarter and
 two thirds of its blocks were questions with a harmless answer, depending on the sample.**
 
-- **164 of 164** hand-labeled cheating edits are caught and **153 of 153** harmless look-alikes (reformats, moves, raised
+- **165 of 165** hand-labeled cheating edits are caught and **154 of 154** harmless look-alikes (reformats, moves, raised
   thresholds, environment-gated skips) stay silent. The cases were written with the detector, so they guard against regressions;
   they do not prove accuracy. One gap is documented and still open.
 - **A catalog of cheats that someone else wrote.** Of the nine hacks in [reward-hack-zoo](https://github.com/MatthewWaller/reward-hack-zoo) (hand-written specimens; none from a model) four are reported (a skip, a patched target, a `conftest.py` that rewrites reports,

package/dist/{chunk-L4XLCXC2.js → chunk-U5MFYERX.js}

@@ -4538,6 +4538,32 @@ function gatingCalls(file, text) {
   if (!(/\.gitlab-ci/.test(file) || CI_GATE.test(gatingTriggers(text) ?? text))) return [];
   return [...text.matchAll(/^\s*-?\s*uses:\s*["']?\.\/(\.github\/workflows\/[^\s"'#@]+\.ya?ml)/gm)].map((match) => match[1]);
 }
+function lostCalls(file, oldText, newText) {
+  if (!CI_FILE.test(file)) return [];
+  const before = gatingCalls(file, oldText ?? "");
+  if (!before.length) return [];
+  const after = new Set(gatingCalls(file, newText ?? ""));
+  return before.filter((workflow) => !after.has(workflow));
+}
+function calledTestCommands(text) {
+  const directories = [...new Set([...text.matchAll(/^\s*(?:-\s+)?working-directory\s*:\s*["']?([^\s"'#]+)/gm)].map((match) => match[1]))].sort().join(",");
+  return ciTestEntries(text).map((entry) => `${entry.command.replace(/\s#.*$/, "").replace(/^\s*-?\s*(?:run\s*:\s*)?/, "").replace(/\s+/g, " ").trim()} @${directories}`);
+}
+function resolveLostCallers(lost, commit) {
+  const out = [];
+  for (const [file, { content, stillCalled }] of lost) {
+    if (stillCalled || gatingTestCommands(file, content).length > 0 || calledTestCommands(content).length === 0) continue;
+    out.push(finding(
+      "guard-weakened",
+      file,
+      1,
+      "nothing calls this workflow on a push or pull request any more",
+      "Workflow keeps its tests, but the workflow that called it is gone",
+      commit
+    ));
+  }
+  return out;
+}
 function resolveCiTestSteps(counts, commit, elsewhere = /* @__PURE__ */ new Set(), called = /* @__PURE__ */ new Set()) {
   const before = counts.reduce((sum, item) => sum + item.before, 0);
   const after = counts.reduce((sum, item) => sum + item.after + item.reusableAfter, 0);
@@ -4800,6 +4826,8 @@ async function compareSnapshot(options, cwd, snapshot) {
   const guardFindings = [];
   const ciCounts = [];
   const calledInChange = /* @__PURE__ */ new Set();
+  const lostCalledWorkflows = /* @__PURE__ */ new Set();
+  const touchedCiContent = /* @__PURE__ */ new Map();
   let productionChanged = false;
   const decode = (content) => {
     totalBytes += content.length;
@@ -4837,8 +4865,12 @@ async function compareSnapshot(options, cwd, snapshot) {
         const newText = await readNew(change);
         guardFindings.push(...analyzeGuardFile(change.newPath, oldText, newText, refs.headSha));
         const ci = ciTestSteps(change.newPath, oldText, newText);
-        if (ci) ciCounts.push(ci);
-        if (ci && newText !== null) for (const workflow of gatingCalls(change.newPath, newText)) calledInChange.add(workflow);
+        if (ci) {
+          ciCounts.push(ci);
+          touchedCiContent.set(change.newPath, newText);
+          for (const workflow of lostCalls(change.newPath, oldText, newText)) lostCalledWorkflows.add(workflow);
+          if (newText !== null) for (const workflow of gatingCalls(change.newPath, newText)) calledInChange.add(workflow);
+        }
         result.filesInspected++;
       } catch (error) {
         assertNotAborted(options.signal);
@@ -4897,7 +4929,8 @@ async function compareSnapshot(options, cwd, snapshot) {
   result.complete = result.skippedFiles.length === 0;
   const rules = policy.config.rules ?? {};
   const elsewhere = /* @__PURE__ */ new Set(), called = new Set(calledInChange);
-  if (ciCounts.some((item) => item.before > 0 && item.after === 0 && item.reusableAfter === 0)) {
+  const untouchedLostCallerContent = /* @__PURE__ */ new Map();
+  if (ciCounts.some((item) => item.before > 0 && item.after === 0 && item.reusableAfter === 0) || lostCalledWorkflows.size > 0) {
     const touched = new Set(changes.flatMap((change) => [change.oldPath, change.newPath]));
     const tree = /^[a-f0-9]{40,64}$/.test(refs.headSha) ? refs.headSha : refs.baseSha;
     try {
@@ -4906,6 +4939,7 @@ async function compareSnapshot(options, cwd, snapshot) {
           const text = new TextDecoder().decode(await readBlob(cwd, file.oid, options.signal, 512 * 1024));
           for (const command of enforcedTestCommands(file.path, text)) elsewhere.add(command);
           for (const workflow of gatingCalls(file.path, text)) called.add(workflow);
+          if (lostCalledWorkflows.has(file.path)) untouchedLostCallerContent.set(file.path, text);
         } catch (error) {
           assertNotAborted(options.signal);
         }
@@ -4914,7 +4948,16 @@ async function compareSnapshot(options, cwd, snapshot) {
       assertNotAborted(options.signal);
     }
   }
-  result.infractions.push(...[...resolveTampering(tamperingFiles, productionChanged), ...guardFindings, ...resolveCiTestSteps(ciCounts, refs.headSha, elsewhere, called)].filter((finding2) => rules[finding2.type] !== "off"));
+  const ciFindings = resolveCiTestSteps(ciCounts, refs.headSha, elsewhere, called);
+  const alreadyFlagged = new Set(ciFindings.map((found) => found.file));
+  const lostCallers = /* @__PURE__ */ new Map();
+  for (const workflow of lostCalledWorkflows) {
+    if (alreadyFlagged.has(workflow)) continue;
+    const content = touchedCiContent.has(workflow) ? touchedCiContent.get(workflow) ?? null : untouchedLostCallerContent.get(workflow) ?? null;
+    if (content === null) continue;
+    lostCallers.set(workflow, { content, stillCalled: called.has(workflow) });
+  }
+  result.infractions.push(...[...resolveTampering(tamperingFiles, productionChanged), ...guardFindings, ...ciFindings, ...resolveLostCallers(lostCallers, 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

@@ -38,7 +38,7 @@ import {
   terminalText,
   uninstallHooks,
   writeBaseline
-} from "./chunk-L4XLCXC2.js";
+} from "./chunk-U5MFYERX.js";
 
 // src/cli.ts
 import { Command } from "commander";

package/dist/index.js

@@ -92,7 +92,7 @@ import {
   unquoteGitPath,
   validateExceptions,
   writeBaseline
-} from "./chunk-L4XLCXC2.js";
+} from "./chunk-U5MFYERX.js";
 export {
   AGENT_LABELS,
   CONFIG_FILENAMES,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-roast",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "description": "Stops AI agents (and rushed humans) weakening tests, coverage gates or CI to get a green build. Hook for Claude Code, Codex, Cursor, Gemini CLI, Copilot, Droid; pre-commit; GitHub Action. Offline.",
   "mcpName": "io.github.Nari-Ab/agent-roast",
   "type": "module",