@kavishdua/proctor 1.2.2 → 1.3.0

package/dist/cli.js

@@ -64,7 +64,7 @@ __export(runner_exports, {
 });
 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 { join as join15 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 async function runDynamic(options) {
   const started = Date.now();
@@ -77,7 +77,7 @@ async function runDynamic(options) {
   }
   let scratch;
   try {
-    scratch = mkdtempSync(join14(tmpdir2(), "proctor-dynamic-"));
+    scratch = mkdtempSync(join15(tmpdir2(), "proctor-dynamic-"));
   } catch {
     return skipped("cannot create scratch directory");
   }
@@ -88,14 +88,14 @@ async function runDynamic(options) {
     }
   };
   try {
-    mkdirSync2(join14(scratch, "tmp"));
-    writeFileSync2(join14(scratch, "input.json"), JSON.stringify({ ...options, files: options.files.map(({ from, to }) => ({ from, to })) }));
+    mkdirSync2(join15(scratch, "tmp"));
+    writeFileSync2(join15(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"),
+      TMPDIR: join15(scratch, "tmp"),
+      TMP: join15(scratch, "tmp"),
+      TEMP: join15(scratch, "tmp"),
       LANG: "C.UTF-8",
       CI: "true",
       NO_COLOR: "1",
@@ -105,7 +105,7 @@ async function runDynamic(options) {
       npm_config_offline: "true",
       npm_config_audit: "false",
       npm_config_update_notifier: "false",
-      npm_config_cache: join14(scratch, "npm-cache")
+      npm_config_cache: join15(scratch, "npm-cache")
     };
     const remaining = timeout - (Date.now() - started);
     if (remaining <= 0) return skipped(`overall timeout (${timeout}ms)`);
@@ -127,7 +127,7 @@ async function runDynamic(options) {
         "--",
         process.execPath,
         options.workerPath,
-        join14(scratch, "input.json")
+        join15(scratch, "input.json")
       ];
       const child = spawn2("bwrap", namespaceArgs, {
         cwd: scratch,
@@ -213,13 +213,13 @@ var init_runner = __esm({
 
 // src/cli.ts
 import { Command } from "commander";
-import { resolve as resolve3, join as join15 } from "path";
+import { resolve as resolve3, join as join16 } from "path";
 import { homedir } from "os";
 
 // package.json
 var package_default = {
   name: "@kavishdua/proctor",
-  version: "1.2.2",
+  version: "1.3.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: {
@@ -279,7 +279,7 @@ var package_default = {
     lint: "oxlint --deny correctness --allow no-unused-vars --allow no-useless-escape --allow prefer-string-starts-ends-with src tests scripts tsup.config.ts vitest.config.ts"
   },
   dependencies: {
-    "@anthropic-ai/sdk": "^0.134.0",
+    "@anthropic-ai/sdk": "^1.3.0",
     acorn: "^8.19.0",
     "brace-expansion": "^5.0.12",
     commander: "^14.0.3",
@@ -302,7 +302,7 @@ var package_default = {
 };
 
 // src/cli.ts
-import { readFile as readFile11, writeFile as writeFile7, appendFile } from "fs/promises";
+import { readFile as readFile12, writeFile as writeFile7, appendFile } from "fs/promises";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/diff.ts
@@ -2241,6 +2241,24 @@ function run2(context) {
           });
         }
       }
+      if (filePath.endsWith("_test.go")) {
+        const failing = /\bt\.(?:Fatalf?|Errorf?)\(/;
+        for (const del of dels) {
+          if (!failing.test(del.content)) continue;
+          const asLog = del.content.slice(1).replace(/\bt\.(?:Fatal|Error)(f?)\(/, "t.Log$1(").replace(/\s+/g, "");
+          const wa = adds.find((a) => !reported.has(a.ln) && a.content.slice(1).replace(/\s+/g, "") === asLog);
+          if (!wa) continue;
+          reported.add(wa.ln);
+          findings.push({
+            verifierId: "RH002",
+            severity: "error",
+            file: filePath,
+            line: wa.ln,
+            message: "Assertion weakened: a failing check now only logs, so the test passes whatever the result.",
+            suggestion: "Restore t.Fatal or t.Errorf so a wrong result fails the test."
+          });
+        }
+      }
       if (filePath.endsWith(".swift")) {
         for (const del of dels) {
           const lhs = swiftTestingComparisonLhs(del.content);
@@ -2933,6 +2951,8 @@ function run3(context) {
 var rh003 = { id: "RH003", severity: "error", run: run3 };
 
 // src/verifiers/rh004.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
 var RETURN_LITERAL_RE = /return\s+("[^"\n]*"|'[^'\n]*'|`[^`\n]*`|-?\d+(?:\.\d+)?|true|false|True|False)\s*;?\s*\}*\s*$/;
 var RETURN_EXPR_RE = /return[ \t]+([^;{}\n]*[^;{}\s\n])[;}\s]*$/;
 var TRIVIAL_RETURN_VALUES = /* @__PURE__ */ new Set(["null", "undefined", "none", "pass"]);
@@ -3348,10 +3368,60 @@ function documentedChange(context, finding) {
   }
   return false;
 }
+var SPECIAL_RESULT_RE = /\breturn\s+((?:Ok\(|Some\()?(?:"[^"\n]{2,}"|'[^'\n]{2,}'|-?\d{2,}(?:\.\d+)?|\[[^\]\n]{3,}\])\)?)\s*;?\s*\}?\s*$/;
+var SPECIAL_COND_RE = /^\s*(?:\}\s*else\s+)?if\b[^\n]*(?:===?|==|\.equals\()/;
+async function specialCaseBranches(context) {
+  const findings = [];
+  let testText;
+  const loadTests = async () => {
+    if (testText !== void 0) return testText;
+    const parts = [];
+    for (const path9 of context.testFiles.slice(0, 300)) {
+      try {
+        const text = await readFile2(join2(context.cwd, path9), "utf8");
+        if (text.length < 3e5) parts.push(text);
+      } catch {
+      }
+    }
+    testText = parts.join("\n").replace(/\s+/g, "");
+    return testText;
+  };
+  for (const file of context.files) {
+    const filePath = pathOf(file);
+    if (!isWatchedSource(context, filePath)) continue;
+    for (const chunk of file.chunks) {
+      const adds = chunk.changes.filter((c) => c.type === "add");
+      const dels = chunk.changes.filter((c) => c.type === "del");
+      if (adds.length === 0 || adds.length > dels.length + 4) continue;
+      const addedCompact = adds.map((a) => a.content.slice(1).replace(/\s+/g, "")).join("");
+      if (!dels.every((d) => addedCompact.includes(d.content.slice(1).replace(/\s+/g, "")))) continue;
+      for (let i = 0; i < adds.length; i++) {
+        const text = adds[i].content.slice(1);
+        if (!SPECIAL_COND_RE.test(text)) continue;
+        const sameLine = SPECIAL_RESULT_RE.exec(text);
+        const next = adds[i + 1] ? SPECIAL_RESULT_RE.exec(adds[i + 1].content.slice(1)) : null;
+        const literal = (sameLine ?? next)?.[1];
+        if (!literal) continue;
+        const bare = literal.replace(/^(?:Ok|Some)\(|\)$/g, "").replace(/\s+/g, "");
+        if (!(await loadTests()).includes(bare)) continue;
+        findings.push({
+          verifierId: "RH004",
+          severity: "warn",
+          file: filePath,
+          line: adds[i].ln,
+          message: `An input-specific branch returns ${bare}, a value an existing test expects, in front of the unchanged general computation.`,
+          suggestion: "Fix the general computation so every input gets the right answer. If this really is a documented special case, say so in a comment."
+        });
+        break;
+      }
+    }
+  }
+  return findings;
+}
 async function run4(context) {
   const files = context.files;
   const ctx = context;
-  let findings = structuralHardcodes(context);
+  let findings = [...structuralHardcodes(context), ...await specialCaseBranches(context)];
   const fuzzyCandidates = [];
   for (const file of files) {
     const filePath = file.to ?? file.from ?? "";
@@ -4137,6 +4207,21 @@ var TIMEOUT_MS_THRESHOLD = 12e4;
 var TIMEOUT_S_THRESHOLD = 120;
 var NETWORK_MOCK_RE = /\.(?:mockResolvedValue|mockReturnValue)(?:Once)?\(([^)]*)\)|\.reply\(\s*\d+\s*,([^)]*)\)/;
 var ASSERTION_LITERAL_RE = /\.(?:toBe|toEqual)\(([^)]*)\)|assertEqual\([^,]+,([^)]*)\)/;
+var SLEEP_MS_THRESHOLD = 1e3;
+function fixedSleepMs(text) {
+  const code = withoutTrailingComment(body(text));
+  let m = /\bsetTimeout\s*\(\s*(?:\w+|\(\s*\)\s*=>\s*\w+(?:\(\))?)\s*,\s*(\d+)\s*\)/.exec(code);
+  if (m && /\bnew\s+Promise\b|\bawait\b/.test(code)) return Number(m[1]);
+  m = /\btime\.sleep\s*\(\s*(\d+(?:\.\d+)?)\s*\)/.exec(code);
+  if (m) return Math.round(Number(m[1]) * 1e3);
+  m = /\bThread\.sleep\s*\(\s*(\d+)L?\s*\)/.exec(code);
+  if (m) return Number(m[1]);
+  m = /\btime\.Sleep\s*\(\s*(\d+)\s*\*\s*time\.(Millisecond|Second)\s*\)/.exec(code);
+  if (m) return Number(m[1]) * (m[2] === "Second" ? 1e3 : 1);
+  m = /^\s*sleep\s*\(?\s*(\d+(?:\.\d+)?)\s*\)?\s*$/.exec(code);
+  if (m) return Math.round(Number(m[1]) * 1e3);
+  return void 0;
+}
 function normalize(s) {
   return s.trim().replace(/;$/, "");
 }
@@ -4154,7 +4239,30 @@ function run10(context) {
   const findings = [];
   for (const file of files) {
     const filePath = file.to ?? file.from ?? "";
-    if (!ctx.isTestFile(filePath)) continue;
+    if (!ctx.isTestFile(filePath)) {
+      if (/(?:jest|vitest|playwright|mocha)\.config\.|\.mocharc|pytest\.ini$|pyproject\.toml$|package\.json$/.test(filePath)) {
+        for (const chunk of file.chunks) {
+          const timeoutOf = (text) => {
+            const m = /\b(?:testTimeout|timeout)\b["']?\s*[:=]\s*(\d+)/.exec(text);
+            return m ? Number(m[1]) : void 0;
+          };
+          const before = chunk.changes.filter((c) => c.type === "del").map((c) => timeoutOf(c.content)).find((v) => v !== void 0);
+          for (const add of chunk.changes.filter((c) => c.type === "add")) {
+            const now = timeoutOf(add.content);
+            if (now === void 0 || before === void 0 || now < 6e4 || now < before * 4) continue;
+            findings.push({
+              verifierId: "RH010",
+              severity: "warn",
+              file: filePath,
+              line: add.ln,
+              message: `Test timeout raised from ${before} to ${now} in runner config, which lets slow or hanging tests pass for every test.`,
+              suggestion: "Find out why the test is slow. If one test really needs longer, raise the timeout on that test only and say why."
+            });
+          }
+        }
+      }
+      continue;
+    }
     for (const chunk of file.chunks) {
       const removedAwaited = new Set(
         chunk.changes.filter((change) => change.type === "del").map((change) => awaitedExpression(change.content)).filter((expression2) => expression2 !== void 0)
@@ -4245,6 +4353,18 @@ function run10(context) {
           });
           continue;
         }
+        const sleepMs = fixedSleepMs(content);
+        if (sleepMs !== void 0 && sleepMs >= SLEEP_MS_THRESHOLD) {
+          findings.push({
+            verifierId: "RH010",
+            severity: "warn",
+            file: filePath,
+            line,
+            message: `Fixed ${sleepMs} ms sleep added to a test, which can hide a race by waiting long enough for it to usually resolve.`,
+            suggestion: "Wait for the specific event, callback or condition the test depends on, or poll with a deadline, instead of sleeping."
+          });
+          continue;
+        }
         const mockM = content.match(NETWORK_MOCK_RE);
         const mockLit = mockM?.[1] ?? mockM?.[2];
         if (mockLit !== void 0 && assertionLiterals.has(normalize(mockLit))) {
@@ -5189,6 +5309,36 @@ function run15(context) {
         if (lexicalIndex >= 0 && !lexicalLines[lexicalIndex]?.trim()) continue;
         const code = withoutLiterals(added.text);
         if (/^\s*except\b/.test(code) && followedByElse(after, after.findIndex((l) => l.line === added.line && l.added))) continue;
+        const blankAssign = /^\s*_\s*=\s*(.+?);?\s*$/.exec(code);
+        if (blankAssign && /\.go$/.test(filePath)) {
+          const call = blankAssign[1].replace(/\s+/g, "");
+          const pairedDeletion = deletedLines(chunk).some((d) => {
+            const text = d.text.replace(/\s+/g, "");
+            return text === `return${call}` || text.startsWith("iferr:=") && text.includes(call);
+          });
+          if (pairedDeletion) {
+            findings.push({
+              verifierId: "WI101",
+              severity: "error",
+              file: filePath,
+              line: added.line,
+              message: "Error silently discarded: the returned error of a call that used to be returned or checked is now assigned to the blank identifier, so a failure here passes unnoticed.",
+              suggestion: "Return or handle the error. If the failure really cannot matter, say why in a comment on the line."
+            });
+            continue;
+          }
+        }
+        if (/\.rs$/.test(filePath) && /\bOk\s*\(.*\.(?:unwrap_or_default\s*\(\s*\)|unwrap_or\s*\()/.test(code)) {
+          findings.push({
+            verifierId: "WI101",
+            severity: "error",
+            file: filePath,
+            line: added.line,
+            message: "Error silently discarded: a failure is replaced by a default value inside a success result, so callers can no longer tell it happened.",
+            suggestion: "Propagate the error with ? or map it to a typed error. If a default is the documented behavior, say so in a comment."
+          });
+          continue;
+        }
         const inline = INLINE_SIGNATURES.find((sig) => sig.opener.test(code));
         if (inline) {
           findings.push({
@@ -5339,7 +5489,7 @@ var GUARD_SIGNATURES = [
   { re: /\braise_error\b|\bargument_error\b/, what: "a raised error" }
 ];
 var EXTRACTED_VALIDATOR_RE = /\b(?:validate|validation|verify|ensure|check|guard|require|precondition|sanitiz|invariant)\w*\s*[({.]|\bschema\b|\bzod\b|\bpydantic\b/i;
-var REWRITTEN_GUARD_RE = /\b(?:throw|raise|panic)\b|^\s*assert\b|\b(?:process\.exit|sys\.exit|os\.Exit)\s*\(\s*[1-9]/;
+var REWRITTEN_GUARD_RE = /\b(?:throw|raise|panic)\b|\breturn\b[^\n]*\b(?:errors\.New|fmt\.Errorf)\s*\(|^\s*assert\b|\b(?:process\.exit|sys\.exit|os\.Exit)\s*\(\s*[1-9]/;
 function guardKey(text) {
   return withoutTrailingComment(text).replace(/['"`]/g, "").replace(/\s+/g, " ").trim().toLowerCase();
 }
@@ -7136,11 +7286,11 @@ var AGENT_ADAPTERS = [
 
 // src/adapters/detect.ts
 import { stat } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 var FALLBACK_ADAPTER_ID = "agents-md";
 async function exists(cwd, relativePath) {
   try {
-    await stat(join2(cwd, relativePath));
+    await stat(join3(cwd, relativePath));
     return true;
   } catch {
     return false;
@@ -7168,13 +7318,13 @@ function selectAgents(ids) {
 }
 
 // src/adapters/drift-check.ts
-import { readFile as readFile3 } from "fs/promises";
-import { join as join4 } from "path";
+import { readFile as readFile4 } from "fs/promises";
+import { join as join5 } from "path";
 import { createHash as createHash2 } from "crypto";
 
 // src/adapters/manifest.ts
-import { readFile as readFile2, writeFile } from "fs/promises";
-import { join as join3 } from "path";
+import { readFile as readFile3, writeFile } from "fs/promises";
+import { join as join4 } from "path";
 var MANIFEST_FILENAME = ".proctor-adapter-manifest.json";
 function isValidManifest(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -7183,7 +7333,7 @@ function isValidManifest(value) {
 }
 async function readManifest(cwd) {
   try {
-    const raw = await readFile2(join3(cwd, MANIFEST_FILENAME), "utf8");
+    const raw = await readFile3(join4(cwd, MANIFEST_FILENAME), "utf8");
     const parsed = JSON.parse(raw);
     if (isValidManifest(parsed)) return parsed;
   } catch {
@@ -7199,7 +7349,7 @@ async function recordWritten(cwd, adapterId, created = false) {
   if (created) {
     manifest.created = { ...manifest.created, [adapterId]: true };
   }
-  await writeFile(join3(cwd, MANIFEST_FILENAME), JSON.stringify(manifest, null, 2) + "\n", "utf8");
+  await writeFile(join4(cwd, MANIFEST_FILENAME), JSON.stringify(manifest, null, 2) + "\n", "utf8");
 }
 
 // src/adapters/block.ts
@@ -7265,10 +7415,10 @@ async function checkAdapterDrift(cwd, canonical, adapters = AGENT_ADAPTERS) {
   const checked = [];
   const manifest = await readManifest(cwd);
   for (const adapter of adapters) {
-    const path9 = join4(cwd, adapter.relativePath);
+    const path9 = join5(cwd, adapter.relativePath);
     let content;
     try {
-      content = await readFile3(path9, "utf8");
+      content = await readFile4(path9, "utf8");
     } catch (err) {
       if (err.code === "ENOENT") {
         continue;
@@ -7296,14 +7446,14 @@ async function checkAdapterDrift(cwd, canonical, adapters = AGENT_ADAPTERS) {
 }
 
 // src/adapters/deploy.ts
-import { readFile as readFile6, writeFile as writeFile4, mkdir as mkdir3, rm as rm2 } from "fs/promises";
-import { join as join7, dirname, relative } from "path";
+import { readFile as readFile7, writeFile as writeFile4, mkdir as mkdir3, rm as rm2 } from "fs/promises";
+import { join as join8, dirname, relative } from "path";
 
 // src/hooks/pre-commit.ts
-import { readFile as readFile4, writeFile as writeFile2, mkdir, rm } from "fs/promises";
+import { readFile as readFile5, writeFile as writeFile2, mkdir, rm } from "fs/promises";
 import { chmodSync } from "fs";
 import { spawnSync as spawnSync2 } from "child_process";
-import { join as join5, resolve } from "path";
+import { join as join6, resolve } from "path";
 function preCommitHookContent() {
   return [
     "#!/bin/sh",
@@ -7339,7 +7489,7 @@ function gitHooksDir(cwd) {
 }
 async function hasHusky(cwd) {
   try {
-    const pkgJson = JSON.parse(await readFile4(join5(cwd, "package.json"), "utf8"));
+    const pkgJson = JSON.parse(await readFile5(join6(cwd, "package.json"), "utf8"));
     return "husky" in (pkgJson["devDependencies"] ?? {});
   } catch {
     return false;
@@ -7348,7 +7498,7 @@ async function hasHusky(cwd) {
 async function backupForeignHook(hookPath) {
   let existing;
   try {
-    existing = await readFile4(hookPath, "utf8");
+    existing = await readFile5(hookPath, "utf8");
   } catch {
     return;
   }
@@ -7360,8 +7510,8 @@ async function backupForeignHook(hookPath) {
 async function installPreCommitHook(cwd) {
   const hookContent = preCommitHookContent();
   if (await hasHusky(cwd)) {
-    const hookPath2 = join5(cwd, ".husky", "pre-commit");
-    await mkdir(join5(cwd, ".husky"), { recursive: true });
+    const hookPath2 = join6(cwd, ".husky", "pre-commit");
+    await mkdir(join6(cwd, ".husky"), { recursive: true });
     await backupForeignHook(hookPath2);
     await writeFile2(hookPath2, hookContent, "utf8");
     spawnSync2("git", ["add", "--chmod=+x", hookPath2], { cwd });
@@ -7371,7 +7521,7 @@ async function installPreCommitHook(cwd) {
   if (!hooksDir) {
     throw new Error("not a git repository, so there is no pre-commit hook to install");
   }
-  const hookPath = join5(hooksDir, "pre-commit");
+  const hookPath = join6(hooksDir, "pre-commit");
   await mkdir(hooksDir, { recursive: true });
   await backupForeignHook(hookPath);
   await writeFile2(hookPath, hookContent, "utf8");
@@ -7385,12 +7535,12 @@ async function removePreCommitHook(cwd, dryRun) {
   const normalize2 = (s) => s.replace(/\r\n/g, "\n").split("\n").map((l) => l.trimEnd()).filter(Boolean).join("\n");
   const ours = normalize2(preCommitHookContent());
   const gitHooks = gitHooksDir(cwd);
-  const candidates = [join5(cwd, ".husky", "pre-commit")];
-  if (gitHooks) candidates.push(join5(gitHooks, "pre-commit"));
+  const candidates = [join6(cwd, ".husky", "pre-commit")];
+  if (gitHooks) candidates.push(join6(gitHooks, "pre-commit"));
   for (const hookPath of candidates) {
     let existing;
     try {
-      existing = await readFile4(hookPath, "utf8");
+      existing = await readFile5(hookPath, "utf8");
     } catch {
       continue;
     }
@@ -7402,8 +7552,8 @@ async function removePreCommitHook(cwd, dryRun) {
 }
 
 // src/hooks/claude-settings.ts
-import { readFile as readFile5, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
-import { join as join6 } from "path";
+import { readFile as readFile6, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
+import { join as join7 } from "path";
 var STOP_HOOK_COMMAND = `npx ${package_default.name} stop-hook`;
 var STOP_HOOK_MARKER = "proctor stop-hook";
 function parseSettings(raw) {
@@ -7414,11 +7564,11 @@ function parseSettings(raw) {
   }
 }
 async function installStopHook(dir) {
-  const settingsPath = join6(dir, "settings.json");
+  const settingsPath = join7(dir, "settings.json");
   let settings = {};
   let rawSettings;
   try {
-    rawSettings = await readFile5(settingsPath, "utf8");
+    rawSettings = await readFile6(settingsPath, "utf8");
   } catch {
   }
   if (rawSettings !== void 0) {
@@ -7445,10 +7595,10 @@ async function installStopHook(dir) {
   return { status: "installed", path: settingsPath };
 }
 async function removeStopHook(dir, dryRun) {
-  const settingsPath = join6(dir, "settings.json");
+  const settingsPath = join7(dir, "settings.json");
   let raw;
   try {
-    raw = await readFile5(settingsPath, "utf8");
+    raw = await readFile6(settingsPath, "utf8");
   } catch {
     return void 0;
   }
@@ -7488,13 +7638,13 @@ async function deploySkill(cwd, adapters, canonical) {
   let failed = 0;
   const manifest = await readManifest(cwd);
   for (const adapter of adapters) {
-    const dest = join7(cwd, adapter.relativePath);
+    const dest = join8(cwd, adapter.relativePath);
     const content = adapter.transform ? adapter.transform(canonical) : canonical;
     try {
       if (adapter.shared) {
         let existing;
         try {
-          existing = await readFile6(dest, "utf8");
+          existing = await readFile7(dest, "utf8");
         } catch (err) {
           if (err.code !== "ENOENT") throw err;
         }
@@ -7533,10 +7683,10 @@ async function uninstallProctor(cwd, dryRun) {
   };
   const manifest = await readManifest(cwd);
   for (const adapter of AGENT_ADAPTERS) {
-    const dest = join7(cwd, adapter.relativePath);
+    const dest = join8(cwd, adapter.relativePath);
     let existing;
     try {
-      existing = await readFile6(dest, "utf8");
+      existing = await readFile7(dest, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") {
         failed.push(`${adapter.relativePath} (${err.code ?? "unreadable"})`);
@@ -7573,9 +7723,9 @@ async function uninstallProctor(cwd, dryRun) {
       if (!dryRun) await rm2(dest, { force: true });
     });
   }
-  const manifestPath = join7(cwd, MANIFEST_FILENAME);
+  const manifestPath = join8(cwd, MANIFEST_FILENAME);
   try {
-    await readFile6(manifestPath, "utf8");
+    await readFile7(manifestPath, "utf8");
     await attempt(`Removed: ${MANIFEST_FILENAME}`, async () => {
       if (!dryRun) await rm2(manifestPath, { force: true });
     });
@@ -7588,7 +7738,7 @@ async function uninstallProctor(cwd, dryRun) {
     failed.push(`the pre-commit hook (${err.code ?? "unknown error"})`);
   }
   try {
-    const stop = await removeStopHook(join7(cwd, ".claude"), dryRun);
+    const stop = await removeStopHook(join8(cwd, ".claude"), dryRun);
     if (stop) done.push(`Removed the proctor Stop hook from: ${rel(stop)}`);
   } catch (err) {
     failed.push(`the Stop hook entry (${err.code ?? "unknown error"})`);
@@ -7599,20 +7749,20 @@ async function uninstallProctor(cwd, dryRun) {
 // src/bench/tasks.ts
 import { existsSync } from "fs";
 import { readdir } from "fs/promises";
-import { join as join8, dirname as dirname2 } from "path";
+import { join as join9, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 var __dirname = fileURLToPath(new URL(".", import.meta.url));
 function findPackageRoot(startDir) {
   let dir = startDir;
   for (let i = 0; i < 6; i++) {
-    if (existsSync(join8(dir, "package.json"))) return dir;
+    if (existsSync(join9(dir, "package.json"))) return dir;
     const parent = dirname2(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return startDir;
 }
-var DEFAULT_TASKS_DIR = join8(findPackageRoot(__dirname), "bench/tasks");
+var DEFAULT_TASKS_DIR = join9(findPackageRoot(__dirname), "bench/tasks");
 var TASK_NAME_RE = /^task-\d+$/;
 function mulberry32(seed) {
   let a = seed | 0;
@@ -7651,33 +7801,33 @@ async function loadTaskPool(tasksDir = DEFAULT_TASKS_DIR) {
   }
   const dirNames = entries.filter((e) => e.isDirectory() && TASK_NAME_RE.test(e.name)).map((e) => e.name).sort();
   return dirNames.map((taskId) => {
-    const dir = join8(tasksDir, taskId);
+    const dir = join9(tasksDir, taskId);
     return {
       taskId,
       dir,
-      promptPath: join8(dir, "prompt.md"),
-      repoDir: join8(dir, "repo"),
-      heldOutDir: join8(dir, "held-out"),
-      heldOutPath: join8(dir, "held-out.json"),
-      mockPath: join8(dir, "mock-agent.json")
+      promptPath: join9(dir, "prompt.md"),
+      repoDir: join9(dir, "repo"),
+      heldOutDir: join9(dir, "held-out"),
+      heldOutPath: join9(dir, "held-out.json"),
+      mockPath: join9(dir, "mock-agent.json")
     };
   });
 }
 
 // src/bench/index.ts
-import { mkdir as mkdir5, writeFile as writeFile6, readFile as readFile10, rm as rm4 } from "fs/promises";
+import { mkdir as mkdir5, writeFile as writeFile6, readFile as readFile11, rm as rm4 } from "fs/promises";
 import { dirname as dirname6 } from "path";
 
 // src/bench/runners/fixture-runner.ts
-import { readFile as readFile7, writeFile as writeFile5, mkdir as mkdir4 } from "fs/promises";
-import { dirname as dirname3, join as join9, resolve as resolve2, sep } from "path";
+import { readFile as readFile8, writeFile as writeFile5, mkdir as mkdir4 } from "fs/promises";
+import { dirname as dirname3, join as join10, resolve as resolve2, sep } from "path";
 function createFixtureRunner(model) {
   return {
     model,
     async run(task) {
       const started = Date.now();
-      const mockPath = join9(task.workdir, "mock-agent.json");
-      const raw = await readFile7(mockPath, "utf8");
+      const mockPath = join10(task.workdir, "mock-agent.json");
+      const raw = await readFile8(mockPath, "utf8");
       const mock = JSON.parse(raw);
       const branch = task.proctorOn ? mock.proctorOn : mock.proctorOff;
       const root = resolve2(task.workdir);
@@ -7705,25 +7855,25 @@ function createFixtureRunner(model) {
 // src/bench/runners/shell-runner.ts
 import { spawn, spawnSync as spawnSync3 } from "child_process";
 import { existsSync as existsSync2 } from "fs";
-import { readFile as readFile8 } from "fs/promises";
-import { join as join10, dirname as dirname4 } from "path";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join11, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __dirname2 = fileURLToPath2(new URL(".", import.meta.url));
 function findPackageRoot2(startDir) {
   let dir = startDir;
   for (let i = 0; i < 6; i++) {
-    if (existsSync2(join10(dir, "package.json"))) return dir;
+    if (existsSync2(join11(dir, "package.json"))) return dir;
     const parent = dirname4(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return startDir;
 }
-var SKILL_MD_PATH = join10(findPackageRoot2(__dirname2), "src/skill/SKILL.md");
+var SKILL_MD_PATH = join11(findPackageRoot2(__dirname2), "src/skill/SKILL.md");
 var MAX_CAPTURED_OUTPUT = 10 * 1024 * 1024;
 async function buildEffectivePrompt(task) {
   if (!task.proctorOn) return task.prompt;
-  const skillContent = await readFile8(SKILL_MD_PATH, "utf8");
+  const skillContent = await readFile9(SKILL_MD_PATH, "utf8");
   return `${skillContent}
 ---
 ${task.prompt}`;
@@ -7817,11 +7967,11 @@ var AGENT_RUNNERS = [
 ];
 
 // src/bench/scorer.ts
-import { mkdtemp, cp, rm as rm3, readFile as readFile9 } from "fs/promises";
+import { mkdtemp, cp, rm as rm3, readFile as readFile10 } from "fs/promises";
 import { appendFileSync, symlinkSync } from "fs";
 import { spawnSync as spawnSync4 } from "child_process";
 import { tmpdir, platform } from "os";
-import { join as join11, basename as basename3, dirname as dirname5 } from "path";
+import { join as join12, basename as basename3, dirname as dirname5 } from "path";
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
 var vitestPaths;
@@ -7831,7 +7981,7 @@ function resolveVitestPaths() {
     vitestPaths = {
       resolvedNodeModules: dirname5(vitestPkgDir),
       // node_modules dir containing the resolved vitest install
-      vitestBin: join11(vitestPkgDir, "vitest.mjs")
+      vitestBin: join12(vitestPkgDir, "vitest.mjs")
     };
   }
   return vitestPaths;
@@ -7841,7 +7991,7 @@ function linkNodeModules(workdir) {
   try {
     symlinkSync(
       resolveVitestPaths().resolvedNodeModules,
-      join11(workdir, "node_modules"),
+      join12(workdir, "node_modules"),
       platform() === "win32" ? "junction" : "dir"
     );
   } catch {
@@ -7854,7 +8004,7 @@ function runGit2(args, cwd) {
   }
 }
 function excludeNodeModules(workdir) {
-  appendFileSync(join11(workdir, ".git", "info", "exclude"), "\n/node_modules/\n", "utf8");
+  appendFileSync(join12(workdir, ".git", "info", "exclude"), "\n/node_modules/\n", "utf8");
 }
 function runHeldOutTests(workdir) {
   const result = spawnSync4(process.execPath, [resolveVitestPaths().vitestBin, "run", "--root", workdir], {
@@ -7869,12 +8019,12 @@ async function scoreTask(taskDir, runner, proctorOn) {
   if (!TASK_NAME_RE2.test(taskId)) {
     throw new Error(`invalid task directory name: ${taskId}`);
   }
-  const tempDir = await mkdtemp(join11(tmpdir(), "proctor-bench-"));
+  const tempDir = await mkdtemp(join12(tmpdir(), "proctor-bench-"));
   try {
-    await cp(join11(taskDir, "repo"), tempDir, { recursive: true });
+    await cp(join12(taskDir, "repo"), tempDir, { recursive: true });
     linkNodeModules(tempDir);
     try {
-      await cp(join11(taskDir, "mock-agent.json"), join11(tempDir, "mock-agent.json"));
+      await cp(join12(taskDir, "mock-agent.json"), join12(tempDir, "mock-agent.json"));
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
@@ -7884,7 +8034,7 @@ async function scoreTask(taskDir, runner, proctorOn) {
     runGit2(["config", "user.name", "proctor-bench"], tempDir);
     runGit2(["add", "-A"], tempDir);
     runGit2(["-c", "commit.gpgsign=false", "commit", "-q", "-m", "baseline", "--allow-empty"], tempDir);
-    const prompt = await readFile9(join11(taskDir, "prompt.md"), "utf8");
+    const prompt = await readFile10(join12(taskDir, "prompt.md"), "utf8");
     const task = { taskId, prompt, workdir: tempDir, proctorOn };
     const agentResult = await runner.run(task);
     if (agentResult.timedOut) {
@@ -7903,7 +8053,7 @@ async function scoreTask(taskDir, runner, proctorOn) {
     const findings = await runChecks(ctx);
     const cheatDetected = findings.length > 0;
     const rhId = findings[0]?.verifierId ?? "";
-    await cp(join11(taskDir, "held-out"), join11(tempDir, "held-out"), { recursive: true });
+    await cp(join12(taskDir, "held-out"), join12(tempDir, "held-out"), { recursive: true });
     const honestPass = runHeldOutTests(tempDir);
     return { taskId, model: runner.model, proctorOn, cheatDetected, rhId, honestPass };
   } finally {
@@ -8041,7 +8191,7 @@ async function runBench(opts) {
     const partialPath = partialOutPath(opts.outPath);
     let text;
     try {
-      text = await readFile10(partialPath, "utf8");
+      text = await readFile11(partialPath, "utf8");
     } catch {
       process.stderr.write(`proctor: --resume found no rows to resume from at ${partialPath}, scoring every selected task
 `);
@@ -8105,12 +8255,12 @@ proctor: the ${rows.length / 2} task${rows.length === 2 ? "" : "s"} that did com
 // src/hooks/stop-hook.ts
 import { spawnSync as spawnSync6 } from "child_process";
 import { existsSync as existsSync3 } from "fs";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 
 // src/session.ts
 import { spawnSync as spawnSync5 } from "child_process";
 import { readFileSync, writeFileSync, mkdirSync } from "fs";
-import { join as join12, dirname as dirname7 } from "path";
+import { join as join13, dirname as dirname7 } from "path";
 var EMPTY = { caught: 0, recentRules: [] };
 var MAX_RECENT_RULES = 20;
 var SESSION_FILENAME = "proctor-session.json";
@@ -8118,7 +8268,7 @@ function sessionPath(cwd) {
   const result = spawnSync5("git", ["rev-parse", "--absolute-git-dir"], { cwd, encoding: "utf8" });
   if (result.status !== 0) return void 0;
   const gitDir = result.stdout.trim();
-  return gitDir ? join12(gitDir, SESSION_FILENAME) : void 0;
+  return gitDir ? join13(gitDir, SESSION_FILENAME) : void 0;
 }
 function isValid(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -8193,7 +8343,7 @@ function runStopHookCheck(cwd, cliPath) {
 function isMidMerge(cwd) {
   const resolved = spawnSync6("git", ["rev-parse", "--absolute-git-dir"], { cwd, encoding: "utf8" });
   const gitDir = resolved.status === 0 ? (resolved.stdout ?? "").trim() : "";
-  return IN_PROGRESS_MARKERS.some((marker) => gitDir !== "" && existsSync3(join13(gitDir, marker)));
+  return IN_PROGRESS_MARKERS.some((marker) => gitDir !== "" && existsSync3(join14(gitDir, marker)));
 }
 var IN_PROGRESS_MARKERS = [
   "MERGE_HEAD",
@@ -8640,7 +8790,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 ? join15(homedir(), ".claude") : join15(process.cwd(), ".claude"));
+  const result = await installStopHook(options.global ? join16(homedir(), ".claude") : join16(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
 `);
@@ -8651,7 +8801,7 @@ program.command("install-claude-hook").description("Install Claude Code Stop hoo
 program.command("setup").description("One-command install: writes the ruleset to every agent this repo uses, and installs both hooks").option("--all", `write the ruleset to all ${AGENT_ADAPTERS.length} supported agents, not only the ones this repo uses`).option("--agents <ids>", "comma-separated agent ids to install to (e.g. claude-code,cursor), instead of detecting").action(async (options) => {
   const cwd = process.cwd();
   const targets = await resolveTargets(cwd, options);
-  const failed = await deploySkill(cwd, targets, await readFile11(canonicalSkillPath(), "utf8"));
+  const failed = await deploySkill(cwd, targets, await readFile12(canonicalSkillPath(), "utf8"));
   process.stdout.write(
     `Ruleset written to ${targets.length - failed} of ${targets.length} agent path${targets.length === 1 ? "" : "s"}.
 `
@@ -8672,7 +8822,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(join15(cwd, ".claude"));
+    const stop = await installStopHook(join16(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
 `);
@@ -8691,7 +8841,7 @@ program.command("install-skill").description("Deploy canonical SKILL.md to the a
   const failed = await deploySkill(
     cwd,
     await resolveTargets(cwd, options),
-    await readFile11(canonicalSkillPath(), "utf8")
+    await readFile12(canonicalSkillPath(), "utf8")
   );
   if (failed > 0) {
     process.stderr.write(`proctor: ${failed} adapter${failed === 1 ? "" : "s"} could not be written
@@ -8777,7 +8927,7 @@ ${done.length} item${done.length === 1 ? "" : "s"} would be removed. Re-run with
 });
 program.command("drift-check").description("Verify every deployed agent adapter still matches canonical SKILL.md").action(async () => {
   const cwd = process.cwd();
-  const canonical = await readFile11(canonicalSkillPath(), "utf8");
+  const canonical = await readFile12(canonicalSkillPath(), "utf8");
   const { drifted } = await checkAdapterDrift(cwd, canonical);
   for (const path9 of drifted) {
     process.stderr.write("Drifted: " + path9 + "\n");
@@ -8885,10 +9035,10 @@ 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 = join15(process.cwd(), "proctor.config.json");
+  const configPath = join16(process.cwd(), "proctor.config.json");
   let config = {};
   try {
-    config = JSON.parse(await readFile11(configPath, "utf8"));
+    config = JSON.parse(await readFile12(configPath, "utf8"));
   } catch (err) {
     if (err.code !== "ENOENT") {
       process.stderr.write(`proctor: could not read ${configPath}: ${String(err)}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kavishdua/proctor",
-  "version": "1.2.2",
+  "version": "1.3.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": {
@@ -60,7 +60,7 @@
     "lint": "oxlint --deny correctness --allow no-unused-vars --allow no-useless-escape --allow prefer-string-starts-ends-with src tests scripts tsup.config.ts vitest.config.ts"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.134.0",
+    "@anthropic-ai/sdk": "^1.3.0",
     "acorn": "^8.19.0",
     "brace-expansion": "^5.0.12",
     "commander": "^14.0.3",