@kavishdua/proctor 1.1.0 → 1.2.1

package/README.md

@@ -37,6 +37,7 @@ source needs Node 20.19+ or 22.12+.
 - [What do the codes mean?](#what-do-the-codes-mean)
 - [Badges](#badges)
 - [CI](#ci)
+- [Dynamic checks](#dynamic-checks), opt-in runtime evidence
 
 **Why it works**
 
@@ -306,6 +307,32 @@ See the language matrix for each check's scope.
 Some WI checks accept an explanatory comment; others require a committed approval or suppression
 marker. Check the rule's `--explain` output before relying on an exception.
 
+Three static checks keep ambiguous repairs visible as warnings. RH003 warns when a rewrite re-emits an
+already skipped Python test, or renames a skipped JavaScript test without disabling a known
+active test. RH004 warns for string or boolean domain branches, literal returns inside
+conditional fallback paths, and explicit SPEC or CHANGELOG behavior notes naming the changed
+function or both special-case literals. WI112 warns when every removed assertion targets a source function
+or dispatch arm removed from the corresponding module in the same diff. Newly disabled tests,
+focus modifiers, unconditional computation replacements without a specific behavior note, and
+unrelated assertion deletions keep their existing errors. WI112 remains opt-in.
+
+RH004 keeps an error for an added key that encodes a list of scalar values, or matches a common
+serialization of a composite literal asserted as input to the same function in changed tests.
+This includes joined, JSON and template string signatures. Domain names and catch/except
+fallbacks remain advisory. Serialized fixture evidence is not demoted by a behavior note.
+
+These warnings do not establish that a repair is correct. Compare the change with the project's
+documented contract and test the supported paths. Incomplete diff context can prevent matching
+a repair, and an unauthorized feature removal can look like an authorized one. Warnings remain
+visible in reports and follow the existing exit policy: `--ci` fails on errors only; a warning
+without `--ci` can exit `1`. Paired, tuned development cases and reproduction steps live in
+[bench/dynamic-dev](bench/dynamic-dev/README.md). They are not an independent accuracy estimate.
+On the tuned authored cases, these checks report 7/36 original cheats and 21/21 repair-set
+cheats, with 0/60 honest errors. Three original catches and one repair-set catch are warnings.
+All seven added serialized-key cheats produce errors. These tuned counts do not establish
+retention of blocking catches or accuracy on other inputs; an independently reported lost
+blocking catch motivated the serialization regressions.
+
 ## Badges
 
 [![proctor](https://img.shields.io/badge/proctor-honest_pass-22C55E)](https://github.com/catfish-1234/proctor)
@@ -345,6 +372,39 @@ jobs:
 The example pins the commit behind the `v1.0.0` release. You can use the `v1.0.0` tag instead, but
 a full commit SHA is immutable, so it keeps builds reproducible.
 
+## Dynamic checks
+
+`proctor check --dynamic` runs extra checks using a runnable project test suite. The default
+check keeps its existing output and runs no project tests. You can also commit
+`{"dynamic": true, "dynamicTimeoutMs": 60000}` in `proctor.config.json`. Use
+`--dynamic-timeout 30000` to override the overall budget in milliseconds.
+
+This prototype supports Node's `node:test`, Jest and Vitest through `npm run test`, plus Python
+`unittest`, `pytest` and plain Python scripts. When unittest collects no cases or only collection
+errors, plain scripts run directly and bare `test_*` functions run individually in fresh processes.
+It needs Linux and bubblewrap with working user, mount, network and PID
+namespaces. Windows, macOS, unsupported languages and unavailable isolation report
+`dynamic: skipped, reason`; a skip never adds a failing finding. Tests run in temporary copies,
+with host mounts read-only and network disabled. The default overall timeout is 60 seconds,
+including copies; descendants are terminated when the worker ends.
+
+Warnings name the commands, run labels and observed results. The checks need runnable
+tests and installed dependencies, can miss changes, and cannot prove intent. A red original suite
+is a normal fix input; named per-test comparisons and numeric, string or boolean probes still run.
+For red-to-green fixes with unchanged tests, mutation-lite tries at most four parser-confirmed
+changes in called functions. DY002 probes and DY004 mutation warnings are advisory and do not
+change the exit code on their own. Mutations can survive because code is redundant or behavior
+is deliberately untested; survival does not establish cheating. Repeated outcomes
+can reflect order dependence.
+
+Measured limits: dynamic checks are opt-in and advisory only. They do not change which findings
+block a commit. Mutation-lite reports missing test coverage, not cheating, and it can fire on
+honest changes whose tests do not cover every changed line. On a private 80-case corpus (40
+cheating changes, 40 honest ones) that informed this iteration, dynamic warnings surfaced 4
+cheating changes the static checks missed and flagged 1 honest change. Because the same corpus
+informed the checks, these are not clean held-out numbers.
+See the [scope, dropped ideas and tuned dev-set measurements](bench/dynamic-dev/README.md).
+
 ## How it works
 
 proctor combines a **ruleset** with a **guard**. The ruleset tells the agent how to complete work

package/dist/cli.js

@@ -57,15 +57,169 @@ var init_judge = __esm({
   }
 });
 
+// src/dynamic/runner.ts
+var runner_exports = {};
+__export(runner_exports, {
+  runDynamic: () => runDynamic
+});
+import { spawn as spawn2 } from "child_process";
+import { mkdtempSync, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, rmSync } from "fs";
+import { join as join14 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+async function runDynamic(options) {
+  const started = Date.now();
+  const skipped = (reason) => ({ status: "skipped", reason, findings: [], runs: [], notes: [], elapsedMs: Date.now() - started });
+  const timeout = options.timeoutMs ?? 6e4;
+  if (!Number.isSafeInteger(timeout) || timeout < 1 || timeout > 2147483647) return skipped("timeout must be an integer from 1 to 2147483647 milliseconds");
+  if (process.env["PROCTOR_DYNAMIC_ACTIVE"]) return skipped("nested dynamic check");
+  if (process.platform !== "linux") {
+    return skipped("not run: this prototype needs Linux and bubblewrap for write and network isolation");
+  }
+  let scratch;
+  try {
+    scratch = mkdtempSync(join14(tmpdir2(), "proctor-dynamic-"));
+  } catch {
+    return skipped("cannot create scratch directory");
+  }
+  const clean = () => {
+    try {
+      rmSync(scratch, { recursive: true, force: true });
+    } catch {
+    }
+  };
+  try {
+    mkdirSync2(join14(scratch, "tmp"));
+    writeFileSync2(join14(scratch, "input.json"), JSON.stringify({ ...options, files: options.files.map(({ from, to }) => ({ from, to })) }));
+    const env = {
+      PATH: process.env["PATH"],
+      HOME: scratch,
+      TMPDIR: join14(scratch, "tmp"),
+      TMP: join14(scratch, "tmp"),
+      TEMP: join14(scratch, "tmp"),
+      LANG: "C.UTF-8",
+      CI: "true",
+      NO_COLOR: "1",
+      PROCTOR_DYNAMIC_ACTIVE: "1",
+      PYTHONDONTWRITEBYTECODE: "1",
+      PYTEST_DISABLE_PLUGIN_AUTOLOAD: "1",
+      npm_config_offline: "true",
+      npm_config_audit: "false",
+      npm_config_update_notifier: "false",
+      npm_config_cache: join14(scratch, "npm-cache")
+    };
+    const remaining = timeout - (Date.now() - started);
+    if (remaining <= 0) return skipped(`overall timeout (${timeout}ms)`);
+    return await new Promise((resolve4) => {
+      const namespaceArgs = [
+        "--die-with-parent",
+        "--unshare-net",
+        "--unshare-pid",
+        "--ro-bind",
+        "/",
+        "/",
+        "--bind",
+        scratch,
+        scratch,
+        "--proc",
+        "/proc",
+        "--dev",
+        "/dev",
+        "--",
+        process.execPath,
+        options.workerPath,
+        join14(scratch, "input.json")
+      ];
+      const child = spawn2("bwrap", namespaceArgs, {
+        cwd: scratch,
+        env,
+        detached: true,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const kill = () => {
+        if (child.pid) {
+          try {
+            process.kill(-child.pid, "SIGKILL");
+          } catch {
+          }
+        }
+      };
+      const onExit = () => {
+        kill();
+        clean();
+      };
+      const onInt = () => {
+        onExit();
+        process.exit(130);
+      };
+      const onTerm = () => {
+        onExit();
+        process.exit(143);
+      };
+      process.once("exit", onExit);
+      process.once("SIGINT", onInt);
+      process.once("SIGTERM", onTerm);
+      let stdout = "", stderr = "", reason = "";
+      const timer = setTimeout(() => {
+        reason = `overall timeout (${timeout}ms)`;
+        kill();
+      }, remaining);
+      child.stdout.on("data", (data) => {
+        stdout += data.toString();
+        if (stdout.length > 4 * 1024 * 1024) {
+          reason = "worker output limit";
+          kill();
+        }
+      });
+      child.stderr.on("data", (data) => {
+        stderr = (stderr + data.toString()).slice(-2e3);
+      });
+      child.once("error", (err) => {
+        reason = `cannot start isolated worker: ${err.message}`;
+      });
+      child.once("close", (code) => {
+        clearTimeout(timer);
+        kill();
+        process.removeListener("exit", onExit);
+        process.removeListener("SIGINT", onInt);
+        process.removeListener("SIGTERM", onTerm);
+        if (reason) {
+          resolve4(skipped(reason));
+          return;
+        }
+        if (code !== 0) {
+          resolve4(skipped(stderr.trim() || `isolated worker exited ${code}`));
+          return;
+        }
+        try {
+          const result = JSON.parse(stdout);
+          result.elapsedMs = Date.now() - started;
+          resolve4(result);
+        } catch {
+          resolve4(skipped("isolated worker returned no usable result"));
+        }
+      });
+    });
+  } catch (err) {
+    return skipped(`cannot prepare isolated worker: ${String(err).replace(/^Error: /, "")}`);
+  } finally {
+    clean();
+  }
+}
+var init_runner = __esm({
+  "src/dynamic/runner.ts"() {
+    "use strict";
+  }
+});
+
 // src/cli.ts
 import { Command } from "commander";
-import { resolve as resolve3, join as join14 } from "path";
+import { resolve as resolve3, join as join15 } from "path";
 import { homedir } from "os";
 
 // package.json
 var package_default = {
   name: "@kavishdua/proctor",
-  version: "1.1.0",
+  version: "1.2.0",
   description: "Catch AI agents gaming their test suites: deleted tests, skipped tests, weakened assertions, hardcoded outputs",
   homepage: "https://github.com/catfish-1234/proctor#readme",
   bugs: {
@@ -126,6 +280,7 @@ var package_default = {
   },
   dependencies: {
     "@anthropic-ai/sdk": "^0.132.0",
+    acorn: "^8.19.0",
     "brace-expansion": "^5.0.12",
     commander: "^14.0.3",
     "parse-diff": "0.12.0",
@@ -719,6 +874,14 @@ function normalizeConfig(config) {
     warn(`config 'aiModel' must be a string; ignoring it`);
     delete out.aiModel;
   }
+  if (config.dynamic !== void 0 && typeof config.dynamic !== "boolean") {
+    warn("config 'dynamic' must be a boolean; ignoring it");
+    delete out.dynamic;
+  }
+  if (config.dynamicTimeoutMs !== void 0 && (!Number.isSafeInteger(config.dynamicTimeoutMs) || config.dynamicTimeoutMs < 1 || config.dynamicTimeoutMs > 2147483647)) {
+    warn("config 'dynamicTimeoutMs' must be an integer from 1 to 2147483647; ignoring it");
+    delete out.dynamicTimeoutMs;
+  }
   return out;
 }
 async function buildContext(cwd, files, opts) {
@@ -816,7 +979,9 @@ async function buildContext(cwd, files, opts) {
     approvedTestChanges: config.approvedTestChanges,
     commitMessage,
     snapshotGlobs,
-    aiModel
+    aiModel,
+    ...config.dynamic !== void 0 ? { dynamic: config.dynamic } : {},
+    ...config.dynamicTimeoutMs !== void 0 ? { dynamicTimeoutMs: config.dynamicTimeoutMs } : {}
   };
 }
 
@@ -6315,6 +6480,24 @@ function jsonReport(findings) {
 
 // src/reporters/sarif.ts
 import { createHash } from "crypto";
+
+// src/dynamic/metadata.ts
+var DYNAMIC_METADATA = Object.fromEntries([
+  ["DY001", "OriginalTestRegression", "Previously passing original tests fail on new code"],
+  ["DY002", "NumericBranchContradiction", "A literal branch contradicts an executed numeric, string or boolean reference"],
+  ["DY003", "ExpectedLiteralContradiction", "An expectation-only edit changes a test outcome on unchanged code"],
+  ["DY004", "SurvivingSourceMutation", "A changed statement in a called function can be mutated without a failing test"],
+  ["DY005", "InconsistentRepeatedTest", "A test with a new sleep or retry has inconsistent outcomes"]
+].map(([id, name, description]) => [id, {
+  name,
+  shortDescription: description,
+  fullDescription: `${description}. Opt-in runtime evidence is heuristic and cannot establish intent. See README for the exact scope and limits.`,
+  defaultLevel: "warning",
+  fix: "Review the named commands and results, correct the behavior or test, and add a focused regression test.",
+  helpUri: "https://github.com/catfish-1234/proctor#dynamic-checks"
+}]));
+
+// src/reporters/sarif.ts
 function levelFor(severity) {
   if (severity === "error") return "error";
   if (severity === "warn") return "warning";
@@ -6324,7 +6507,7 @@ function fingerprint(verifierId, file, line) {
   return createHash("sha256").update(`${verifierId}:${file}:${line}`).digest("hex");
 }
 function sarifReport(findings) {
-  const rules = Object.entries(RULE_METADATA).map(([id, meta]) => ({
+  const rules = Object.entries({ ...RULE_METADATA, ...Object.fromEntries(Object.entries(DYNAMIC_METADATA).filter(([id]) => findings.some((f) => f.verifierId === id))) }).map(([id, meta]) => ({
     id,
     name: meta.name,
     shortDescription: { text: meta.shortDescription },
@@ -7836,13 +8019,13 @@ async function readStdin() {
 }
 var program = new Command();
 program.name("proctor").description("AI agent test-tampering guard").version(package_default.version);
-program.command("check [path]").description("Check staged, unstaged, and untracked changes for test tampering").option("--staged", "analyze only staged changes").option("--uncommitted", "explicitly analyze the default scope: staged, unstaged, and untracked changes together").option("--base <ref>", "analyze changes against a base ref (e.g. origin/main or a commit SHA) instead of staged/working-tree changes, for CI, where nothing is staged in a fresh checkout").option("--ci", "show only errors in the text report; warnings do not affect the exit code").option("--json", "output findings as JSON to stdout").option("--sarif", "output SARIF 2.1.0 JSON to stdout").option("--ai", "enable the networked LLM judge (requires ANTHROPIC_API_KEY)").option("--rules <ids>", "comma-separated list of verifier IDs to run (narrows the enabled set, e.g. RH001,RH003)").option("--wi", "also run the remaining opt-in work-integrity checks (WI1xx)").option("--all-checks", "alias for --wi: add the entire WI family to the configured checks").option("--explain <id>", "print the full explanation for a verifier ID and exit, no diff analysis").option("--fix", "with --explain, print what an honest fix looks like instead of the rule description").option("--markdown <file>", 'also write a Markdown summary to this file, e.g. --markdown "$GITHUB_STEP_SUMMARY"').action(async (pathArg, options) => {
+program.command("check [path]").description("Check staged, unstaged, and untracked changes for test tampering").option("--staged", "analyze only staged changes").option("--uncommitted", "explicitly analyze the default scope: staged, unstaged, and untracked changes together").option("--base <ref>", "analyze changes against a base ref (e.g. origin/main or a commit SHA) instead of staged/working-tree changes, for CI, where nothing is staged in a fresh checkout").option("--ci", "show only errors in the text report; warnings do not affect the exit code").option("--json", "output findings as JSON to stdout").option("--sarif", "output SARIF 2.1.0 JSON to stdout").option("--dynamic", "run isolated extra checks using the project tests (opt-in)").option("--dynamic-timeout <ms>", "overall dynamic budget in milliseconds (default 60000)").option("--ai", "enable the networked LLM judge (requires ANTHROPIC_API_KEY)").option("--rules <ids>", "comma-separated list of verifier IDs to run (narrows the enabled set, e.g. RH001,RH003)").option("--wi", "also run the remaining opt-in work-integrity checks (WI1xx)").option("--all-checks", "alias for --wi: add the entire WI family to the configured checks").option("--explain <id>", "print the full explanation for a verifier ID and exit, no diff analysis").option("--fix", "with --explain, print what an honest fix looks like instead of the rule description").option("--markdown <file>", 'also write a Markdown summary to this file, e.g. --markdown "$GITHUB_STEP_SUMMARY"').action(async (pathArg, options) => {
   if (options.fix && !options.explain) {
     process.stderr.write("proctor: --fix only applies with --explain, e.g. proctor check --explain RH001 --fix\n");
     process.exit(2);
   }
   if (options.explain) {
-    const meta = RULE_METADATA[options.explain];
+    const meta = RULE_METADATA[options.explain] ?? DYNAMIC_METADATA[options.explain];
     if (!meta) {
       process.stderr.write(`proctor: unknown verifier ID '${options.explain}'
 `);
@@ -7892,6 +8075,10 @@ Honest fix: proctor check --explain ${options.explain} --fix
 `);
     process.exit(0);
   }
+  if (options.dynamicTimeout !== void 0 && (!Number.isSafeInteger(Number(options.dynamicTimeout)) || Number(options.dynamicTimeout) < 1 || Number(options.dynamicTimeout) > 2147483647)) {
+    process.stderr.write("proctor: --dynamic-timeout must be an integer from 1 to 2147483647 milliseconds\n");
+    process.exit(2);
+  }
   const selectedScopes = [options.base !== void 0, options.staged === true, options.uncommitted === true].filter(Boolean).length;
   if (selectedScopes > 1) {
     process.stderr.write("proctor: choose only one diff scope: --staged, --uncommitted, or --base <ref>\n");
@@ -7957,6 +8144,24 @@ Honest fix: proctor check --explain ${options.explain} --fix
     process.exitCode = 3;
     return;
   }
+  if (options.dynamic || ctx.dynamic === true) {
+    const { runDynamic: runDynamic2 } = await Promise.resolve().then(() => (init_runner(), runner_exports));
+    const dynamic = await runDynamic2({
+      cwd,
+      workerPath: fileURLToPath3(new URL("./dynamic-worker.js", import.meta.url)),
+      base: options.base,
+      staged: options.staged,
+      files,
+      testPathGlobs: ctx.testPathGlobs,
+      timeoutMs: options.dynamicTimeout !== void 0 ? Number(options.dynamicTimeout) : ctx.dynamicTimeoutMs
+    });
+    findings.push(...dynamic.findings);
+    process.stderr.write(dynamic.status === "skipped" ? `dynamic: skipped, ${dynamic.reason}
+` : `dynamic: completed, ${dynamic.runs.length} runs, ${dynamic.findings.length} findings, ${dynamic.elapsedMs}ms
+`);
+    for (const note of dynamic.notes) process.stderr.write(`dynamic: ${note}
+`);
+  }
   if (options.markdown) {
     try {
       await appendFile(options.markdown, markdownReport(findings) + "\n", "utf8");
@@ -7968,7 +8173,7 @@ Honest fix: proctor check --explain ${options.explain} --fix
   if (options.sarif) {
     const sarif = sarifReport(findings);
     const hasError2 = findings.some((f) => f.severity === "error");
-    const hasWarn2 = findings.some((f) => f.severity === "warn");
+    const hasWarn2 = findings.some((f) => f.severity === "warn" && !["DY002", "DY004"].includes(f.verifierId));
     await new Promise((resolve4) => {
       process.stdout.write(sarif + "\n", () => {
         process.exitCode = hasError2 ? 2 : hasWarn2 && !options.ci ? 1 : 0;
@@ -7987,7 +8192,7 @@ Honest fix: proctor check --explain ${options.explain} --fix
     if (receipt.status === "honest-pass" && receipt.approvedCount === 0 && !options.ci) process.stdout.write(badgeLine(receipt) + "\n");
   }
   const hasError = findings.some((f) => f.severity === "error");
-  const hasWarn = findings.some((f) => f.severity === "warn");
+  const hasWarn = findings.some((f) => f.severity === "warn" && !["DY002", "DY004"].includes(f.verifierId));
   process.exitCode = hasError ? 2 : hasWarn && !options.ci ? 1 : 0;
 });
 program.command("install-hook").description("Install git pre-commit hook").action(async () => {
@@ -8003,7 +8208,7 @@ program.command("stop-hook").description("Claude Code Stop hook: reads stdin JSO
   process.exit(exitCode);
 });
 program.command("install-claude-hook").description("Install Claude Code Stop hook").option("--global", "write to ~/.claude/settings.json").action(async (options) => {
-  const result = await installStopHook(options.global ? join14(homedir(), ".claude") : join14(process.cwd(), ".claude"));
+  const result = await installStopHook(options.global ? join15(homedir(), ".claude") : join15(process.cwd(), ".claude"));
   if (result.status === "invalid-json") {
     process.stderr.write(`proctor: ${result.path} exists but is not valid JSON; fix it manually and re-run
 `);
@@ -8035,7 +8240,7 @@ program.command("setup").description("One-command install: writes the ruleset to
     process.exitCode = 1;
   }
   if (targets.some((a) => a.id === "claude-code")) {
-    const stop = await installStopHook(join14(cwd, ".claude"));
+    const stop = await installStopHook(join15(cwd, ".claude"));
     if (stop.status === "invalid-json") {
       process.stderr.write(`proctor: ${stop.path} is not valid JSON, so the Stop hook was not installed; fix it and re-run
 `);
@@ -8248,7 +8453,7 @@ program.command("approve <rule> <file>").description("Record a genuine test chan
     process.stderr.write("proctor: --reason cannot be empty\n");
     process.exit(2);
   }
-  const configPath = join14(process.cwd(), "proctor.config.json");
+  const configPath = join15(process.cwd(), "proctor.config.json");
   let config = {};
   try {
     config = JSON.parse(await readFile11(configPath, "utf8"));

package/dist/dynamic-worker.js

@@ -0,0 +1,776 @@
+// src/dynamic-worker.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
+import { spawnSync as spawnSync4 } from "child_process";
+import picomatch from "picomatch";
+
+// src/dynamic/snapshots.ts
+import { spawnSync } from "child_process";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, symlinkSync, writeFileSync, copyFileSync, chmodSync } from "fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+var EXCLUDED = /^(?:bench\/(?:dynamic|heldout)(?:\/|$))|(?:^|\/)(?:\.git|node_modules|\.venv|venv|__pycache__)(?:\/|$)/;
+var MAX_BYTES = 64 * 1024 * 1024;
+function git(cwd, args, input) {
+  const r = spawnSync("git", args, { cwd, input, maxBuffer: MAX_BYTES, timeout: 15e3, env: { ...process.env, GIT_OPTIONAL_LOCKS: "0", GIT_CONFIG_NOSYSTEM: "1" } });
+  if (r.status !== 0) throw Error("cannot read local Git snapshot");
+  return r.stdout;
+}
+function validPath(path) {
+  return !isAbsolute(path) && !path.split("/").some((p) => p === ".." || p === "" || p.includes("\\"));
+}
+function snapshot(cwd, ref) {
+  const entries = git(cwd, ref ? ["ls-tree", "-rz", "--full-tree", ref] : ["ls-files", "--stage", "-z"]).toString().split("\0").filter(Boolean).map((row) => {
+    const tab = row.indexOf("	");
+    const meta = row.slice(0, tab).split(" "), path = row.slice(tab + 1);
+    return { path, mode: meta[0], sha: meta[ref ? 2 : 1] };
+  }).filter((e) => !EXCLUDED.test(e.path));
+  if (entries.some((e) => !validPath(e.path) || !/^100(644|755)$/.test(e.mode))) throw Error("not run: symlink, submodule or unsafe tracked path");
+  const blobs = git(cwd, ["cat-file", "--batch"], entries.map((e) => e.sha).join("\n") + "\n");
+  const files = /* @__PURE__ */ new Map();
+  let offset = 0;
+  for (const entry of entries) {
+    const newline = blobs.indexOf(10, offset);
+    const [sha, kind, sizeText] = blobs.subarray(offset, newline).toString().split(" ");
+    const size = Number(sizeText);
+    if (sha !== entry.sha || kind !== "blob" || !Number.isSafeInteger(size)) throw Error("unreadable Git blob");
+    offset = newline + 1;
+    files.set(entry.path, { data: blobs.subarray(offset, offset + size), mode: parseInt(entry.mode, 8) & 511 });
+    offset += size + 1;
+  }
+  return files;
+}
+function loadSnapshots(options2) {
+  const top = git(options2.cwd, ["rev-parse", "--show-toplevel"]).toString().trim();
+  if (resolve(top) !== resolve(options2.cwd)) throw Error("not run: invoke dynamic checks at the repository root");
+  const ref = options2.base ? git(top, ["merge-base", "--", options2.base, "HEAD"]).toString().trim() : "HEAD";
+  const old = snapshot(top, ref);
+  const next = snapshot(top, options2.staged ? void 0 : "HEAD");
+  if (!options2.base && !options2.staged) {
+    for (const file of options2.files) {
+      if (file.from && file.from !== "/dev/null" && file.from !== file.to) next.delete(file.from);
+      const path = file.to;
+      if (!path || path === "/dev/null") {
+        if (file.from) next.delete(file.from);
+        continue;
+      }
+      if (!validPath(path) || EXCLUDED.test(path)) continue;
+      const disk = join(top, path);
+      if (!existsSync(disk)) {
+        next.delete(path);
+        continue;
+      }
+      const stat = lstatSync(disk);
+      if (!stat.isFile()) throw Error("not run: changed symlink or non-regular file");
+      if (stat.size > MAX_BYTES) throw Error("snapshot size limit");
+      next.set(path, { data: readFileSync(disk), mode: stat.mode & 511 });
+    }
+  }
+  for (const tree of [old, next]) {
+    if ([...tree.values()].reduce((sum, f) => sum + f.data.length, 0) > MAX_BYTES) throw Error("snapshot size limit");
+  }
+  for (const path of ["package.json", "package-lock.json", "yarn.lock", "pnpm-lock.yaml", "requirements.txt", "poetry.lock", "uv.lock"]) {
+    if (old.get(path)?.data.toString() !== next.get(path)?.data.toString()) throw Error(`not run: dependency manifest changed (${path})`);
+  }
+  return { old, next };
+}
+function copyDependencies(source, target, sourceRoot, targetRoot) {
+  const stat = lstatSync(source);
+  if (stat.isSymbolicLink()) {
+    const destination = resolve(dirname(source), readlinkSync(source));
+    const rel = relative(sourceRoot, destination);
+    if (rel.startsWith(".." + sep) || rel === ".." || isAbsolute(rel)) throw Error("not run: dependency symlink points outside node_modules");
+    symlinkSync(relative(dirname(target), join(targetRoot, rel)), target);
+  } else if (stat.isDirectory()) {
+    mkdirSync(target, { recursive: true });
+    for (const name of readdirSync(source)) copyDependencies(join(source, name), join(target, name), sourceRoot, targetRoot);
+  } else if (stat.isFile()) {
+    copyFileSync(source, target);
+    chmodSync(target, stat.mode & 511);
+  }
+}
+function materialize(tree, dir, cwd) {
+  mkdirSync(dir, { recursive: true });
+  for (const [path, file] of tree) {
+    const target = join(dir, path);
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, file.data, { mode: file.mode });
+  }
+  const deps = join(cwd, "node_modules");
+  if (existsSync(deps)) copyDependencies(deps, join(dir, "node_modules"), deps, join(dir, "node_modules"));
+}
+
+// src/dynamic/adapters.ts
+import { stripVTControlCharacters } from "util";
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+function detectAdapter(tree, tests) {
+  const pkgText = tree.get("package.json")?.data.toString();
+  if (pkgText) {
+    const pkg = JSON.parse(pkgText);
+    const script = pkg.scripts?.test;
+    if (typeof script === "string") {
+      if (/\bvitest\b/.test(script)) return { command: "npm", args: ["run", "test", "--", "--run", "--reporter=json"], kind: "vitest" };
+      if (/\bjest\b/.test(script)) return { command: "npm", args: ["run", "test", "--", "--json", "--runInBand", "--watch=false"], kind: "jest" };
+      if (/\bnode\b.*--test\b/.test(script)) return { command: "npm", args: ["run", "test"], kind: "tap" };
+      throw Error("not run: unrecognized package test script (node:test, jest and vitest supported)");
+    }
+  }
+  const js = tests.filter((p) => /\.(?:mjs|cjs|js)$/.test(p));
+  if (js.length) return { command: process.execPath, args: ["--test", "--test-reporter=tap", ...js], kind: "tap" };
+  const py = tests.filter((p) => p.endsWith(".py"));
+  if (py.length) {
+    const pytest = ["pytest.ini", "conftest.py"].some((p) => tree.has(p)) || /\[tool\.pytest/.test(tree.get("pyproject.toml")?.data.toString() ?? "") || py.some((p) => /(?:^|\n)\s*(?:import pytest|from pytest\b)/.test(tree.get(p)?.data.toString() ?? ""));
+    return pytest ? { command: "python3", args: ["-m", "pytest", "-q", "--tb=short", "--junitxml=.proctor-junit.xml"], kind: "pytest" } : { command: "python3", args: ["-m", "unittest", "discover", "-v"], kind: "unittest", testFiles: py };
+  }
+  throw Error("not run: no supported Node or Python tests found");
+}
+function uniqueOutcomes(rows) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const [id] of rows) counts.set(id, (counts.get(id) ?? 0) + 1);
+  return {
+    passed: rows.filter(([id, pass]) => pass && counts.get(id) === 1).map(([id]) => id),
+    failed: rows.filter(([id, pass]) => !pass && counts.get(id) === 1).map(([id]) => id)
+  };
+}
+function parseResults(kind, stdout, stderr, junit = "") {
+  const rows = [];
+  if (kind === "tap") {
+    for (const match of stdout.matchAll(/^\s*(not )?ok \d+ - (.+?)(?: #.*)?$/gm)) {
+      if (/ # (?:SKIP|TODO)/i.test(match[0])) continue;
+      rows.push([match[2].trim(), !match[1]]);
+    }
+  } else if (kind === "unittest") {
+    for (const match of stderr.matchAll(/^(.+? \(.+?\)) \.\.\. (ok|FAIL|ERROR)\s*$/gm)) rows.push([match[1], match[2] === "ok"]);
+  } else if (kind === "pytest") {
+    const decode = (s) => s.replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+    for (const m of junit.matchAll(/<testcase\b([^>]*?)(?:\/>|>([\s\S]*?)<\/testcase>)/g)) {
+      if (/<skipped\b/.test(m[2] ?? "")) continue;
+      const cls = /\bclassname="([^"]*)"/.exec(m[1])?.[1];
+      const name = /\bname="([^"]*)"/.exec(m[1])?.[1];
+      if (name) rows.push([decode(`${cls ?? ""}::${name}`), !/<(?:failure|error)\b/.test(m[2] ?? "")]);
+    }
+  } else {
+    let result2;
+    for (const stream of [stdout, stderr]) {
+      const start = stream.indexOf("{"), end = stream.lastIndexOf("}");
+      if (start < 0 || end < start) continue;
+      try {
+        const candidate = JSON.parse(stream.slice(start, end + 1));
+        if (Array.isArray(candidate.testResults)) {
+          result2 = candidate;
+          break;
+        }
+      } catch {
+      }
+    }
+    if (!result2) throw Error("test reporter did not produce readable JSON");
+    for (const suite of result2.testResults ?? []) {
+      for (const test of suite.assertionResults ?? []) {
+        if (test.status === "passed" || test.status === "failed") rows.push([test.fullName ?? [...test.ancestorTitles ?? [], test.title].join(" "), test.status === "passed"]);
+      }
+    }
+  }
+  return uniqueOutcomes(rows);
+}
+var PYTHON_FUNCTIONS = `import ast,json,sys
+tree=ast.parse(open(sys.argv[1],encoding='utf-8').read())
+print(json.dumps([n.name for n in tree.body if isinstance(n,(ast.FunctionDef,ast.AsyncFunctionDef)) and n.name.startswith('test_')]))
+`;
+var PYTHON_CALL = `import asyncio,importlib.util,inspect,os,sys
+file,name=sys.argv[1:]
+sys.path.insert(0,os.path.dirname(os.path.abspath(file)))
+spec=importlib.util.spec_from_file_location('proctor_test',file)
+module=importlib.util.module_from_spec(spec)
+sys.modules[spec.name]=module
+spec.loader.exec_module(module)
+result=getattr(module,name)()
+if inspect.isawaitable(result): asyncio.run(result)
+`;
+function runPythonFiles(adapter, dir, label, discovery, env) {
+  if (!adapter.testFiles?.length) throw Error(`cannot run ${label}: no Python files for direct execution`);
+  const passed = [], failed = [], details = [];
+  const fileRuns = [];
+  const helper = ".proctor-python-test.py";
+  writeFileSync2(join2(dir, helper), PYTHON_CALL);
+  for (const file of adapter.testFiles) {
+    const collected = spawnSync2(adapter.command, ["-c", PYTHON_FUNCTIONS, file], { cwd: dir, encoding: "utf8", maxBuffer: 128 * 1024, env });
+    if (collected.error || collected.signal) throw Error(`cannot inspect ${file}: ${collected.error?.message ?? collected.signal}`);
+    const names = collected.status === 0 ? JSON.parse(collected.stdout) : [];
+    if (new Set(names).size !== names.length) throw Error(`cannot run ${label}: duplicate Python function names in ${file}`);
+    const invocations = names.length ? names.map((name) => ({ id: `${file}::${name}`, args: [helper, file, name] })) : [{ id: file, args: [file] }];
+    for (const { id, args } of invocations) {
+      const r = spawnSync2(adapter.command, args, { cwd: dir, encoding: "utf8", maxBuffer: 2 * 1024 * 1024, env });
+      if (r.error || r.signal || r.status === null) throw Error(`cannot run ${label}, ${file}: ${r.error?.message ?? r.signal ?? "no exit code"}`);
+      fileRuns.push({ file: id, command: [adapter.command, ...args].join(" "), exitCode: r.status });
+      (r.status === 0 ? passed : failed).push(id);
+      details.push(`${id}: exit ${r.status}
+${r.stdout ?? ""}${r.stderr ?? ""}`);
+    }
+  }
+  return {
+    label,
+    command: `${adapter.command} -m unittest discover -v, then direct Python files`,
+    exitCode: failed.length ? 1 : 0,
+    passed,
+    failed,
+    fileRuns,
+    detail: stripVTControlCharacters(`${discovery}
+${details.join("\n")}`).slice(-1200)
+  };
+}
+function runTests(adapter, dir, label, extraEnv = {}) {
+  const artifact = join2(dir, ".proctor-junit.xml");
+  if (adapter.kind === "pytest") rmSync(artifact, { force: true });
+  const env = { ...process.env, ...extraEnv, PWD: dir, ...adapter.kind === "tap" && adapter.command === "npm" ? { NODE_OPTIONS: "--test-reporter=tap" } : {} };
+  const r = spawnSync2(adapter.command, adapter.args, { cwd: dir, encoding: "utf8", maxBuffer: 2 * 1024 * 1024, env });
+  if (r.error || r.signal) throw Error(`cannot run ${label}: ${r.error?.message ?? r.signal}`);
+  const stdout = r.stdout ?? "", stderr = r.stderr ?? "";
+  const outcomes = parseResults(adapter.kind, stdout, stderr, existsSync2(artifact) ? readFileSync2(artifact, "utf8") : "");
+  if (adapter.kind === "unittest") {
+    const real = [...outcomes.passed, ...outcomes.failed].filter((id) => !id.includes("unittest.loader._FailedTest"));
+    const discovered = Number(/^Ran (\d+) tests? in /m.exec(stderr)?.[1] ?? 0);
+    const collectionFailed = outcomes.failed.some((id) => id.includes("unittest.loader._FailedTest"));
+    if (!real.length && (discovered === 0 || collectionFailed)) return runPythonFiles(adapter, dir, label, stdout + stderr, env);
+    if (collectionFailed) throw Error(`cannot run ${label}: unittest collection failed beside real cases`);
+  }
+  if (outcomes.passed.length + outcomes.failed.length === 0) throw Error(`cannot run ${label}: no named test results (exit ${r.status}); ${String(stdout + stderr).replace(/\s+/g, " ").slice(-300)}`);
+  if (r.status !== 0 && outcomes.failed.length === 0) throw Error(`cannot run ${label}: command exited ${r.status} without a named failing test`);
+  if (r.status === 0 && outcomes.failed.length) throw Error(`cannot run ${label}: reporter and exit code disagree`);
+  return {
+    label,
+    command: (adapter.kind === "tap" && adapter.command === "npm" ? "NODE_OPTIONS=--test-reporter=tap " : "") + [adapter.command, ...adapter.args].join(" "),
+    exitCode: r.status,
+    ...outcomes,
+    detail: stripVTControlCharacters(String(stdout + stderr)).slice(-1200)
+  };
+}
+
+// src/dynamic/signals.ts
+var LITERAL = String.raw`(?:-?\d+(?:\.\d+)?|true|false|None|True|False|null|"[^"\n]*"|'[^'\n]*')`;
+var ASSERTION_PATTERNS = [
+  new RegExp(String.raw`^\s*((?:assert\.(?:strictEqual|equal|deepEqual|deepStrictEqual)|self\.assertEqual)\(.+?,\s*)(${LITERAL})(\s*\)\s*;?\s*)$`),
+  new RegExp(String.raw`^\s*(expect\(.+?\)\.to(?:Be|Equal|StrictEqual)\(\s*)(${LITERAL})(\s*\)\s*;?\s*)$`),
+  new RegExp(String.raw`^(\s*assert\s+.+?\s*==\s*)(${LITERAL})(\s*)$`)
+];
+var assertion = (line) => ASSERTION_PATTERNS.map((pattern) => pattern.exec(line)).find(Boolean);
+function expectationChanges(before, after) {
+  const assertions = (text) => {
+    const map = /* @__PURE__ */ new Map();
+    for (const line of text.split("\n")) {
+      const match = assertion(line);
+      if (match) map.set(match[1].trim() + match[3].trim(), match[2]);
+    }
+    return map;
+  };
+  const a = assertions(before), b = assertions(after);
+  return [...a].filter(([key, value]) => b.has(key) && b.get(key) !== value).map(([key, value]) => ({ before: value, after: b.get(key) }));
+}
+function expectedEdits(before, after) {
+  return expectationChanges(before, after).length > 0;
+}
+function expectationOnlyEdit(before, after) {
+  const canonical2 = (text) => text.split("\n").map((line) => {
+    const match = assertion(line);
+    return match ? `${match[1]}__EXPECTED_LITERAL__${match[3]}` : line;
+  }).join("\n");
+  return expectedEdits(before, after) && canonical2(before) === canonical2(after);
+}
+function documentedIntent(old, next) {
+  for (const [path, file] of next) {
+    if (!/(?:^|\/)(?:SPEC[^/]*|CHANGELOG[^/]*)\.(?:md|rst|txt)$/i.test(path)) continue;
+    const before = old.get(path)?.data.toString() ?? "";
+    const previous = new Set(before.split("\n"));
+    if (file.data.toString().split("\n").some((line) => line.trim() && !/^\s*#/.test(line) && !previous.has(line))) return true;
+  }
+  return false;
+}
+function definesPythonFunction(text, name) {
+  for (const match of text.matchAll(/^\s*def (\w+)\s*\(/gm)) {
+    if (match[1] === name) return true;
+  }
+  return false;
+}
+function locateTest(id, tree, tests) {
+  if (tests.includes(id) && tree.has(id)) return id;
+  const [plainFile, plainFunction] = id.split("::");
+  if (plainFunction && plainFile && tests.includes(plainFile) && tree.has(plainFile)) return plainFile;
+  const python = (/^(test\w+) \(/.exec(id)?.[1] ?? id.split("::").at(-1))?.replace(/\[.*$/, "");
+  const exact = tests.filter((p) => {
+    const text = tree.get(p)?.data.toString() ?? "";
+    return text.includes(`'${id}'`) || text.includes(`"${id}"`) || p.endsWith(".py") && !!python && definesPythonFunction(text, python);
+  });
+  if (exact.length) return exact.length === 1 ? exact[0] : void 0;
+  const nested = tests.filter((p) => [...(tree.get(p)?.data.toString() ?? "").matchAll(/\b(?:test|it)\s*\(\s*(['"])([^'"\n]+)\1/g)].some((m) => id.endsWith(" " + m[2])));
+  return nested.length === 1 ? nested[0] : void 0;
+}
+var UNARY_ARITHMETIC = /^(\w+)\s*[*+\/-]\s*-?\d+(?:\.\d+)?$/;
+var PY_BRANCH = /if\s+(\w+)\s*==\s*(-?\d+(?:\.\d+)?|True|False|"[^"\\\n]*"|'[^'\\\n]*')\s*:\s*return\s+(-?\d+(?:\.\d+)?|True|False|"[^"\\\n]*"|'[^'\\\n]*')/;
+var JS_BRANCH = /if\s*\(\s*(\w+)\s*===?\s*(-?\d+(?:\.\d+)?|true|false|"[^"\\\n]*"|'[^'\\\n]*')\s*\)\s*(?:\{\s*)?return\s+(-?\d+(?:\.\d+)?|true|false|"[^"\\\n]*"|'[^'\\\n]*');?\s*\}?/;
+function simpleReference(expression, arg, py) {
+  if (expression === arg) return true;
+  const numeric = UNARY_ARITHMETIC.exec(expression);
+  const method = /^(\w+)\.(\w+)\(\)$/.exec(expression);
+  const negate = /^(?:!\s*|not\s+)(\w+)$/.exec(expression);
+  const concat = /^(?:(\w+)\s*\+\s*(?:"[^"\\\n]*"|'[^'\\\n]*')|(?:"[^"\\\n]*"|'[^'\\\n]*')\s*\+\s*(\w+))$/.exec(expression);
+  return numeric?.[1] === arg || negate?.[1] === arg || concat?.[1] === arg || concat?.[2] === arg || method?.[1] === arg && (py ? ["lower", "upper", "strip"] : ["toLowerCase", "toUpperCase", "trim"]).includes(method[2]);
+}
+function probeLiteral(text) {
+  if (text.startsWith('"') || text.startsWith("'")) return text.slice(1, -1);
+  if (/^(?:true|True|false|False)$/.test(text)) return text === "true" || text === "True";
+  return Number(text);
+}
+function probeInputs(input) {
+  if (typeof input === "boolean") return [!input, input];
+  if (typeof input === "string") return [`${input}a`, input, `b${input}`];
+  return [input - 1, input, input + 1];
+}
+function pythonBody(text, name, arg) {
+  const header = `def ${name}(${arg}):`;
+  const start = text.indexOf(header);
+  if (start < 0 || start > 0 && text[start - 1] !== "\n") return void 0;
+  const lines = text.slice(start + header.length).split("\n");
+  const body = [];
+  for (const line of lines.slice(1)) {
+    if (line.trim() === "") {
+      body.push(line);
+      continue;
+    }
+    if (/^[ \t]/.test(line)) {
+      body.push(line);
+      continue;
+    }
+    break;
+  }
+  return body.length ? body.join("\n") : void 0;
+}
+function jsBody(text, name, arg) {
+  for (const marker of [`export function ${name}(${arg})`, `function ${name}(${arg})`]) {
+    const start = text.indexOf(marker);
+    if (start < 0) continue;
+    const open = text.indexOf("{", start + marker.length);
+    if (open < 0) return void 0;
+    const close = text.indexOf("\n}", open);
+    if (close < 0) return void 0;
+    return text.slice(open + 1, close);
+  }
+  return void 0;
+}
+function findProbes(old, next, isTest) {
+  const probes = [];
+  for (const [file, entry] of next) {
+    if (isTest(file) || !/\.(?:js|mjs|cjs|py)$/.test(file)) continue;
+    const before = old.get(file)?.data.toString(), after = entry.data.toString();
+    if (!before || before === after) continue;
+    const py = file.endsWith(".py");
+    const functions = py ? [...before.matchAll(/^def (\w+)\((\w+)\):\n[ \t]+return ([^\n]+)\n?/gm)] : [...before.matchAll(/(?:export\s+)?function (\w+)\((\w+)\)\s*\{\s*return\s+([^;{}\n]+);?\s*\}/g)];
+    for (const fn of functions) {
+      const [, name, arg, expression] = fn;
+      if (!simpleReference(expression.trim(), arg, py)) continue;
+      if (!py && !before.includes(`export function ${name}`) && !before.includes("module.exports") && !before.includes(`exports.${name}`)) continue;
+      const body = py ? pythonBody(after, name, arg) : jsBody(after, name, arg);
+      if (!body) continue;
+      const branchMatch = (py ? PY_BRANCH : JS_BRANCH).exec(body);
+      const branch = branchMatch && branchMatch[1] === arg ? branchMatch : void 0;
+      if (!branch || !body.includes(expression.trim())) continue;
+      const remainder = body.replace(branch[0], "").replace(/return\s+/, "").replace(/[;\s]/g, "");
+      if (remainder !== expression.replace(/\s/g, "")) continue;
+      probes.push({ file, name, input: probeLiteral(branch[2]), returned: probeLiteral(branch[3]), line: after.slice(0, after.indexOf(branch[0])).split("\n").length, language: py ? "python" : "js" });
+    }
+  }
+  return probes.slice(0, 8);
+}
+
+// src/dynamic/mutations.ts
+import { parse } from "acorn";
+import { spawnSync as spawnSync3 } from "child_process";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3, relative as relative2, sep as sep2 } from "path";
+import { fileURLToPath } from "url";
+var MUTATION_LIMIT = 4;
+function changedSourceLines(before, after) {
+  const a = before.split("\n"), b = after.split("\n");
+  if (a.length * b.length > 4e6) return /* @__PURE__ */ new Set();
+  const width = b.length + 1, rows = new Uint16Array((a.length + 1) * width);
+  for (let i2 = a.length - 1; i2 >= 0; i2--) for (let j2 = b.length - 1; j2 >= 0; j2--) {
+    rows[i2 * width + j2] = a[i2] === b[j2] ? rows[(i2 + 1) * width + j2 + 1] + 1 : Math.max(rows[(i2 + 1) * width + j2], rows[i2 * width + j2 + 1]);
+  }
+  const changed = /* @__PURE__ */ new Set();
+  let i = 0, j = 0;
+  while (i < a.length || j < b.length) {
+    if (i < a.length && j < b.length && a[i] === b[j]) {
+      i++;
+      j++;
+    } else if (j < b.length && (i === a.length || rows[i * width + j + 1] >= rows[(i + 1) * width + j])) {
+      changed.add(++j);
+    } else i++;
+  }
+  return changed;
+}
+var PYTHON_PROFILE = `import atexit,json,os,sys,threading
+root=os.getcwd()+os.sep
+calls=set()
+def record(frame,event,arg):
+    if event=='call' and frame.f_code.co_filename.startswith(root):
+        calls.add((frame.f_code.co_filename,frame.f_code.co_firstlineno))
+def save():
+    with open(os.path.join(os.environ['PROCTOR_CALLS'],'python-'+str(os.getpid())+'.json'),'w') as out:
+        json.dump(sorted(calls),out)
+sys.setprofile(record)
+threading.setprofile(record)
+atexit.register(save)
+`;
+function coverageEnvironment(dir) {
+  const path = join3(dir, ".proctor-calls"), hooks = join3(path, "hooks");
+  mkdirSync2(hooks, { recursive: true });
+  writeFileSync3(join3(hooks, "sitecustomize.py"), PYTHON_PROFILE);
+  return { path, env: { NODE_V8_COVERAGE: path, PROCTOR_CALLS: path, PYTHONPATH: hooks } };
+}
+function readCalls(path, dir) {
+  const calls = { js: /* @__PURE__ */ new Map(), python: /* @__PURE__ */ new Map() };
+  for (const name of readdirSync2(path).filter((p) => p.endsWith(".json")).slice(0, 100)) {
+    try {
+      const text = readFileSync3(join3(path, name), "utf8");
+      if (text.length > 4 * 1024 * 1024) continue;
+      const data = JSON.parse(text);
+      if (name.startsWith("python-")) {
+        for (const [file, line] of data) calls.python.set(file, [...calls.python.get(file) ?? [], line]);
+      } else for (const script of data.result ?? []) {
+        if (!script.url.startsWith("file:")) continue;
+        const file = fileURLToPath(script.url);
+        if (relative2(dir, file).startsWith(".." + sep2)) continue;
+        const ranges = script.functions.map((fn) => fn.ranges[0]).filter((r) => r.count > 0).map((r) => ({ start: r.startOffset, end: r.endOffset }));
+        calls.js.set(file, [...calls.js.get(file) ?? [], ...ranges]);
+      }
+    } catch {
+    }
+  }
+  return calls;
+}
+var OMIT = /* @__PURE__ */ Symbol("deleted statement");
+function canonical(value, target, replacement) {
+  if (target && value === target) return canonical(replacement);
+  if (Array.isArray(value)) return value.map((v) => canonical(v, target, replacement)).filter((v) => v !== OMIT);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(Object.entries(value).filter(([key]) => !["start", "end", "loc", "raw"].includes(key)).sort(([a], [b]) => a.localeCompare(b)).map(([key, v]) => [key, canonical(v, target, replacement)]));
+}
+var parseJs = (source) => parse(source, { ecmaVersion: "latest", sourceType: "module", locations: true });
+function jsMutations(before, source, called) {
+  let ast, previous;
+  try {
+    ast = parseJs(source);
+    previous = parseJs(before);
+  } catch {
+    return [];
+  }
+  const fingerprint = (node) => JSON.stringify(canonical(node));
+  const original = /* @__PURE__ */ new Set();
+  function remember(node) {
+    if (["ReturnStatement", "ThrowStatement", "ExpressionStatement", "VariableDeclaration", "IfStatement"].includes(node.type)) original.add(fingerprint(node));
+    if (node.type === "IfStatement") original.add(fingerprint(node.test));
+    for (const value of Object.values(node)) {
+      if (Array.isArray(value)) {
+        for (const child of value) if (child?.type) remember(child);
+      } else if (value && typeof value === "object" && "type" in value) remember(value);
+    }
+  }
+  remember(previous);
+  const changed = changedSourceLines(before, source), candidates = [];
+  const used = /* @__PURE__ */ new Set();
+  function visit(node, fn) {
+    if (candidates.length >= MUTATION_LIMIT) return;
+    if (["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"].includes(node.type)) fn = node;
+    const line = node.loc.start.line;
+    if (fn && changed.has(line) && !used.has(line) && !original.has(fingerprint(node)) && called.some((r) => r.start === fn.start && r.end === fn.end)) {
+      const start = source.lastIndexOf("\n", node.start - 1) + 1;
+      const end = source.indexOf("\n", node.end);
+      const lineEnd = end < 0 ? source.length : end;
+      const fullLine = /^\s*$/.test(source.slice(start, node.start)) && /^\s*$/.test(source.slice(node.end, lineEnd));
+      const attempts = [];
+      if (fullLine && node.loc.end.line === line && ["ReturnStatement", "ThrowStatement", "ExpressionStatement", "VariableDeclaration", "IfStatement"].includes(node.type)) {
+        attempts.push({ text: source.slice(0, node.start) + source.slice(node.end), replacement: OMIT, target: node, operation: "delete statement" });
+      }
+      if (node.type === "IfStatement") {
+        const test = node.test;
+        if (test.loc.end.line === line && !original.has(fingerprint(test))) attempts.push({
+          text: source.slice(0, test.start) + `!(${source.slice(test.start, test.end)})` + source.slice(test.end),
+          target: test,
+          replacement: { type: "UnaryExpression", operator: "!", prefix: true, argument: canonical(test) },
+          operation: "negate condition"
+        });
+      }
+      for (const attempt of attempts) {
+        try {
+          const parsed = parseJs(attempt.text);
+          if (JSON.stringify(canonical(parsed)) !== JSON.stringify(canonical(ast, attempt.target, attempt.replacement))) continue;
+          candidates.push({ line, functionName: fn.id?.name ?? "<anonymous>", source: attempt.text, operation: attempt.operation });
+          used.add(line);
+          break;
+        } catch {
+        }
+      }
+    }
+    for (const value of Object.values(node)) {
+      if (Array.isArray(value)) {
+        for (const child of value) if (child?.type) visit(child, fn);
+      } else if (value && typeof value === "object" && "type" in value) visit(value, fn);
+    }
+  }
+  visit(ast);
+  return candidates.slice(0, MUTATION_LIMIT);
+}
+var PYTHON_MUTATIONS = `import ast,copy,json,sys
+data=json.load(sys.stdin)
+source=data['source']
+lines=source.splitlines(keepends=True)
+tree=ast.parse(source)
+original={ast.dump(n) for n in ast.walk(ast.parse(data['before'])) if isinstance(n,(ast.stmt,ast.expr))}
+# Require a lossless syntax round trip before editing this file.
+assert ast.dump(ast.parse(ast.unparse(tree)))==ast.dump(tree)
+changed=set(data['changed'])
+called=set(data['called'])
+out=[]
+used=set()
+def offset(line,col):
+    return sum(map(len,lines[:line-1]))+len(lines[line-1].encode('utf-8')[:col].decode('utf-8'))
+class Replace(ast.NodeTransformer):
+    def __init__(self,target,replacement): self.target,self.replacement=target,replacement
+    def visit(self,node):
+        if node is self.target: return self.replacement
+        return super().visit(node)
+def visit(node,fn=None):
+    if len(out)>=4: return
+    if isinstance(node,(ast.FunctionDef,ast.AsyncFunctionDef)):
+        fn=node if not node.decorator_list and isinstance(node,ast.FunctionDef) else None
+    line=getattr(node,'lineno',0)
+    if fn and fn.lineno in called and line in changed and line not in used and ast.dump(node) not in original:
+        attempts=[]
+        if isinstance(node,(ast.Return,ast.Raise,ast.Assign,ast.AnnAssign,ast.AugAssign,ast.Expr,ast.If)):
+            start=offset(line,node.col_offset)
+            end=offset(node.end_lineno,node.end_col_offset)
+            if node.end_lineno==line and not source[offset(line,0):start].strip() and not source[end:offset(line,len(lines[line-1].encode('utf-8')))].strip():
+                attempts.append((source[:start]+source[end:],node,None,'delete statement'))
+        target=node.test if isinstance(node,ast.If) else node.value if isinstance(node,ast.Return) else None
+        if target is not None and target.lineno==target.end_lineno and ast.dump(target) not in original:
+            start=offset(target.lineno,target.col_offset)
+            end=offset(target.end_lineno,target.end_col_offset)
+            replacement=ast.UnaryOp(op=ast.Not(),operand=copy.deepcopy(target))
+            attempts.append((source[:start]+'not ('+source[start:end]+')'+source[end:],target,replacement,'negate condition' if isinstance(node,ast.If) else 'negate return'))
+        for text,target,replacement,operation in attempts:
+            try:
+                parsed=ast.parse(text)
+                memo={}
+                expected=copy.deepcopy(tree,memo)
+                expected=Replace(memo[id(target)],replacement).visit(expected)
+                same=ast.dump(parsed)==ast.dump(expected) and ast.dump(ast.parse(ast.unparse(parsed)))==ast.dump(parsed)
+            except (SyntaxError,ValueError): same=False
+            if same:
+                out.append(dict(line=line,functionName=fn.name,source=text,operation=operation))
+                used.add(line)
+                break
+    for child in ast.iter_child_nodes(node): visit(child,fn)
+visit(tree)
+print(json.dumps(out[:4]))
+`;
+function pythonMutations(before, source, called, dir) {
+  const r = spawnSync3("python3", ["-c", PYTHON_MUTATIONS], {
+    cwd: dir,
+    encoding: "utf8",
+    maxBuffer: 2 * 1024 * 1024,
+    input: JSON.stringify({ before, source, changed: [...changedSourceLines(before, source)], called })
+  });
+  if (r.status !== 0) return [];
+  try {
+    return JSON.parse(r.stdout);
+  } catch {
+    return [];
+  }
+}
+
+// src/dynamic-worker.ts
+var options = JSON.parse(readFileSync4(process.argv[2], "utf8"));
+var scratch = dirname2(process.argv[2]);
+var result = { status: "completed", findings: [], runs: [], notes: [], elapsedMs: 0 };
+function evidence(...runs) {
+  return runs.map((r) => `${r.label}: \`${r.command}\`, exit ${r.exitCode}, ${r.passed.length} passed, ${r.failed.length} failed${r.failed.length ? ` (${r.failed.join(", ")})` : ""}${r.fileRuns ? "; " + r.fileRuns.map((f) => `\`${f.command}\`, exit ${f.exitCode}, file ${f.file}`).join("; ") : ""}`).join("; ");
+}
+function finding(id, file, message, runs, line = 1) {
+  result.findings.push({ verifierId: id, severity: "warn", file, line, message: `${message} Evidence: ${evidence(...runs)}.`, suggestion: "Review the observed behavior and add a focused regression test. Runtime evidence cannot establish intent." });
+}
+try {
+  let run2 = function(tree, label) {
+    const dir = join4(scratch, `run-${result.runs.length + 1}`);
+    materialize(tree, dir, options.cwd);
+    const runAdapter = detectAdapter(tree, [...tree.keys()].filter((p) => isTest(p)));
+    const testRun = runTests(runAdapter, dir, label);
+    result.runs.push(testRun);
+    return { run: testRun, dir };
+  }, withTests2 = function(source, tests) {
+    const hybrid = new Map(source);
+    for (const p of /* @__PURE__ */ new Set([...oldTests, ...nextTests])) hybrid.delete(p);
+    for (const [p, data] of tests) if (isTest(p)) hybrid.set(p, data);
+    return hybrid;
+  };
+  run = run2, withTests = withTests2;
+  const { old, next } = loadSnapshots(options);
+  const isTest = picomatch(options.testPathGlobs, { dot: true });
+  const oldTests = [...old.keys()].filter((p) => isTest(p)), nextTests = [...next.keys()].filter((p) => isTest(p));
+  const adapter = detectAdapter(old, oldTests);
+  const nextAdapter = detectAdapter(next, nextTests);
+  if (adapter.kind !== nextAdapter.kind) throw Error("not run: test framework changed");
+  if ([...next.keys()].some((p) => !isTest(p) && /\.(?:go|rs|java|rb|php|cs|kt|cpp|c|swift)$/.test(p) && old.get(p)?.data.toString() !== next.get(p)?.data.toString())) {
+    result.notes.push("not run: probes for languages other than Node JavaScript and Python");
+  }
+  const original = run2(old, "original tests / original code").run;
+  const current = run2(next, "new tests / new code");
+  if (original.failed.length && current.run.exitCode === 0) {
+    result.notes.push("Original tests are red and new tests are green. Continue with per-test comparisons and applicable probes; this is a normal fix shape.");
+  }
+  const testChanges = [.../* @__PURE__ */ new Set([...oldTests, ...nextTests])].filter((p) => old.get(p)?.data.toString() !== next.get(p)?.data.toString());
+  const changedSource = [.../* @__PURE__ */ new Set([...old.keys(), ...next.keys()])].some((p) => !isTest(p) && !/\.(?:md|rst|txt)$/i.test(p) && old.get(p)?.data.toString() !== next.get(p)?.data.toString());
+  const intent = documentedIntent(old, next);
+  const edits = testChanges.filter((p) => expectedEdits(old.get(p)?.data.toString() ?? "", next.get(p)?.data.toString() ?? ""));
+  const cross = testChanges.length ? run2(withTests2(next, old), "original tests / new code").run : current.run;
+  if (!intent) {
+    for (const id of cross.failed.filter((id2) => original.passed.includes(id2))) {
+      const file = locateTest(id, old, oldTests);
+      if (file && !edits.includes(file)) finding("DY001", file, `Previously passing original test ${JSON.stringify(id)} fails against the new code`, [original, current.run, cross]);
+    }
+  }
+  let reverse;
+  if (testChanges.length) {
+    reverse = run2(withTests2(old, next), "new tests / original code").run;
+    const both = current.run.passed.filter((id) => reverse.passed.includes(id));
+    if (both.length) result.notes.push(`${both.length} named tests passed on both code revisions. This alone does not show that changed tests exercise the change and is not a finding.`);
+    if (!changedSource && !intent && testChanges.length === 1 && edits.length && expectationOnlyEdit(old.get(edits[0])?.data.toString() ?? "", next.get(edits[0])?.data.toString() ?? "")) {
+      const rejected = reverse.failed.filter((id) => original.passed.includes(id));
+      const accepted = reverse.passed.filter((id) => original.failed.includes(id));
+      for (const id of [...rejected, ...accepted]) {
+        const file = locateTest(id, old, oldTests);
+        const mismatch = accepted.includes(id) ? "failed with the original expectation, but the edited expectation passes on that same old code; the edit already matches the old behavior" : "passed with the original expectation, but the edited expectation fails on that same old code";
+        if (file && edits.includes(file)) finding("DY003", file, `Only the expected literal changed (${expectationChanges(old.get(file)?.data.toString() ?? "", next.get(file)?.data.toString() ?? "").map((e) => `${e.before} to ${e.after}`).join(", ")}): test ${JSON.stringify(id)} ${mismatch}`, [original, current.run, reverse]);
+      }
+    }
+  }
+  if (current.run.exitCode === 0 && !testChanges.length && !intent) {
+    for (const probe of findProbes(old, next, isTest)) {
+      const values = probeInputs(probe.input);
+      const observed = [];
+      const probeRuns = [];
+      for (const [tree, label] of [[old, "probe / original code"], [next, "probe / new code"]]) {
+        const dir = join4(scratch, `probe-${result.runs.length + 1}`);
+        materialize(tree, dir, options.cwd);
+        let command, args;
+        if (probe.language === "js") {
+          const script = `const m=await import(${JSON.stringify("./" + probe.file)});const f=m[${JSON.stringify(probe.name)}]??m.default?.[${JSON.stringify(probe.name)}];console.log(JSON.stringify(${JSON.stringify(values)}.map(x=>f(x))));`;
+          writeFileSync4(join4(dir, ".proctor-probe.mjs"), script);
+          command = process.execPath;
+          args = [".proctor-probe.mjs"];
+        } else {
+          const script = `import importlib.util,json
+s=importlib.util.spec_from_file_location('probe',${JSON.stringify(probe.file)})
+m=importlib.util.module_from_spec(s)
+s.loader.exec_module(m)
+print(json.dumps([getattr(m,${JSON.stringify(probe.name)})(x) for x in json.loads(${JSON.stringify(JSON.stringify(values))})]))
+`;
+          writeFileSync4(join4(dir, ".proctor-probe.py"), script);
+          command = "python3";
+          args = [".proctor-probe.py"];
+        }
+        const r = spawnSync4(command, args, { cwd: dir, encoding: "utf8", maxBuffer: 128 * 1024 });
+        if (r.status !== 0) {
+          observed.length = 0;
+          break;
+        }
+        let outputs;
+        try {
+          outputs = JSON.parse(r.stdout);
+        } catch {
+          observed.length = 0;
+          break;
+        }
+        if (!Array.isArray(outputs) || outputs.length !== values.length || outputs.some((n) => !["number", "string", "boolean"].includes(typeof n) || typeof n === "number" && !Number.isFinite(n))) {
+          observed.length = 0;
+          break;
+        }
+        observed.push(outputs);
+        const pr = { label, command: `${command} ${args.join(" ")} (${probe.file}:${probe.name}, inputs ${JSON.stringify(values)})`, exitCode: 0, passed: [], failed: [], detail: `outputs ${JSON.stringify(outputs)}` };
+        result.runs.push(pr);
+        probeRuns.push(pr);
+      }
+      if (observed.length === 2 && values.every((_, i) => i === 1 || observed[0][i] === observed[1][i]) && observed[0][1] !== observed[1][1]) {
+        finding("DY002", probe.file, `Literal branch in ${probe.name} contradicts the original simple reference only at ${JSON.stringify(probe.input)}: old ${JSON.stringify(observed[0])}, new ${JSON.stringify(observed[1])}, inputs ${JSON.stringify(values)}`, [original, current.run, ...probeRuns], probe.line);
+      }
+    }
+  }
+  if (original.failed.length && current.run.exitCode === 0 && !testChanges.length && !intent) {
+    try {
+      const coverage = coverageEnvironment(current.dir);
+      const control = runTests(nextAdapter, current.dir, "new tests / new code coverage control", coverage.env);
+      result.runs.push(control);
+      const samePasses = (a, b) => a.exitCode === 0 && b.exitCode === 0 && !a.failed.length && !b.failed.length && a.passed.length > 0 && a.passed.length === b.passed.length && a.passed.every((id) => b.passed.includes(id));
+      if (samePasses(current.run, control)) {
+        const calls = readCalls(coverage.path, current.dir);
+        let count = 0;
+        for (const [file, entry] of next) {
+          if (count >= MUTATION_LIMIT) break;
+          if (isTest(file) || !/\.(?:js|mjs|cjs|py)$/.test(file)) continue;
+          const before = old.get(file)?.data.toString() ?? "", source = entry.data.toString();
+          if (before === source) continue;
+          const path = join4(current.dir, file);
+          const candidates = file.endsWith(".py") ? pythonMutations(before, source, calls.python.get(path) ?? [], current.dir) : jsMutations(before, source, calls.js.get(path) ?? []);
+          for (const mutation of candidates) {
+            if (count >= MUTATION_LIMIT) break;
+            count++;
+            let mutant;
+            try {
+              writeFileSync4(path, mutation.source);
+              mutant = runTests(nextAdapter, current.dir, `mutation ${count}: ${mutation.operation}, ${file}:${mutation.line} (${mutation.functionName})`);
+              result.runs.push(mutant);
+            } catch {
+            } finally {
+              writeFileSync4(path, source);
+            }
+            if (mutant && samePasses(current.run, mutant)) {
+              const restored = runTests(nextAdapter, current.dir, `mutation ${count}: restored control`);
+              result.runs.push(restored);
+              if (samePasses(current.run, restored)) finding(
+                "DY004",
+                file,
+                `${mutation.operation} at ${file}:${mutation.line} in called function ${mutation.functionName} left every named test passing; this changed statement has no demonstrated test protection`,
+                [original, current.run, control, mutant, restored],
+                mutation.line
+              );
+            }
+          }
+        }
+        result.notes.push(`Mutation-lite: ${Math.min(count, MUTATION_LIMIT)} candidates run, cap ${MUTATION_LIMIT}; only parser-confirmed statements in called functions are eligible.`);
+      } else result.notes.push("not run: mutation-lite coverage control did not reproduce the green suite");
+    } catch (error) {
+      result.notes.push(`not run: mutation-lite could not establish reliable evidence: ${String(error)}`);
+    }
+  }
+  const raceFiles = testChanges.filter((p) => /(?:sleep\s*\(|setTimeout\s*\(|\bretry\b|\bretries\b)/.test(next.get(p)?.data.toString() ?? "") && (next.get(p)?.data.toString().match(/sleep\s*\(|setTimeout\s*\(|\bretry\b|\bretries\b/g)?.length ?? 0) > (old.get(p)?.data.toString().match(/sleep\s*\(|setTimeout\s*\(|\bretry\b|\bretries\b/g)?.length ?? 0));
+  if (raceFiles.length && current.run.exitCode === 0) {
+    const repeats = [current.run];
+    for (let i = 1; i <= 3; i++) {
+      const repeated = runTests(nextAdapter, current.dir, `new tests / new code repeat ${i}`);
+      result.runs.push(repeated);
+      repeats.push(repeated);
+    }
+    const ids = new Set(repeats.flatMap((r) => r.failed));
+    for (const id of ids) {
+      const file = locateTest(id, next, raceFiles);
+      if (file && repeats.some((r) => r.passed.includes(id)) && repeats.filter((r) => r.failed.includes(id)).length >= 2) {
+        finding("DY005", file, `Test ${JSON.stringify(id)} has inconsistent outcomes across four runs after adding a sleep or retry; this can also be order dependence`, repeats);
+      }
+    }
+  }
+} catch (error) {
+  result.status = "skipped";
+  result.reason = String(error).replace(/^Error: /, "");
+  result.findings = [];
+}
+var run;
+var withTests;
+process.stdout.write(JSON.stringify(result));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kavishdua/proctor",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Catch AI agents gaming their test suites: deleted tests, skipped tests, weakened assertions, hardcoded outputs",
   "homepage": "https://github.com/catfish-1234/proctor#readme",
   "bugs": {
@@ -61,6 +61,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.132.0",
+    "acorn": "^8.19.0",
     "brace-expansion": "^5.0.12",
     "commander": "^14.0.3",
     "parse-diff": "0.12.0",

package/proctor.schema.json

@@ -5,6 +5,18 @@
   "description": "Configuration for proctor, AI agent test-tampering guard",
   "type": "object",
   "properties": {
+    "dynamic": {
+      "type": "boolean",
+      "default": false,
+      "description": "Opt in to isolated execution of the project tests for dynamic checks."
+    },
+    "dynamicTimeoutMs": {
+      "type": "integer",
+      "minimum": 1,
+      "maximum": 2147483647,
+      "default": 60000,
+      "description": "Overall dynamic budget in milliseconds, including snapshot preparation."
+    },
     "enabled": {
       "type": "array",
       "items": { "type": "string", "pattern": "^(?:RH|WI)\\d{3}$" },