agent-gauntlet 1.0.0 → 1.2.0

package/dist/index.js

@@ -299,7 +299,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "agent-gauntlet",
-  version: "1.0.0",
+  version: "1.2.0",
   description: "A CLI tool for testing AI coding agents",
   license: "MIT",
   author: "Paul Caplan",
@@ -552,7 +552,8 @@ var reviewGateSchema = z2.object({
   parallel: z2.boolean().default(true),
   run_in_ci: z2.boolean().default(true),
   run_locally: z2.boolean().default(true),
-  timeout: z2.number().optional()
+  timeout: z2.number().optional(),
+  enabled: z2.boolean().default(true)
 });
 var reviewPromptFrontmatterSchema = z2.object({
   model: z2.string().optional(),
@@ -563,7 +564,8 @@ var reviewPromptFrontmatterSchema = z2.object({
   run_locally: z2.boolean().default(true),
   timeout: z2.number().optional(),
   prompt_file: z2.string().optional(),
-  skill_name: z2.string().optional()
+  skill_name: z2.string().optional(),
+  enabled: z2.boolean().default(true)
 }).refine((data) => !(data.prompt_file && data.skill_name), {
   message: "'prompt_file' and 'skill_name' are mutually exclusive. Specify only one."
 });
@@ -577,7 +579,8 @@ var reviewYamlSchema = z2.object({
   timeout: z2.number().optional(),
   prompt_file: z2.string().optional(),
   skill_name: z2.string().optional(),
-  builtin: z2.string().optional()
+  builtin: z2.string().optional(),
+  enabled: z2.boolean().default(true)
 }).superRefine((data, ctx) => {
   const sources = [data.prompt_file, data.skill_name, data.builtin].filter(Boolean);
   if (sources.length > 1) {
@@ -742,7 +745,8 @@ async function loadMarkdownReview(file, reviewsPath, gauntletPath) {
     parallel: parsedFrontmatter.parallel,
     run_in_ci: parsedFrontmatter.run_in_ci,
     run_locally: parsedFrontmatter.run_locally,
-    timeout: parsedFrontmatter.timeout
+    timeout: parsedFrontmatter.timeout,
+    enabled: parsedFrontmatter.enabled
   };
   if (parsedFrontmatter.prompt_file) {
     review.promptContent = await loadPromptFile(parsedFrontmatter.prompt_file, gauntletPath, `review "${name}"`);
@@ -768,7 +772,8 @@ async function loadYamlReview(file, reviewsPath, gauntletPath) {
     parallel: parsed.parallel,
     run_in_ci: parsed.run_in_ci,
     run_locally: parsed.run_locally,
-    timeout: parsed.timeout
+    timeout: parsed.timeout,
+    enabled: parsed.enabled
   };
   if (parsed.prompt_file) {
     review.promptContent = await loadPromptFile(parsed.prompt_file, gauntletPath, `review "${name}"`);
@@ -849,9 +854,10 @@ async function dirExists(path4) {
 }
 
 // src/core/change-detector.ts
-import { exec } from "node:child_process";
+import { exec, execFile } from "node:child_process";
 import { promisify } from "node:util";
 var execAsync = promisify(exec);
+var execFileAsync = promisify(execFile);
 function isValidGitRef(ref) {
   return /^[a-zA-Z0-9._\-/]+$/.test(ref);
 }
@@ -924,8 +930,40 @@ class ChangeDetector {
     ]);
     return Array.from(files);
   }
+  async resolveLocalBaseBranch() {
+    const base = this.baseBranch;
+    if (base.startsWith("origin/"))
+      return base;
+    const remoteRef = `origin/${base}`;
+    const [localExists, remoteExists] = await Promise.all([
+      execFileAsync("git", ["rev-parse", "--verify", base]).then(() => true, () => false),
+      execFileAsync("git", ["rev-parse", "--verify", remoteRef]).then(() => true, () => false)
+    ]);
+    if (!remoteExists)
+      return base;
+    if (!localExists)
+      return remoteRef;
+    try {
+      const [{ stdout: remoteAhead }, { stdout: localAhead }] = await Promise.all([
+        execFileAsync("git", [
+          "rev-list",
+          "--count",
+          `${base}..${remoteRef}`
+        ]),
+        execFileAsync("git", [
+          "rev-list",
+          "--count",
+          `${remoteRef}..${base}`
+        ])
+      ]);
+      return parseInt(localAhead.trim(), 10) > parseInt(remoteAhead.trim(), 10) ? base : remoteRef;
+    } catch {
+      return remoteRef;
+    }
+  }
   async getLocalChangedFiles() {
-    return this.getDiffWithWorkingTree(this.baseBranch);
+    const resolvedBase = await this.resolveLocalBaseBranch();
+    return this.getDiffWithWorkingTree(resolvedBase);
   }
   async getCommitChangedFiles(commit) {
     try {
@@ -1081,8 +1119,10 @@ function shouldRunGate(gateConfig, isCI) {
 
 class JobGenerator {
   config;
-  constructor(config) {
+  enableReviews;
+  constructor(config, enableReviews = new Set) {
     this.config = config;
+    this.enableReviews = enableReviews;
   }
   generateJobs(expandedEntryPoints) {
     const jobs = [];
@@ -1131,6 +1171,8 @@ class JobGenerator {
       }
       if (!shouldRunGate(reviewConfig, isCI))
         continue;
+      if (!(reviewConfig.enabled || this.enableReviews.has(reviewName)))
+        continue;
       jobs.push({
         id: `review:${ep.path}:${reviewName}`,
         type: "review",
@@ -1663,9 +1705,10 @@ import fs9 from "node:fs/promises";
 import path8 from "node:path";
 
 // src/utils/execution-state.ts
-import { spawn as spawn2 } from "node:child_process";
+import { execFile as execFile2, spawn as spawn2 } from "node:child_process";
 import fs8 from "node:fs/promises";
 import path7 from "node:path";
+import { StringDecoder } from "node:string_decoder";
 
 // src/utils/debug-log.ts
 import fs7 from "node:fs/promises";
@@ -1837,6 +1880,35 @@ function getDebugLogger() {
 // src/utils/execution-state.ts
 var EXECUTION_STATE_FILENAME = ".execution_state";
 var SESSION_REF_FILENAME = ".session_ref";
+function getStatePath(logDir) {
+  return path7.join(logDir, EXECUTION_STATE_FILENAME);
+}
+function spawnGit(args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2("git", args, { stdio: ["ignore", "pipe", "pipe"] });
+    const stdoutDecoder = new StringDecoder("utf8");
+    const stderrDecoder = new StringDecoder("utf8");
+    let stdout = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += typeof chunk === "string" ? chunk : stdoutDecoder.write(chunk);
+    });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += typeof chunk === "string" ? chunk : stderrDecoder.write(chunk);
+    });
+    child.on("close", (code) => {
+      stdout += stdoutDecoder.end();
+      stderr += stderrDecoder.end();
+      if (code === 0)
+        resolve(stdout.trim());
+      else {
+        const detail = stderr.trim();
+        reject(new Error(detail ? `git ${args.join(" ")} failed with code ${code}: ${detail}` : `git ${args.join(" ")} failed with code ${code}`));
+      }
+    });
+    child.on("error", reject);
+  });
+}
 function isPlainRecord(value) {
   if (value == null)
     return false;
@@ -1859,7 +1931,7 @@ function isValidStateData(data) {
 }
 async function readExecutionState(logDir) {
   try {
-    const statePath = path7.join(logDir, EXECUTION_STATE_FILENAME);
+    const statePath = getStatePath(logDir);
     const content = await fs8.readFile(statePath, "utf-8");
     const data = JSON.parse(content);
     if (!isValidStateData(data))
@@ -1880,38 +1952,52 @@ async function readExecutionState(logDir) {
     return null;
   }
 }
-async function resolveStashResult(code, stdout) {
-  if (code === 0) {
-    const sha = stdout.trim();
-    if (sha)
-      return sha;
+async function createWorkingTreeRef() {
+  const hasChanges = await hasWorkingTreeChanges();
+  if (!hasChanges) {
     return getCurrentCommit();
   }
-  return getCurrentCommit().catch(() => {
-    throw new Error(`git stash create failed with code ${code}`);
-  });
-}
-async function createWorkingTreeRef() {
-  return new Promise((resolve, reject) => {
-    const child = spawn2("git", ["stash", "create", "--include-untracked"], {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    child.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    child.on("close", (code) => {
-      resolveStashResult(code, stdout).then(resolve, reject);
+  const runGit = (args) => new Promise((resolve, reject) => {
+    execFile2("git", args, (error, stdout) => {
+      if (error)
+        reject(error);
+      else
+        resolve(stdout.trim());
     });
-    child.on("error", reject);
   });
+  const prevTop = await runGit(["rev-parse", "--verify", "stash@{0}"]).catch(() => "");
+  try {
+    await runGit([
+      "stash",
+      "push",
+      "--include-untracked",
+      "-m",
+      "gauntlet-snapshot"
+    ]);
+  } catch {
+    return getCurrentCommit();
+  }
+  const newTop = await runGit(["rev-parse", "stash@{0}"]).catch(() => "");
+  const createdStash = !!newTop && newTop !== prevTop;
+  if (!createdStash) {
+    if (prevTop && !newTop) {
+      console.error("gauntlet: unable to verify stash snapshot; leaving stash untouched. Run `git stash pop` manually if needed.");
+    }
+    return getCurrentCommit();
+  }
+  try {
+    await runGit(["stash", "pop"]);
+  } catch {
+    console.error("gauntlet: stash pop failed — run `git stash pop` manually to restore your working tree");
+  }
+  return newTop;
 }
 async function writeExecutionState(logDir) {
-  const statePath = path7.join(logDir, EXECUTION_STATE_FILENAME);
-  const [branch, commit, workingTreeRef, rawState] = await Promise.all([
+  const statePath = getStatePath(logDir);
+  const workingTreeRef = await createWorkingTreeRef();
+  const [branch, commit, rawState] = await Promise.all([
     getCurrentBranch(),
     getCurrentCommit(),
-    createWorkingTreeRef(),
     readRawState(statePath)
   ]);
   const existingUnhealthy = extractUnhealthyAdapters(rawState);
@@ -1946,91 +2032,23 @@ async function writeExecutionState(logDir) {
     await fs8.rm(sessionRefPath, { force: true });
   } catch {}
 }
-async function getCurrentBranch() {
-  return new Promise((resolve, reject) => {
-    const child = spawn2("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    child.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve(stdout.trim());
-      } else {
-        reject(new Error(`git rev-parse failed with code ${code}`));
-      }
-    });
-    child.on("error", reject);
-  });
+function getCurrentBranch() {
+  return spawnGit(["rev-parse", "--abbrev-ref", "HEAD"]);
 }
-async function getCurrentCommit() {
-  return new Promise((resolve, reject) => {
-    const child = spawn2("git", ["rev-parse", "HEAD"], {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    child.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve(stdout.trim());
-      } else {
-        reject(new Error(`git rev-parse failed with code ${code}`));
-      }
-    });
-    child.on("error", reject);
-  });
+function getCurrentCommit() {
+  return spawnGit(["rev-parse", "HEAD"]);
 }
-async function isCommitInBranch(commit, branch) {
-  return new Promise((resolve) => {
-    const child = spawn2("git", ["merge-base", "--is-ancestor", commit, branch], { stdio: ["ignore", "pipe", "pipe"] });
-    child.on("close", (code) => {
-      resolve(code === 0);
-    });
-    child.on("error", () => {
-      resolve(false);
-    });
-  });
+function isCommitInBranch(commit, branch) {
+  return spawnGit(["merge-base", "--is-ancestor", commit, branch]).then(() => true).catch(() => false);
 }
 function getExecutionStateFilename() {
   return EXECUTION_STATE_FILENAME;
 }
-async function hasWorkingTreeChanges() {
-  return new Promise((resolve) => {
-    const child = spawn2("git", ["status", "--porcelain"], {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    child.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve(stdout.trim().length > 0);
-      } else {
-        resolve(true);
-      }
-    });
-    child.on("error", () => {
-      resolve(true);
-    });
-  });
+function hasWorkingTreeChanges() {
+  return spawnGit(["status", "--porcelain"]).then((out) => out.length > 0).catch(() => true);
 }
-async function gitObjectExists(sha) {
-  return new Promise((resolve) => {
-    const child = spawn2("git", ["cat-file", "-t", sha], {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    child.on("close", (code) => {
-      resolve(code === 0);
-    });
-    child.on("error", () => {
-      resolve(false);
-    });
-  });
+function gitObjectExists(sha) {
+  return spawnGit(["cat-file", "-t", sha]).then(() => true).catch(() => false);
 }
 async function resolveFixBaseForMergedCommit(working_tree_ref) {
   if (!working_tree_ref) {
@@ -2074,7 +2092,7 @@ function isAdapterCoolingDown(entry) {
   return Date.now() - markedAt < COOLDOWN_MS;
 }
 async function getUnhealthyAdapters(logDir) {
-  const statePath = path7.join(logDir, EXECUTION_STATE_FILENAME);
+  const statePath = getStatePath(logDir);
   const rawState = await readRawState(statePath);
   return extractUnhealthyAdapters(rawState) ?? {};
 }
@@ -2088,7 +2106,7 @@ async function readRawState(statePath) {
 }
 async function markAdapterUnhealthy(logDir, adapterName, reason) {
   await getDebugLogger()?.logAdapterHealthChange(adapterName, false, reason);
-  const statePath = path7.join(logDir, EXECUTION_STATE_FILENAME);
+  const statePath = getStatePath(logDir);
   const rawData = await readRawState(statePath) ?? {};
   const adapters = rawData.unhealthy_adapters ?? {};
   adapters[adapterName] = {
@@ -2101,7 +2119,7 @@ async function markAdapterUnhealthy(logDir, adapterName, reason) {
 }
 async function markAdapterHealthy(logDir, adapterName) {
   await getDebugLogger()?.logAdapterHealthChange(adapterName, true);
-  const statePath = path7.join(logDir, EXECUTION_STATE_FILENAME);
+  const statePath = getStatePath(logDir);
   const rawData = await readRawState(statePath);
   if (!rawData)
     return;
@@ -2119,7 +2137,7 @@ async function markAdapterHealthy(logDir, adapterName) {
 async function deleteExecutionState(logDir) {
   try {
     await getDebugLogger()?.logStateDelete();
-    const statePath = path7.join(logDir, EXECUTION_STATE_FILENAME);
+    const statePath = getStatePath(logDir);
     await fs8.rm(statePath, { force: true });
   } catch {}
 }
@@ -2183,11 +2201,11 @@ async function checkRunInterval(logDir, intervalMinutes) {
   return elapsedMinutes >= intervalMinutes;
 }
 async function hasChangesVsBaseBranch(cwd, baseBranch) {
-  const { execFile } = await import("node:child_process");
+  const { execFile: execFile3 } = await import("node:child_process");
   const { promisify: promisify3 } = await import("node:util");
-  const execFileAsync = promisify3(execFile);
+  const execFileAsync2 = promisify3(execFile3);
   try {
-    const { stdout } = await execFileAsync("git", ["diff", "--name-only", `${baseBranch}...HEAD`], { cwd });
+    const { stdout } = await execFileAsync2("git", ["diff", "--name-only", `${baseBranch}...HEAD`], { cwd });
     return stdout.trim().length > 0;
   } catch {
     return true;
@@ -3014,6 +3032,7 @@ import os3 from "node:os";
 import path12 from "node:path";
 import { promisify as promisify4 } from "node:util";
 var execAsync4 = promisify4(exec4);
+var _tmpCounter = 0;
 function parseJsonlLine(line) {
   try {
     const obj = JSON.parse(line);
@@ -3176,7 +3195,7 @@ class CodexAdapter {
 --- DIFF ---
 ${opts.diff}`;
     const tmpDir = os3.tmpdir();
-    const tmpFile = path12.join(tmpDir, `gauntlet-codex-${Date.now()}.txt`);
+    const tmpFile = path12.join(tmpDir, `gauntlet-codex-${process.pid}-${Date.now()}-${_tmpCounter++}.txt`);
     await fs13.writeFile(tmpFile, fullContent);
     const args = this.buildArgs(opts.allowToolUse, opts.thinkingBudget);
     const cleanup = () => fs13.unlink(tmpFile).catch(() => {});
@@ -3254,6 +3273,7 @@ function resolveModelFromList(allModels, opts) {
 
 // src/cli-adapters/cursor.ts
 var execAsync5 = promisify5(exec5);
+var _tmpCounter2 = 0;
 var log = getCategoryLogger("cursor");
 function parseModelList(output) {
   return output.split(`
@@ -3344,7 +3364,7 @@ class CursorAdapter {
 --- DIFF ---
 ${opts.diff}`;
     const tmpDir = os4.tmpdir();
-    const tmpFile = path13.join(tmpDir, `gauntlet-cursor-${process.pid}-${Date.now()}.txt`);
+    const tmpFile = path13.join(tmpDir, `gauntlet-cursor-${process.pid}-${Date.now()}-${_tmpCounter2++}.txt`);
     await fs14.writeFile(tmpFile, fullContent);
     let resolvedModel;
     if (opts.model) {
@@ -3747,6 +3767,7 @@ import os6 from "node:os";
 import path15 from "node:path";
 import { promisify as promisify7 } from "node:util";
 var execAsync7 = promisify7(exec7);
+var _tmpCounter3 = 0;
 var log2 = getCategoryLogger("github-copilot");
 function parseCopilotModels(helpOutput) {
   const match = helpOutput.match(/choices:\s*(.+?)\)/);
@@ -3835,7 +3856,7 @@ class GitHubCopilotAdapter {
 --- DIFF ---
 ${opts.diff}`;
     const tmpDir = os6.tmpdir();
-    const tmpFile = path15.join(tmpDir, `gauntlet-copilot-${process.pid}-${Date.now()}.txt`);
+    const tmpFile = path15.join(tmpDir, `gauntlet-copilot-${process.pid}-${Date.now()}-${_tmpCounter3++}.txt`);
     await fs16.writeFile(tmpFile, fullContent);
     let resolvedModel;
     if (opts.model) {
@@ -4068,98 +4089,504 @@ async function handleCriticalError(error, jobId, startTime, logPaths, mainLogger
 
 // src/gates/review-diff.ts
 import { exec as exec8 } from "node:child_process";
+import fs18 from "node:fs/promises";
+import os7 from "node:os";
+import path16 from "node:path";
+import { promisify as promisify9 } from "node:util";
+
+// src/core/diff-stats.ts
+import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify8 } from "node:util";
-var log4 = getCategoryLogger("gate", "review");
-var execAsync8 = promisify8(exec8);
-function parseLines(stdout) {
-  return stdout.split(`
-`).map((line) => line.trim()).filter((line) => line.length > 0);
+var execFileAsyncOriginal = promisify8(execFile3);
+var execFileAsync2 = execFileAsyncOriginal;
+async function gitExec(args) {
+  const { stdout } = await execFileAsync2("git", args, {
+    maxBuffer: MAX_BUFFER_BYTES
+  });
+  return stdout;
 }
-function pathArg(entryPointPath) {
-  return ` -- ${quoteArg(entryPointPath)}`;
+async function computeDiffStats(baseBranch, options = {}) {
+  if (options.commit) {
+    return computeCommitDiffStats(options.commit);
+  }
+  if (options.fixBase) {
+    return computeFixBaseDiffStats(options.fixBase);
+  }
+  if (options.uncommitted) {
+    return computeUncommittedDiffStats();
+  }
+  const isCI = process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true";
+  if (isCI) {
+    return computeCIDiffStats(baseBranch);
+  }
+  return computeLocalDiffStats(baseBranch);
 }
-function quoteArg(value) {
-  return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
+async function computeCommitDiffStats(commit) {
+  try {
+    const numstat = await gitExec([
+      "diff",
+      "--numstat",
+      `${commit}^..${commit}`
+    ]);
+    const lineStats = parseNumstat(numstat);
+    const nameStatus = await gitExec([
+      "diff",
+      "--name-status",
+      `${commit}^..${commit}`
+    ]);
+    const fileStats = parseNameStatus(nameStatus);
+    return {
+      baseRef: `${commit}^`,
+      ...fileStats,
+      ...lineStats
+    };
+  } catch {
+    try {
+      const numstat = await gitExec(["diff", "--numstat", "--root", commit]);
+      const lineStats = parseNumstat(numstat);
+      const nameStatus = await gitExec([
+        "diff",
+        "--name-status",
+        "--root",
+        commit
+      ]);
+      const fileStats = parseNameStatus(nameStatus);
+      return {
+        baseRef: "root",
+        ...fileStats,
+        ...lineStats
+      };
+    } catch {
+      return emptyDiffStats(commit);
+    }
+  }
 }
-async function execDiff(command) {
+async function computeUncommittedDiffStats() {
+  const stagedNumstat = await gitExec(["diff", "--numstat", "--cached"]);
+  const stagedLines = parseNumstat(stagedNumstat);
+  const stagedStatus = await gitExec(["diff", "--name-status", "--cached"]);
+  const stagedFiles = parseNameStatus(stagedStatus);
+  const unstagedNumstat = await gitExec(["diff", "--numstat"]);
+  const unstagedLines = parseNumstat(unstagedNumstat);
+  const unstagedStatus = await gitExec(["diff", "--name-status"]);
+  const unstagedFiles = parseNameStatus(unstagedStatus);
+  const untrackedList = await gitExec([
+    "ls-files",
+    "--others",
+    "--exclude-standard"
+  ]);
+  const untrackedFiles = untrackedList.split(`
+`).map((f) => f.trim()).filter((f) => f.length > 0);
+  return {
+    baseRef: "uncommitted",
+    total: stagedFiles.total + unstagedFiles.total + untrackedFiles.length - countOverlap(stagedStatus, unstagedStatus),
+    newFiles: stagedFiles.newFiles + unstagedFiles.newFiles + untrackedFiles.length,
+    modifiedFiles: stagedFiles.modifiedFiles + unstagedFiles.modifiedFiles,
+    deletedFiles: stagedFiles.deletedFiles + unstagedFiles.deletedFiles,
+    linesAdded: stagedLines.linesAdded + unstagedLines.linesAdded,
+    linesRemoved: stagedLines.linesRemoved + unstagedLines.linesRemoved
+  };
+}
+async function getStashUntrackedFiles(fixBase, pathFilter) {
   try {
-    const { stdout } = await execAsync8(command, {
-      maxBuffer: MAX_BUFFER_BYTES
-    });
-    return stdout;
-  } catch (error) {
-    const err = error;
-    if (typeof err.code === "number" && err.stdout) {
-      return err.stdout;
+    const args = ["ls-tree", "-r", "--name-only", `${fixBase}^3`];
+    if (pathFilter) {
+      args.push("--", pathFilter);
     }
-    throw error;
+    const treeFiles = await gitExec(args);
+    return new Set(treeFiles.split(`
+`).map((f) => f.trim()).filter((f) => f.length > 0));
+  } catch {
+    return new Set;
   }
 }
-async function untrackedDiff(entryPointPath) {
-  const pArg = pathArg(entryPointPath);
-  const { stdout } = await execAsync8(`git ls-files --others --exclude-standard${pArg}`, { maxBuffer: MAX_BUFFER_BYTES });
-  const files = parseLines(stdout);
-  const diffs = [];
+async function countChangedStashUntracked(files, fixBase) {
+  let changed = 0;
   for (const file of files) {
     try {
-      const diff = await execDiff(`git diff --no-index -- /dev/null ${quoteArg(file)}`);
-      if (diff.trim())
-        diffs.push(diff);
-    } catch (error) {
-      const err = error;
-      const msg = [err.message, err.stderr].filter(Boolean).join(`
-`);
-      if (msg.includes("Could not access") || msg.includes("ENOENT") || msg.includes("No such file")) {
-        continue;
+      const [oldHash, newHash] = await Promise.all([
+        gitExec(["rev-parse", `${fixBase}^3:${file}`]),
+        gitExec(["hash-object", "--", file])
+      ]);
+      if (oldHash.trim() !== newHash.trim()) {
+        changed++;
       }
-      throw error;
+    } catch {
+      changed++;
     }
   }
-  return diffs.join(`
-`);
-}
-async function getDiff(entryPointPath, baseBranch, options) {
-  log4.debug(`getDiff: entryPoint=${entryPointPath}, fixBase=${options?.fixBase ?? "none"}, uncommitted=${options?.uncommitted ?? false}, commit=${options?.commit ?? "none"}`);
-  if (options?.fixBase) {
-    const result = await getFixBaseDiff(entryPointPath, options.fixBase);
-    if (result !== null)
-      return result;
-  }
-  if (options?.uncommitted) {
-    return getUncommittedDiff(entryPointPath);
-  }
-  if (options?.commit) {
-    return getCommitDiff(entryPointPath, options.commit);
-  }
-  const isCI = process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true";
-  return isCI ? getCIDiff(entryPointPath, baseBranch) : getLocalDiff(entryPointPath, baseBranch);
+  return changed;
 }
-async function getFixBaseDiff(entryPointPath, fixBase) {
-  if (!/^[a-f0-9]+$/.test(fixBase)) {
-    throw new Error(`Invalid session ref: ${fixBase}`);
-  }
-  const pArg = pathArg(entryPointPath);
+async function computeFixBaseDiffStats(fixBase) {
   try {
-    const diff = await execDiff(`git diff ${fixBase}${pArg}`);
-    const { stdout: untrackedStdout } = await execAsync8(`git ls-files --others --exclude-standard${pArg}`, { maxBuffer: MAX_BUFFER_BYTES });
-    const currentUntracked = new Set(parseLines(untrackedStdout));
-    const { stdout: snapshotFilesStdout } = await execAsync8(`git ls-tree -r --name-only ${fixBase}${pArg}`, { maxBuffer: MAX_BUFFER_BYTES });
-    const snapshotFiles = new Set(parseLines(snapshotFilesStdout));
-    const newUntracked = [...currentUntracked].filter((f) => !snapshotFiles.has(f));
-    const newUntrackedDiffs = await collectUntrackedDiffs(newUntracked);
-    const scopedDiff = [diff, ...newUntrackedDiffs].filter(Boolean).join(`
-`);
-    log4.debug(`Scoped diff via fixBase: ${scopedDiff.split(`
-`).length} lines`);
-    return scopedDiff;
-  } catch (error) {
-    log4.warn(`Failed to compute diff against fixBase ${fixBase}, falling back to full uncommitted diff. ${error instanceof Error ? error.message : error}`);
-    return null;
-  }
-}
-async function collectUntrackedDiffs(files) {
-  const diffs = [];
-  for (const file of files) {
+    const numstat = await gitExec(["diff", "--numstat", fixBase]);
+    const lineStats = parseNumstat(numstat);
+    const nameStatus = await gitExec(["diff", "--name-status", fixBase]);
+    const fileStats = parseNameStatus(nameStatus);
+    const currentUntracked = (await gitExec(["ls-files", "--others", "--exclude-standard"])).split(`
+`).map((f) => f.trim()).filter((f) => f.length > 0);
+    let fixBaseTrackedFiles;
+    try {
+      const treeFiles = await gitExec([
+        "ls-tree",
+        "-r",
+        "--name-only",
+        fixBase
+      ]);
+      fixBaseTrackedFiles = new Set(treeFiles.split(`
+`).map((f) => f.trim()).filter((f) => f.length > 0));
+    } catch {
+      fixBaseTrackedFiles = new Set;
+    }
+    const fixBaseUntrackedFiles = await getStashUntrackedFiles(fixBase);
+    const allSnapshotFiles = new Set([
+      ...fixBaseTrackedFiles,
+      ...fixBaseUntrackedFiles
+    ]);
+    const newUntrackedFiles = currentUntracked.filter((f) => !allSnapshotFiles.has(f));
+    const knownUntrackedFiles = currentUntracked.filter((f) => fixBaseUntrackedFiles.has(f));
+    const changedKnownUntracked = await countChangedStashUntracked(knownUntrackedFiles, fixBase);
+    return {
+      baseRef: fixBase,
+      total: fileStats.total + newUntrackedFiles.length + changedKnownUntracked,
+      newFiles: fileStats.newFiles + newUntrackedFiles.length,
+      modifiedFiles: fileStats.modifiedFiles + changedKnownUntracked,
+      deletedFiles: fileStats.deletedFiles,
+      linesAdded: lineStats.linesAdded,
+      linesRemoved: lineStats.linesRemoved
+    };
+  } catch {
+    return emptyDiffStats(fixBase);
+  }
+}
+async function computeCIDiffStats(baseBranch) {
+  const headRef = process.env.GITHUB_SHA || "HEAD";
+  try {
+    const numstat = await gitExec([
+      "diff",
+      "--numstat",
+      `${baseBranch}...${headRef}`
+    ]);
+    const lineStats = parseNumstat(numstat);
+    const nameStatus = await gitExec([
+      "diff",
+      "--name-status",
+      `${baseBranch}...${headRef}`
+    ]);
+    const fileStats = parseNameStatus(nameStatus);
+    return {
+      baseRef: baseBranch,
+      ...fileStats,
+      ...lineStats
+    };
+  } catch {
+    try {
+      const numstat = await gitExec(["diff", "--numstat", "HEAD^...HEAD"]);
+      const lineStats = parseNumstat(numstat);
+      const nameStatus = await gitExec([
+        "diff",
+        "--name-status",
+        "HEAD^...HEAD"
+      ]);
+      const fileStats = parseNameStatus(nameStatus);
+      return {
+        baseRef: "HEAD^",
+        ...fileStats,
+        ...lineStats
+      };
+    } catch {
+      return emptyDiffStats(baseBranch);
+    }
+  }
+}
+async function computeLocalDiffStats(baseBranch) {
+  const committedNumstat = await gitExec([
+    "diff",
+    "--numstat",
+    `${baseBranch}...HEAD`
+  ]);
+  const committedLines = parseNumstat(committedNumstat);
+  const committedStatus = await gitExec([
+    "diff",
+    "--name-status",
+    `${baseBranch}...HEAD`
+  ]);
+  const committedFiles = parseNameStatus(committedStatus);
+  const uncommittedNumstat = await gitExec(["diff", "--numstat", "HEAD"]);
+  const uncommittedLines = parseNumstat(uncommittedNumstat);
+  const uncommittedStatus = await gitExec(["diff", "--name-status", "HEAD"]);
+  const uncommittedFiles = parseNameStatus(uncommittedStatus);
+  const untrackedList = await gitExec([
+    "ls-files",
+    "--others",
+    "--exclude-standard"
+  ]);
+  const untrackedFiles = untrackedList.split(`
+`).map((f) => f.trim()).filter((f) => f.length > 0);
+  const totalNew = committedFiles.newFiles + uncommittedFiles.newFiles + untrackedFiles.length;
+  const totalModified = committedFiles.modifiedFiles + uncommittedFiles.modifiedFiles;
+  const totalDeleted = committedFiles.deletedFiles + uncommittedFiles.deletedFiles;
+  return {
+    baseRef: baseBranch,
+    total: totalNew + totalModified + totalDeleted,
+    newFiles: totalNew,
+    modifiedFiles: totalModified,
+    deletedFiles: totalDeleted,
+    linesAdded: committedLines.linesAdded + uncommittedLines.linesAdded,
+    linesRemoved: committedLines.linesRemoved + uncommittedLines.linesRemoved
+  };
+}
+function parseNumstat(output) {
+  let linesAdded = 0;
+  let linesRemoved = 0;
+  for (const line of output.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    const parts = line.split("\t");
+    if (parts.length < 3)
+      continue;
+    const added = parts[0];
+    const removed = parts[1];
+    if (added && added !== "-") {
+      linesAdded += parseInt(added, 10) || 0;
+    }
+    if (removed && removed !== "-") {
+      linesRemoved += parseInt(removed, 10) || 0;
+    }
+  }
+  return { linesAdded, linesRemoved };
+}
+function parseNameStatus(output) {
+  let newFiles = 0;
+  let modifiedFiles = 0;
+  let deletedFiles = 0;
+  for (const line of output.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    const status = line[0];
+    switch (status) {
+      case "A":
+        newFiles++;
+        break;
+      case "M":
+      case "R":
+      case "C":
+      case "T":
+        modifiedFiles++;
+        break;
+      case "D":
+        deletedFiles++;
+        break;
+    }
+  }
+  return {
+    total: newFiles + modifiedFiles + deletedFiles,
+    newFiles,
+    modifiedFiles,
+    deletedFiles
+  };
+}
+function countOverlap(status1, status2) {
+  const files1 = new Set;
+  for (const line of status1.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    const parts = line.split("\t");
+    const file = parts[1];
+    if (parts.length >= 2 && file) {
+      files1.add(file);
+    }
+  }
+  let overlap = 0;
+  for (const line of status2.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    const parts = line.split("\t");
+    const file = parts[1];
+    if (parts.length >= 2 && file && files1.has(file)) {
+      overlap++;
+    }
+  }
+  return overlap;
+}
+function emptyDiffStats(baseRef) {
+  return {
+    baseRef,
+    total: 0,
+    newFiles: 0,
+    modifiedFiles: 0,
+    deletedFiles: 0,
+    linesAdded: 0,
+    linesRemoved: 0
+  };
+}
+
+// src/gates/review-diff.ts
+var log4 = getCategoryLogger("gate", "review");
+var execAsync8 = promisify9(exec8);
+function parseLines(stdout) {
+  return stdout.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function pathArg(entryPointPath) {
+  return ` -- ${quoteArg(entryPointPath)}`;
+}
+function quoteArg(value) {
+  return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
+}
+async function execDiff(command) {
+  try {
+    const { stdout } = await execAsync8(command, {
+      maxBuffer: MAX_BUFFER_BYTES
+    });
+    return stdout;
+  } catch (error) {
+    const err = error;
+    if (typeof err.code === "number" && err.stdout) {
+      return err.stdout;
+    }
+    throw error;
+  }
+}
+async function untrackedDiff(entryPointPath) {
+  const pArg = pathArg(entryPointPath);
+  const { stdout } = await execAsync8(`git ls-files --others --exclude-standard${pArg}`, { maxBuffer: MAX_BUFFER_BYTES });
+  const files = parseLines(stdout);
+  const diffs = [];
+  for (const file of files) {
+    try {
+      const diff = await execDiff(`git diff --no-index -- /dev/null ${quoteArg(file)}`);
+      if (diff.trim())
+        diffs.push(diff);
+    } catch (error) {
+      const err = error;
+      const msg = [err.message, err.stderr].filter(Boolean).join(`
+`);
+      if (msg.includes("Could not access") || msg.includes("ENOENT") || msg.includes("No such file")) {
+        continue;
+      }
+      throw error;
+    }
+  }
+  return diffs.join(`
+`);
+}
+async function getDiff(entryPointPath, baseBranch, options) {
+  log4.debug(`getDiff: entryPoint=${entryPointPath}, fixBase=${options?.fixBase ?? "none"}, uncommitted=${options?.uncommitted ?? false}, commit=${options?.commit ?? "none"}`);
+  if (options?.fixBase) {
+    const result = await getFixBaseDiff(entryPointPath, options.fixBase);
+    if (result !== null)
+      return result;
+  }
+  if (options?.uncommitted) {
+    return getUncommittedDiff(entryPointPath);
+  }
+  if (options?.commit) {
+    return getCommitDiff(entryPointPath, options.commit);
+  }
+  const isCI = process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true";
+  return isCI ? getCIDiff(entryPointPath, baseBranch) : getLocalDiff(entryPointPath, baseBranch);
+}
+async function hasFileChangedSinceStash(file, fixBase) {
+  const [{ stdout: oldHashOut }, { stdout: newHashOut }] = await Promise.all([
+    execAsync8(`git rev-parse ${quoteArg(`${fixBase}^3:${file}`)}`, {
+      maxBuffer: MAX_BUFFER_BYTES
+    }),
+    execAsync8(`git hash-object -- ${quoteArg(file)}`, {
+      maxBuffer: MAX_BUFFER_BYTES
+    })
+  ]);
+  return oldHashOut.trim() !== newHashOut.trim();
+}
+async function writeStashFileToTemp(file, fixBase, tmpDir, counter) {
+  const { stdout: oldContent } = await execAsync8(`git show ${quoteArg(`${fixBase}^3:${file}`)}`, { maxBuffer: MAX_BUFFER_BYTES, encoding: "buffer" });
+  const tmpFile = path16.join(tmpDir, `${counter}-${path16.basename(file)}`);
+  await fs18.writeFile(tmpFile, oldContent);
+  return tmpFile;
+}
+function placeholderDiff(file) {
+  return `diff --git a/${file} b/${file}
+--- /dev/null
++++ b/${file}
+@@ -0,0 +1 @@
++[gauntlet: diff unavailable for this file]`;
+}
+async function collectStashUntrackedDiffs(files, fixBase) {
+  if (files.length === 0)
+    return [];
+  const diffs = [];
+  const tmpDir = await fs18.mkdtemp(path16.join(os7.tmpdir(), "gauntlet-"));
+  try {
+    let counter = 0;
+    for (const file of files) {
+      const d = await diffSingleStashFile(file, fixBase, tmpDir, counter++);
+      if (d)
+        diffs.push(d);
+    }
+  } finally {
+    await fs18.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+  }
+  return diffs;
+}
+async function diffSingleStashFile(file, fixBase, tmpDir, counter) {
+  try {
+    if (!await hasFileChangedSinceStash(file, fixBase)) {
+      return null;
+    }
+    const tmpFile = await writeStashFileToTemp(file, fixBase, tmpDir, counter);
+    const d = await execDiff(`git diff --no-index -- ${quoteArg(tmpFile)} ${quoteArg(file)}`);
+    return d.trim() || null;
+  } catch (outerErr) {
+    log4.debug(`Stash diff failed for ${file}, falling back to full diff: ${outerErr instanceof Error ? outerErr.message : outerErr}`);
+    return diffFallbackToDevNull(file);
+  }
+}
+async function diffFallbackToDevNull(file) {
+  try {
+    const d = await execDiff(`git diff --no-index -- /dev/null ${quoteArg(file)}`);
+    return d.trim() || null;
+  } catch (innerErr) {
+    log4.warn(`Failed to compute any diff for ${file}: ${innerErr instanceof Error ? innerErr.message : innerErr}`);
+    return placeholderDiff(file);
+  }
+}
+async function getFixBaseDiff(entryPointPath, fixBase) {
+  if (!/^[a-f0-9]+$/.test(fixBase)) {
+    throw new Error(`Invalid session ref: ${fixBase}`);
+  }
+  const pArg = pathArg(entryPointPath);
+  try {
+    const diff = await execDiff(`git diff ${fixBase}${pArg}`);
+    const { stdout: untrackedStdout } = await execAsync8(`git ls-files --others --exclude-standard${pArg}`, { maxBuffer: MAX_BUFFER_BYTES });
+    const currentUntracked = new Set(parseLines(untrackedStdout));
+    const { stdout: snapshotFilesStdout } = await execAsync8(`git ls-tree -r --name-only ${fixBase}${pArg}`, { maxBuffer: MAX_BUFFER_BYTES });
+    const snapshotTrackedFiles = new Set(parseLines(snapshotFilesStdout));
+    const snapshotUntrackedFiles = await getStashUntrackedFiles(fixBase, entryPointPath);
+    const allSnapshotFiles = new Set([
+      ...snapshotTrackedFiles,
+      ...snapshotUntrackedFiles
+    ]);
+    const newUntracked = [...currentUntracked].filter((f) => !allSnapshotFiles.has(f));
+    const knownUntracked = [...currentUntracked].filter((f) => snapshotUntrackedFiles.has(f));
+    const newUntrackedDiffs = await collectUntrackedDiffs(newUntracked);
+    const knownUntrackedDiffs = await collectStashUntrackedDiffs(knownUntracked, fixBase);
+    const scopedDiff = [diff, ...newUntrackedDiffs, ...knownUntrackedDiffs].filter(Boolean).join(`
+`);
+    log4.debug(`Scoped diff via fixBase: ${scopedDiff.split(`
+`).length} lines (${newUntracked.length} new, ${knownUntracked.length} known untracked)`);
+    return scopedDiff;
+  } catch (error) {
+    log4.warn(`Failed to compute diff against fixBase ${fixBase}, falling back to full uncommitted diff. ${error instanceof Error ? error.message : error}`);
+    return null;
+  }
+}
+async function collectUntrackedDiffs(files) {
+  const diffs = [];
+  for (const file of files) {
     try {
       const d = await execDiff(`git diff --no-index -- /dev/null ${quoteArg(file)}`);
       if (d.trim())
@@ -4725,7 +5152,7 @@ async function handleUsageLimit(adapter, logDir, mainLogger) {
 }
 
 // src/gates/review-helpers.ts
-import fs18 from "node:fs/promises";
+import fs19 from "node:fs/promises";
 var log6 = getCategoryLogger("gate", "review");
 async function collectHealthyAdapters(preferences, mainLogger, logDir) {
   const healthyAdapters = [];
@@ -4853,7 +5280,7 @@ async function writeSkippedSlotLog(assignment, loggerFactory, logPathsSet, logPa
     violations: [],
     passIteration: assignment.passIteration
   };
-  await fs18.writeFile(jsonPath, JSON.stringify(skippedOutput, null, 2));
+  await fs19.writeFile(jsonPath, JSON.stringify(skippedOutput, null, 2));
   if (!logPathsSet.has(logPath)) {
     logPathsSet.add(logPath);
     logPaths.push(logPath);
@@ -5250,19 +5677,19 @@ class Runner {
 }
 
 // src/output/console.ts
-import fs21 from "node:fs/promises";
+import fs22 from "node:fs/promises";
 import chalk2 from "chalk";
 
 // src/utils/log-parser.ts
-import fs20 from "node:fs/promises";
-import path18 from "node:path";
+import fs21 from "node:fs/promises";
+import path19 from "node:path";
 
 // src/utils/log-parser-find-helpers.ts
-import fs19 from "node:fs/promises";
-import path17 from "node:path";
+import fs20 from "node:fs/promises";
+import path18 from "node:path";
 
 // src/utils/log-parser-helpers.ts
-import path16 from "node:path";
+import path17 from "node:path";
 function parseReviewFilename(filename) {
   const m = filename.match(/^(.+)_([^@]+)@(\d+)\.(\d+)\.(log|json)$/);
   if (!m)
@@ -5434,9 +5861,9 @@ async function parseRunFile(logDir, runFiles, prefix, runNum, parseJsonFn, parse
   const jsonFile = runFiles.find((f) => f.startsWith(`${prefix}.${runNum}.`) && f.endsWith(".json"));
   const logFile = runFiles.find((f) => f.startsWith(`${prefix}.${runNum}.`) && f.endsWith(".log"));
   if (jsonFile)
-    return parseJsonFn(path16.join(logDir, jsonFile));
+    return parseJsonFn(path17.join(logDir, jsonFile));
   if (logFile)
-    return parseLogFn(path16.join(logDir, logFile));
+    return parseLogFn(path17.join(logDir, logFile));
   return null;
 }
 async function collectIterationFailures(logDir, files, runNum, parseJsonFn, parseLogFn) {
@@ -5553,7 +5980,7 @@ function addCheckFile(checkPrefixMap, file) {
 }
 async function isJsonReviewPassing(jsonPath) {
   try {
-    const content = await fs19.readFile(jsonPath, "utf-8");
+    const content = await fs20.readFile(jsonPath, "utf-8");
     const data = JSON.parse(content);
     return data.status === "pass" || data.status === "skipped_prior_pass";
   } catch {
@@ -5562,7 +5989,7 @@ async function isJsonReviewPassing(jsonPath) {
 }
 async function isLogReviewPassing(logPath) {
   try {
-    const content = await fs19.readFile(logPath, "utf-8");
+    const content = await fs20.readFile(logPath, "utf-8");
     if (content.includes("Status: skipped_prior_pass"))
       return true;
     if (content.includes("--- Review Output")) {
@@ -5618,7 +6045,7 @@ async function processReviewSlots(logDir, reviewSlotMap, includePassedSlots, par
     const reviewIndex = parseInt(slotKey.substring(sepIdx + 1), 10);
     const parsed = parseReviewFilename(fileInfo.filename);
     const adapter = parsed?.adapter || "unknown";
-    const filePath = path17.join(logDir, fileInfo.filename);
+    const filePath = path18.join(logDir, fileInfo.filename);
     const isPassing = fileInfo.ext === "json" ? await isJsonReviewPassing(filePath) : await isLogReviewPassing(filePath);
     if (isPassing && includePassedSlots) {
       recordPassedSlot(passedSlots, jobId, reviewIndex, fileInfo.runNumber, adapter);
@@ -5640,9 +6067,9 @@ async function processCheckFiles(logDir, checkPrefixMap, parseJsonFn, parseLogFn
       continue;
     let failure = null;
     if (exts.has("json")) {
-      failure = await parseJsonFn(path17.join(logDir, `${prefix}.${latestRun}.json`));
+      failure = await parseJsonFn(path18.join(logDir, `${prefix}.${latestRun}.json`));
     } else if (exts.has("log")) {
-      failure = await parseLogFn(path17.join(logDir, `${prefix}.${latestRun}.log`));
+      failure = await parseLogFn(path18.join(logDir, `${prefix}.${latestRun}.log`));
     }
     if (!failure)
       continue;
@@ -5660,9 +6087,9 @@ async function processCheckFiles(logDir, checkPrefixMap, parseJsonFn, parseLogFn
 var log9 = getCategoryLogger("log-parser");
 async function parseJsonReviewFile(jsonPath) {
   try {
-    const content = await fs20.readFile(jsonPath, "utf-8");
+    const content = await fs21.readFile(jsonPath, "utf-8");
     const data = JSON.parse(content);
-    const filename = path18.basename(jsonPath);
+    const filename = path19.basename(jsonPath);
     const parsed = parseReviewFilename(filename);
     const jobId = parsed ? parsed.jobId : filename.replace(/\.\d+\.json$/, "");
     if (data.status === "pass" || data.status === "skipped_prior_pass") {
@@ -5702,8 +6129,8 @@ async function parseJsonReviewFile(jsonPath) {
 }
 async function parseLogFile(logPath) {
   try {
-    const content = await fs20.readFile(logPath, "utf-8");
-    const filename = path18.basename(logPath);
+    const content = await fs21.readFile(logPath, "utf-8");
+    const filename = path19.basename(logPath);
     const parsed = parseReviewFilename(filename);
     const jobId = parsed ? parsed.jobId : extractPrefix(filename);
     if (content.includes("--- Review Output")) {
@@ -5716,7 +6143,7 @@ async function parseLogFile(logPath) {
 }
 async function reconstructHistory(logDir) {
   try {
-    const files = await fs20.readdir(logDir);
+    const files = await fs21.readdir(logDir);
     const sortedRuns = collectRunNumbers(files);
     const iterations = [];
     let previousFailuresByJob = new Map;
@@ -5733,7 +6160,7 @@ async function reconstructHistory(logDir) {
 }
 async function findPreviousFailures(logDir, gateFilter, includePassedSlots) {
   try {
-    const files = await fs20.readdir(logDir);
+    const files = await fs21.readdir(logDir);
     const { reviewSlotMap, checkPrefixMap } = categorizeFiles(files, gateFilter);
     const { jobReviewFailures, passedSlots } = await processReviewSlots(logDir, reviewSlotMap, includePassedSlots, parseJsonReviewFile, parseLogFile);
     const gateFailures = [];
@@ -5743,7 +6170,7 @@ async function findPreviousFailures(logDir, gateFilter, includePassedSlots) {
         gateName: "",
         entryPoint: "",
         adapterFailures,
-        logPath: path18.join(logDir, `${jobId}.log`)
+        logPath: path19.join(logDir, `${jobId}.log`)
       });
     }
     const checkFailures = await processCheckFiles(logDir, checkPrefixMap, parseJsonReviewFile, parseLogFile);
@@ -5762,12 +6189,12 @@ async function findPreviousFailures(logDir, gateFilter, includePassedSlots) {
 async function hasSkippedViolationsInLogs(opts) {
   const { logDir } = opts;
   try {
-    const files = await fs20.readdir(logDir);
+    const files = await fs21.readdir(logDir);
     for (const file of files) {
       if (!file.endsWith(".json"))
         continue;
       try {
-        const content = await fs20.readFile(path18.join(logDir, file), "utf-8");
+        const content = await fs21.readFile(path19.join(logDir, file), "utf-8");
         const data = JSON.parse(content);
         if (data.violations?.some((v) => v.status === "skipped")) {
           return true;
@@ -6025,7 +6452,7 @@ ${chalk2.bold(SEPARATOR)}`);
     const allDetails = [];
     for (const logPath of logPaths) {
       try {
-        const logContent = await fs21.readFile(logPath, "utf-8");
+        const logContent = await fs22.readFile(logPath, "utf-8");
         const details = this.parseLogContent(logContent, result.jobId);
         allDetails.push(...details);
       } catch (_error) {
@@ -6064,9 +6491,9 @@ ${chalk2.bold(SEPARATOR)}`);
 }
 
 // src/output/console-log.ts
-import fs22 from "node:fs";
+import fs23 from "node:fs";
 import fsPromises2 from "node:fs/promises";
-import path19 from "node:path";
+import path20 from "node:path";
 import { inspect } from "node:util";
 var ANSI_REGEX = /\x1b(?:\[[0-9;?]*[A-Za-z]|[78])/g;
 function stripAnsi(text) {
@@ -6076,9 +6503,9 @@ function formatArgs(args) {
   return args.map((a) => typeof a === "string" ? a : inspect(a, { depth: 4 })).join(" ");
 }
 function openLogFileExclusive(logDir, runNum) {
-  const logPath = path19.join(logDir, `console.${runNum}.log`);
+  const logPath = path20.join(logDir, `console.${runNum}.log`);
   try {
-    const fd = fs22.openSync(logPath, fs22.constants.O_WRONLY | fs22.constants.O_CREAT | fs22.constants.O_EXCL);
+    const fd = fs23.openSync(logPath, fs23.constants.O_WRONLY | fs23.constants.O_CREAT | fs23.constants.O_EXCL);
     return { fd, logPath };
   } catch (e) {
     const error = e;
@@ -6092,9 +6519,9 @@ function openLogFileExclusive(logDir, runNum) {
 function openLogFileFallback(logDir, startNum) {
   let runNum = startNum;
   for (let attempts = 0;attempts < 100; attempts++) {
-    const logPath = path19.join(logDir, `console.${runNum}.log`);
+    const logPath = path20.join(logDir, `console.${runNum}.log`);
     try {
-      const fd = fs22.openSync(logPath, fs22.constants.O_WRONLY | fs22.constants.O_CREAT | fs22.constants.O_EXCL);
+      const fd = fs23.openSync(logPath, fs23.constants.O_WRONLY | fs23.constants.O_CREAT | fs23.constants.O_EXCL);
       return { fd, logPath };
     } catch (e) {
       const error = e;
@@ -6115,7 +6542,7 @@ async function startConsoleLog(logDir, runNumber) {
       if (isClosed)
         return;
       try {
-        fs22.writeSync(fd, stripAnsi(text));
+        fs23.writeSync(fd, stripAnsi(text));
       } catch {}
     };
     const originalLog = console.log;
@@ -6163,7 +6590,7 @@ async function startConsoleLog(logDir, runNumber) {
         process.stdout.write = originalStdoutWrite;
         process.stderr.write = originalStderrWrite;
         try {
-          fs22.closeSync(fd);
+          fs23.closeSync(fd);
         } catch {}
       },
       writeToLogOnly: (text) => {
@@ -6171,20 +6598,20 @@ async function startConsoleLog(logDir, runNumber) {
       }
     };
   } catch (error) {
-    fs22.closeSync(fd);
+    fs23.closeSync(fd);
     throw error;
   }
 }
 
 // src/output/logger.ts
-import fs23 from "node:fs/promises";
-import path20 from "node:path";
+import fs24 from "node:fs/promises";
+import path21 from "node:path";
 function formatTimestamp() {
   return new Date().toISOString();
 }
 async function computeGlobalRunNumber(logDir) {
   try {
-    const files = await fs23.readdir(logDir);
+    const files = await fs24.readdir(logDir);
     let max = 0;
     for (const file of files) {
       if (!(file.endsWith(".log") || file.endsWith(".json")))
@@ -6210,7 +6637,7 @@ class Logger {
     this.logDir = logDir;
   }
   async init() {
-    await fs23.mkdir(this.logDir, { recursive: true });
+    await fs24.mkdir(this.logDir, { recursive: true });
     this.globalRunNumber = await computeGlobalRunNumber(this.logDir);
   }
   async close() {}
@@ -6228,14 +6655,14 @@ class Logger {
     } else {
       filename = `${safeName}.${runNum}.log`;
     }
-    return path20.join(this.logDir, filename);
+    return path21.join(this.logDir, filename);
   }
   async initFile(logPath) {
     if (this.initializedFiles.has(logPath)) {
       return;
     }
     this.initializedFiles.add(logPath);
-    await fs23.writeFile(logPath, "");
+    await fs24.writeFile(logPath, "");
   }
   async createJobLogger(jobId) {
     const logPath = await this.getLogPath(jobId);
@@ -6247,7 +6674,7 @@ class Logger {
       if (lines.length > 0) {
         lines[0] = `[${timestamp}] ${lines[0]}`;
       }
-      await fs23.appendFile(logPath, lines.join(`
+      await fs24.appendFile(logPath, lines.join(`
 `) + (text.endsWith(`
 `) ? "" : `
 `));
@@ -6264,7 +6691,7 @@ class Logger {
         if (lines.length > 0) {
           lines[0] = `[${timestamp}] ${lines[0]}`;
         }
-        await fs23.appendFile(logPath, lines.join(`
+        await fs24.appendFile(logPath, lines.join(`
 `) + (text.endsWith(`
 `) ? "" : `
 `));
@@ -6280,8 +6707,8 @@ function resolveBaseBranch(options, config) {
 }
 
 // src/commands/shared.ts
-import fs24 from "node:fs/promises";
-import path21 from "node:path";
+import fs25 from "node:fs/promises";
+import path22 from "node:path";
 var LOCK_FILENAME = ".gauntlet-run.lock";
 var SESSION_REF_FILENAME2 = ".session_ref";
 async function shouldAutoClean(logDir, baseBranch) {
@@ -6316,17 +6743,17 @@ async function performAutoClean(logDir, result, maxPreviousLogs = 3) {
 }
 async function exists(filePath) {
   try {
-    await fs24.stat(filePath);
+    await fs25.stat(filePath);
     return true;
   } catch {
     return false;
   }
 }
 async function acquireLock(logDir) {
-  await fs24.mkdir(logDir, { recursive: true });
-  const lockPath = path21.resolve(logDir, LOCK_FILENAME);
+  await fs25.mkdir(logDir, { recursive: true });
+  const lockPath = path22.resolve(logDir, LOCK_FILENAME);
   try {
-    await fs24.writeFile(lockPath, String(process.pid), { flag: "wx" });
+    await fs25.writeFile(lockPath, String(process.pid), { flag: "wx" });
   } catch (err) {
     if (typeof err === "object" && err !== null && "code" in err && err.code === "EEXIST") {
       console.error(`Error: A gauntlet run is already in progress (lock file: ${lockPath}).`);
@@ -6337,14 +6764,14 @@ async function acquireLock(logDir) {
   }
 }
 async function releaseLock(logDir) {
-  const lockPath = path21.resolve(logDir, LOCK_FILENAME);
+  const lockPath = path22.resolve(logDir, LOCK_FILENAME);
   try {
-    await fs24.rm(lockPath, { force: true });
+    await fs25.rm(lockPath, { force: true });
   } catch {}
 }
 async function hasExistingLogs(logDir) {
   try {
-    const entries = await fs24.readdir(logDir);
+    const entries = await fs25.readdir(logDir);
     return entries.some((f) => (f.endsWith(".log") || f.endsWith(".json")) && f !== "previous" && !f.startsWith("console.") && !f.startsWith("."));
   } catch {
     return false;
@@ -6363,7 +6790,7 @@ function getPersistentFiles() {
 }
 async function hasCurrentLogs(logDir) {
   try {
-    const files = await fs24.readdir(logDir);
+    const files = await fs25.readdir(logDir);
     const persistentFiles = getPersistentFiles();
     return files.some((f) => (f.endsWith(".log") || f.endsWith(".json")) && f !== "previous" && !persistentFiles.has(f));
   } catch {
@@ -6375,23 +6802,23 @@ function getCurrentLogFiles(files) {
   return files.filter((file) => !(file.startsWith("previous") || persistentFiles.has(file)));
 }
 async function deleteCurrentLogs(logDir) {
-  const files = await fs24.readdir(logDir);
-  await Promise.all(getCurrentLogFiles(files).map((file) => fs24.rm(path21.join(logDir, file), { recursive: true, force: true })));
+  const files = await fs25.readdir(logDir);
+  await Promise.all(getCurrentLogFiles(files).map((file) => fs25.rm(path22.join(logDir, file), { recursive: true, force: true })));
 }
 async function rotatePreviousDirs(logDir, maxPreviousLogs) {
   const oldestSuffix = maxPreviousLogs - 1;
   const oldestDir = oldestSuffix === 0 ? "previous" : `previous.${oldestSuffix}`;
-  const oldestPath = path21.join(logDir, oldestDir);
+  const oldestPath = path22.join(logDir, oldestDir);
   if (await exists(oldestPath)) {
-    await fs24.rm(oldestPath, { recursive: true, force: true });
+    await fs25.rm(oldestPath, { recursive: true, force: true });
   }
   for (let i = oldestSuffix - 1;i >= 0; i--) {
     const fromName = i === 0 ? "previous" : `previous.${i}`;
     const toName = `previous.${i + 1}`;
-    const fromPath = path21.join(logDir, fromName);
-    const toPath = path21.join(logDir, toName);
+    const fromPath = path22.join(logDir, fromName);
+    const toPath = path22.join(logDir, toName);
     if (await exists(fromPath)) {
-      await fs24.rename(fromPath, toPath);
+      await fs25.rename(fromPath, toPath);
     }
   }
 }
@@ -6406,12 +6833,12 @@ async function cleanLogs(logDir, maxPreviousLogs = 3) {
       return;
     }
     await rotatePreviousDirs(logDir, maxPreviousLogs);
-    const previousDir = path21.join(logDir, "previous");
-    await fs24.mkdir(previousDir, { recursive: true });
-    const files = await fs24.readdir(logDir);
-    await Promise.all(getCurrentLogFiles(files).map((file) => fs24.rename(path21.join(logDir, file), path21.join(previousDir, file))));
+    const previousDir = path22.join(logDir, "previous");
+    await fs25.mkdir(previousDir, { recursive: true });
+    const files = await fs25.readdir(logDir);
+    await Promise.all(getCurrentLogFiles(files).map((file) => fs25.rename(path22.join(logDir, file), path22.join(previousDir, file))));
     try {
-      await fs24.rm(path21.join(logDir, SESSION_REF_FILENAME2), { force: true });
+      await fs25.rm(path22.join(logDir, SESSION_REF_FILENAME2), { force: true });
     } catch {}
   } catch (error) {
     console.warn("Failed to clean logs in", logDir, ":", error instanceof Error ? error.message : error);
@@ -6511,7 +6938,7 @@ async function detectChangesAndGenerateJobs(config, effectiveBaseBranch, changeO
     uncommitted: options.uncommitted
   });
   const expander = new EntryPointExpander;
-  const jobGen = new JobGenerator(config);
+  const jobGen = new JobGenerator(config, options.enableReviews);
   console.log(chalk3.dim("Detecting changes..."));
   const changes = await changeDetector.getChangedFiles();
   if (changes.length === 0) {
@@ -6620,14 +7047,14 @@ function registerCheckCommand(program) {
   program.command("check").description("Run only applicable checks for detected changes").option("-b, --base-branch <branch>", "Override base branch for change detection").option("-g, --gate <name>", "Run specific check gate only").option("-c, --commit <sha>", "Use diff for a specific commit").option("-u, --uncommitted", "Use diff for current uncommitted changes (staged and unstaged)").action((options) => executeGateCommand("check", options));
 }
 // src/commands/ci/init.ts
-import fs26 from "node:fs/promises";
-import path23 from "node:path";
+import fs27 from "node:fs/promises";
+import path24 from "node:path";
 import chalk4 from "chalk";
 import YAML5 from "yaml";
 
 // src/config/ci-loader.ts
-import fs25 from "node:fs/promises";
-import path22 from "node:path";
+import fs26 from "node:fs/promises";
+import path23 from "node:path";
 import YAML4 from "yaml";
 
 // src/config/ci-schema.ts
@@ -6657,17 +7084,17 @@ var ciConfigSchema = z3.object({
 var GAUNTLET_DIR2 = ".gauntlet";
 var CI_FILE = "ci.yml";
 async function loadCIConfig(rootDir = process.cwd()) {
-  const ciPath = path22.join(rootDir, GAUNTLET_DIR2, CI_FILE);
+  const ciPath = path23.join(rootDir, GAUNTLET_DIR2, CI_FILE);
   if (!await fileExists3(ciPath)) {
     throw new Error(`CI configuration file not found at ${ciPath}. Run 'agent-gauntlet ci init' to create it.`);
   }
-  const content = await fs25.readFile(ciPath, "utf-8");
+  const content = await fs26.readFile(ciPath, "utf-8");
   const raw = YAML4.parse(content);
   return ciConfigSchema.parse(raw);
 }
-async function fileExists3(path23) {
+async function fileExists3(path24) {
   try {
-    const stat = await fs25.stat(path23);
+    const stat = await fs26.stat(path24);
     return stat.isFile();
   } catch {
     return false;
@@ -6758,15 +7185,15 @@ jobs:
 
 // src/commands/ci/init.ts
 async function initCI() {
-  const workflowDir = path23.join(process.cwd(), ".github", "workflows");
-  const workflowPath = path23.join(workflowDir, "gauntlet.yml");
-  const gauntletDir = path23.join(process.cwd(), ".gauntlet");
-  const ciConfigPath = path23.join(gauntletDir, "ci.yml");
+  const workflowDir = path24.join(process.cwd(), ".github", "workflows");
+  const workflowPath = path24.join(workflowDir, "gauntlet.yml");
+  const gauntletDir = path24.join(process.cwd(), ".gauntlet");
+  const ciConfigPath = path24.join(gauntletDir, "ci.yml");
   if (await fileExists4(ciConfigPath)) {
     console.log(chalk4.dim("Found existing .gauntlet/ci.yml"));
   } else {
     console.log(chalk4.yellow("Creating starter .gauntlet/ci.yml..."));
-    await fs26.mkdir(gauntletDir, { recursive: true });
+    await fs27.mkdir(gauntletDir, { recursive: true });
     const starterContent = `# CI Configuration for Agent Gauntlet
 # Define runtimes, services, and which checks to run in CI.
 
@@ -6788,7 +7215,7 @@ checks:
   # - name: linter
   #   requires_runtimes: [ruby]
 `;
-    await fs26.writeFile(ciConfigPath, starterContent);
+    await fs27.writeFile(ciConfigPath, starterContent);
   }
   let ciConfig;
   try {
@@ -6797,7 +7224,7 @@ checks:
     console.warn(chalk4.yellow("Could not load CI config to inject services. Workflow will have no services defined."));
   }
   console.log(chalk4.dim(`Generating ${workflowPath}...`));
-  await fs26.mkdir(workflowDir, { recursive: true });
+  await fs27.mkdir(workflowDir, { recursive: true });
   let templateContent = workflow_default;
   if (ciConfig?.services && Object.keys(ciConfig.services).length > 0) {
     const servicesYaml = YAML5.stringify({ services: ciConfig.services });
@@ -6809,12 +7236,12 @@ checks:
     templateContent = templateContent.replace(`    # Services will be injected here by agent-gauntlet
 `, "");
   }
-  await fs26.writeFile(workflowPath, templateContent);
+  await fs27.writeFile(workflowPath, templateContent);
   console.log(chalk4.green("Successfully generated GitHub Actions workflow!"));
 }
-async function fileExists4(path24) {
+async function fileExists4(path25) {
   try {
-    const stat = await fs26.stat(path24);
+    const stat = await fs27.stat(path25);
     return stat.isFile();
   } catch {
     return false;
@@ -7024,18 +7451,18 @@ function printJobsByWorkDir(jobs) {
   }
 }
 // src/commands/health.ts
-import path26 from "node:path";
+import path27 from "node:path";
 import chalk7 from "chalk";
 
 // src/config/validator.ts
-import fs28 from "node:fs/promises";
-import path25 from "node:path";
+import fs29 from "node:fs/promises";
+import path26 from "node:path";
 import YAML7 from "yaml";
 import { ZodError as ZodError2 } from "zod";
 
 // src/config/validate-reviews.ts
-import fs27 from "node:fs/promises";
-import path24 from "node:path";
+import fs28 from "node:fs/promises";
+import path25 from "node:path";
 import matter2 from "gray-matter";
 import YAML6 from "yaml";
 import { ZodError } from "zod";
@@ -7044,7 +7471,7 @@ async function validateReviewGates(reviewsPath, issues, filesChecked) {
   const reviewSourceFiles = {};
   const existingReviewNames = new Set;
   try {
-    const reviewFiles = await fs27.readdir(reviewsPath);
+    const reviewFiles = await fs28.readdir(reviewsPath);
     detectDuplicateReviewNames2(reviewFiles, reviewsPath, issues);
     for (const file of reviewFiles) {
       if (file.endsWith(".md")) {
@@ -7067,7 +7494,7 @@ function detectDuplicateReviewNames2(reviewFiles, reviewsPath, issues) {
   const reviewNameSources = new Map;
   for (const file of reviewFiles) {
     if (file.endsWith(".md") || file.endsWith(".yml") || file.endsWith(".yaml")) {
-      const name = path24.basename(file, path24.extname(file));
+      const name = path25.basename(file, path25.extname(file));
       const sources = reviewNameSources.get(name) || [];
       sources.push(file);
       reviewNameSources.set(name, sources);
@@ -7084,12 +7511,12 @@ function detectDuplicateReviewNames2(reviewFiles, reviewsPath, issues) {
   }
 }
 async function validateMarkdownReview(file, reviewsPath, reviews, reviewSourceFiles, existingReviewNames, issues, filesChecked) {
-  const filePath = path24.join(reviewsPath, file);
-  const reviewName = path24.basename(file, ".md");
+  const filePath = path25.join(reviewsPath, file);
+  const reviewName = path25.basename(file, ".md");
   existingReviewNames.add(reviewName);
   filesChecked.push(filePath);
   try {
-    const content = await fs27.readFile(filePath, "utf-8");
+    const content = await fs28.readFile(filePath, "utf-8");
     const { data: frontmatter, content: _promptBody } = matter2(content);
     if (!frontmatter || Object.keys(frontmatter).length === 0) {
       issues.push({
@@ -7101,7 +7528,7 @@ async function validateMarkdownReview(file, reviewsPath, reviews, reviewSourceFi
     }
     validateCliPreferenceTools(frontmatter, filePath, issues);
     const parsedFrontmatter = reviewPromptFrontmatterSchema.parse(frontmatter);
-    const name = path24.basename(file, ".md");
+    const name = path25.basename(file, ".md");
     reviews[name] = parsedFrontmatter;
     reviewSourceFiles[name] = filePath;
     validateReviewSemantics(parsedFrontmatter, filePath, issues);
@@ -7110,12 +7537,12 @@ async function validateMarkdownReview(file, reviewsPath, reviews, reviewSourceFi
   }
 }
 async function validateYamlReview(file, reviewsPath, reviews, reviewSourceFiles, existingReviewNames, issues, filesChecked) {
-  const filePath = path24.join(reviewsPath, file);
-  const reviewName = path24.basename(file, path24.extname(file));
+  const filePath = path25.join(reviewsPath, file);
+  const reviewName = path25.basename(file, path25.extname(file));
   existingReviewNames.add(reviewName);
   filesChecked.push(filePath);
   try {
-    const content = await fs27.readFile(filePath, "utf-8");
+    const content = await fs28.readFile(filePath, "utf-8");
     const raw = YAML6.parse(content);
     validateCliPreferenceTools(raw, filePath, issues);
     const parsed = reviewYamlSchema.parse(raw);
@@ -7248,8 +7675,8 @@ var CONFIG_FILE2 = "config.yml";
 var CHECKS_DIR2 = "checks";
 var REVIEWS_DIR2 = "reviews";
 async function validateConfig(rootDir = process.cwd()) {
-  const gauntletPath = path25.join(rootDir, GAUNTLET_DIR3);
-  const configPath = path25.join(gauntletPath, CONFIG_FILE2);
+  const gauntletPath = path26.join(rootDir, GAUNTLET_DIR3);
+  const configPath = path26.join(gauntletPath, CONFIG_FILE2);
   const ctx = {
     gauntletPath,
     configPath,
@@ -7273,7 +7700,7 @@ async function validateProjectConfig(ctx) {
   try {
     if (await fileExists5(ctx.configPath)) {
       ctx.filesChecked.push(ctx.configPath);
-      const configContent = await fs28.readFile(ctx.configPath, "utf-8");
+      const configContent = await fs29.readFile(ctx.configPath, "utf-8");
       return parseProjectConfig(configContent, ctx);
     }
     ctx.issues.push({
@@ -7315,12 +7742,12 @@ function parseProjectConfig(configContent, ctx) {
 async function validateCheckGates(ctx) {
   const checks = {};
   const existingCheckNames = new Set;
-  const checksPath = path25.join(ctx.gauntletPath, CHECKS_DIR2);
+  const checksPath = path26.join(ctx.gauntletPath, CHECKS_DIR2);
   if (!await dirExists2(checksPath)) {
     return { checks, existingCheckNames };
   }
   try {
-    const checkFiles = await fs28.readdir(checksPath);
+    const checkFiles = await fs29.readdir(checksPath);
     for (const file of checkFiles) {
       if (file.endsWith(".yml") || file.endsWith(".yaml")) {
         await parseCheckFile(file, checksPath, checks, existingCheckNames, ctx);
@@ -7337,11 +7764,11 @@ async function validateCheckGates(ctx) {
   return { checks, existingCheckNames };
 }
 async function parseCheckFile(file, checksPath, checks, existingCheckNames, ctx) {
-  const filePath = path25.join(checksPath, file);
+  const filePath = path26.join(checksPath, file);
   ctx.filesChecked.push(filePath);
-  const name = path25.basename(file, path25.extname(file));
+  const name = path26.basename(file, path26.extname(file));
   try {
-    const content = await fs28.readFile(filePath, "utf-8");
+    const content = await fs29.readFile(filePath, "utf-8");
     const raw = YAML7.parse(content);
     const parsed = checkGateSchema.parse(raw);
     existingCheckNames.add(name);
@@ -7371,7 +7798,7 @@ async function parseCheckFile(file, checksPath, checks, existingCheckNames, ctx)
   }
 }
 async function validateReviewGatesWrapper(ctx) {
-  const reviewsPath = path25.join(ctx.gauntletPath, REVIEWS_DIR2);
+  const reviewsPath = path26.join(ctx.gauntletPath, REVIEWS_DIR2);
   if (!await dirExists2(reviewsPath)) {
     return {
       reviews: {},
@@ -7515,12 +7942,12 @@ function validateDefaultPreferenceTools(defaults, ctx) {
   }
 }
 function validateReviewPreferencesAgainstDefaults(defaults, reviews, reviewSourceFiles, ctx) {
-  const reviewsPath = path25.join(ctx.gauntletPath, REVIEWS_DIR2);
+  const reviewsPath = path26.join(ctx.gauntletPath, REVIEWS_DIR2);
   const allowedTools = new Set(defaults);
   for (const [reviewName, reviewConfig] of Object.entries(reviews)) {
     const pref = reviewConfig.cli_preference;
     if (pref && Array.isArray(pref)) {
-      const reviewFile = reviewSourceFiles[reviewName] || path25.join(reviewsPath, `${reviewName}.md`);
+      const reviewFile = reviewSourceFiles[reviewName] || path26.join(reviewsPath, `${reviewName}.md`);
       for (let i = 0;i < pref.length; i++) {
         const tool = pref[i];
         if (!allowedTools.has(tool)) {
@@ -7553,7 +7980,7 @@ function pushYamlOrParseError(error, filePath, issues) {
 }
 async function fileExists5(filePath) {
   try {
-    const stat = await fs28.stat(filePath);
+    const stat = await fs29.stat(filePath);
     return stat.isFile();
   } catch {
     return false;
@@ -7561,7 +7988,7 @@ async function fileExists5(filePath) {
 }
 async function dirExists2(dirPath) {
   try {
-    const stat = await fs28.stat(dirPath);
+    const stat = await fs29.stat(dirPath);
     return stat.isDirectory();
   } catch {
     return false;
@@ -7582,7 +8009,7 @@ function formatHealthResult(health) {
 function displayValidationIssues(validationResult) {
   const issuesByFile = new Map;
   for (const issue of validationResult.issues) {
-    const relativeFile = path26.relative(process.cwd(), issue.file);
+    const relativeFile = path27.relative(process.cwd(), issue.file);
     if (!issuesByFile.has(relativeFile)) {
       issuesByFile.set(relativeFile, []);
     }
@@ -7605,7 +8032,7 @@ async function validateAndDisplayConfig() {
     return;
   }
   for (const file of validationResult.filesChecked) {
-    const relativePath = path26.relative(process.cwd(), file);
+    const relativePath = path27.relative(process.cwd(), file);
     console.log(chalk7.dim(`  ${relativePath}`));
   }
   if (validationResult.valid && validationResult.issues.length === 0) {
@@ -7712,15 +8139,15 @@ function registerHelpCommand(program) {
 // src/commands/init.ts
 import { execFileSync } from "node:child_process";
 import { statSync } from "node:fs";
-import fs31 from "node:fs/promises";
-import path29 from "node:path";
+import fs32 from "node:fs/promises";
+import path30 from "node:path";
 import { fileURLToPath } from "node:url";
 import chalk11 from "chalk";
 
 // src/commands/init-checksums.ts
 import { createHash } from "node:crypto";
-import fs29 from "node:fs/promises";
-import path27 from "node:path";
+import fs30 from "node:fs/promises";
+import path28 from "node:path";
 async function computeSkillChecksum(skillDir) {
   const files = await collectFiles(skillDir);
   files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
@@ -7753,22 +8180,22 @@ function isGauntletHookEntry(entry) {
 async function collectFiles(dir, baseDir) {
   const base = baseDir ?? dir;
   const results = [];
-  const entries = await fs29.readdir(dir, { withFileTypes: true });
+  const entries = await fs30.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path27.join(dir, entry.name);
+    const fullPath = path28.join(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...await collectFiles(fullPath, base));
     } else if (entry.isFile()) {
-      const content = await fs29.readFile(fullPath, "utf-8");
-      results.push({ relativePath: path27.relative(base, fullPath), content });
+      const content = await fs30.readFile(fullPath, "utf-8");
+      results.push({ relativePath: path28.relative(base, fullPath), content });
     }
   }
   return results;
 }
 
 // src/commands/init-hooks.ts
-import fs30 from "node:fs/promises";
-import path28 from "node:path";
+import fs31 from "node:fs/promises";
+import path29 from "node:path";
 import chalk10 from "chalk";
 
 // src/commands/init-prompts.ts
@@ -7846,11 +8273,11 @@ async function mergeHookConfig(opts) {
     wrapInHooksArray,
     baseConfig
   } = opts;
-  await fs30.mkdir(path28.dirname(filePath), { recursive: true });
+  await fs31.mkdir(path29.dirname(filePath), { recursive: true });
   let existing = {};
   if (await exists(filePath)) {
     try {
-      existing = JSON.parse(await fs30.readFile(filePath, "utf-8"));
+      existing = JSON.parse(await fs31.readFile(filePath, "utf-8"));
     } catch {
       existing = {};
     }
@@ -7867,7 +8294,7 @@ async function mergeHookConfig(opts) {
     ...existing,
     hooks: { ...existingHooks, [hookKey]: newEntries }
   };
-  await fs30.writeFile(filePath, `${JSON.stringify(merged, null, 2)}
+  await fs31.writeFile(filePath, `${JSON.stringify(merged, null, 2)}
 `);
   return true;
 }
@@ -7944,7 +8371,7 @@ function buildHookSpec(target) {
   const purpose = isStop ? "gauntlet will run automatically when agent stops" : "agent will be primed with gauntlet instructions at session start";
   return {
     config: {
-      filePath: path28.join(projectRoot, cfg.dir, cfg.file),
+      filePath: path29.join(projectRoot, cfg.dir, cfg.file),
       hookKey: cfg.hookKey,
       hookEntry: cfg.entry,
       deduplicateCmd: cfg.cmd,
@@ -7960,7 +8387,7 @@ async function installHookWithChecksums(target, skipPrompts) {
   let existingConfig = {};
   if (await exists(spec.config.filePath)) {
     try {
-      existingConfig = JSON.parse(await fs30.readFile(spec.config.filePath, "utf-8"));
+      existingConfig = JSON.parse(await fs31.readFile(spec.config.filePath, "utf-8"));
     } catch {
       existingConfig = {};
     }
@@ -7994,8 +8421,8 @@ async function installHookWithChecksums(target, skipPrompts) {
     ...existingConfig,
     hooks: { ...existingHooks, [spec.config.hookKey]: newEntries }
   };
-  await fs30.mkdir(path28.dirname(spec.config.filePath), { recursive: true });
-  await fs30.writeFile(spec.config.filePath, `${JSON.stringify(merged, null, 2)}
+  await fs31.mkdir(path29.dirname(spec.config.filePath), { recursive: true });
+  await fs31.writeFile(spec.config.filePath, `${JSON.stringify(merged, null, 2)}
 `);
   console.log(chalk10.green(spec.installedMsg));
 }
@@ -8013,10 +8440,10 @@ async function installHooksForAdapters(projectRoot, devAdapters, skipPrompts) {
 }
 
 // src/commands/init.ts
-var __dirname2 = path29.dirname(fileURLToPath(import.meta.url));
+var __dirname2 = path30.dirname(fileURLToPath(import.meta.url));
 var SKILLS_SOURCE_DIR = (() => {
-  const bundled = path29.join(__dirname2, "..", "skills");
-  const dev = path29.join(__dirname2, "..", "..", "skills");
+  const bundled = path30.join(__dirname2, "..", "skills");
+  const dev = path30.join(__dirname2, "..", "..", "skills");
   try {
     statSync(bundled);
     return bundled;
@@ -8027,14 +8454,10 @@ var SKILLS_SOURCE_DIR = (() => {
     throw err;
   }
 })();
-var SKILL_ACTIONS = ["run", "check", "status", "help", "setup"];
-var SKILL_DESCRIPTIONS = {
-  run: "Run the verification suite",
-  check: "Run checks only (no reviews)",
-  status: "Show gauntlet status",
-  help: "Diagnose and explain gauntlet behavior",
-  setup: "Configure checks and reviews interactively"
-};
+async function getSkillDirNames() {
+  const entries = await fs32.readdir(SKILLS_SOURCE_DIR, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+}
 var CLI_PREFERENCE_ORDER = [
   "codex",
   "claude",
@@ -8061,7 +8484,7 @@ function registerInitCommand(program) {
 }
 async function runInit(options) {
   const projectRoot = process.cwd();
-  const targetDir = path29.join(projectRoot, ".gauntlet");
+  const targetDir = path30.join(projectRoot, ".gauntlet");
   const skipPrompts = options.yes ?? false;
   console.log("Detecting available CLI agents...");
   const availableAdapters = await detectAvailableCLIs();
@@ -8093,7 +8516,7 @@ async function runInit(options) {
   }
   await installExternalFiles(projectRoot, hookAdapters, skipPrompts);
   await addToGitignore(projectRoot, "gauntlet_logs");
-  printPostInitInstructions(instructionCLINames);
+  await printPostInitInstructions(instructionCLINames);
 }
 function printNoCLIsMessage() {
   console.log();
@@ -8108,35 +8531,34 @@ async function scaffoldGauntletDir(_projectRoot, targetDir, reviewCLINames, numR
     console.log(chalk11.dim(".gauntlet/ already exists, skipping scaffolding"));
     return;
   }
-  await fs31.mkdir(targetDir);
-  await fs31.mkdir(path29.join(targetDir, "checks"));
-  await fs31.mkdir(path29.join(targetDir, "reviews"));
+  await fs32.mkdir(targetDir);
+  await fs32.mkdir(path30.join(targetDir, "checks"));
+  await fs32.mkdir(path30.join(targetDir, "reviews"));
   await writeConfigYml(targetDir, reviewCLINames);
-  await fs31.writeFile(path29.join(targetDir, "reviews", "code-quality.yml"), `builtin: code-quality
+  await fs32.writeFile(path30.join(targetDir, "reviews", "code-quality.yml"), `builtin: code-quality
 num_reviews: ${numReviews}
 `);
   console.log(chalk11.green("Created .gauntlet/reviews/code-quality.yml"));
 }
 async function copyDirRecursive(opts) {
-  await fs31.mkdir(opts.dest, { recursive: true });
-  const entries = await fs31.readdir(opts.src, { withFileTypes: true });
+  await fs32.mkdir(opts.dest, { recursive: true });
+  const entries = await fs32.readdir(opts.src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path29.join(opts.src, entry.name);
-    const destPath = path29.join(opts.dest, entry.name);
+    const srcPath = path30.join(opts.src, entry.name);
+    const destPath = path30.join(opts.dest, entry.name);
     if (entry.isDirectory()) {
       await copyDirRecursive({ src: srcPath, dest: destPath });
     } else {
-      await fs31.copyFile(srcPath, destPath);
+      await fs32.copyFile(srcPath, destPath);
     }
   }
 }
 async function installSkillsWithChecksums(projectRoot, skipPrompts) {
-  const skillsDir = path29.join(projectRoot, ".claude", "skills");
-  for (const action of SKILL_ACTIONS) {
-    const dirName = `gauntlet-${action}`;
-    const sourceDir = path29.join(SKILLS_SOURCE_DIR, dirName);
-    const targetDir = path29.join(skillsDir, dirName);
-    const relativeDir = `${path29.relative(projectRoot, targetDir)}/`;
+  const skillsDir = path30.join(projectRoot, ".claude", "skills");
+  for (const dirName of await getSkillDirNames()) {
+    const sourceDir = path30.join(SKILLS_SOURCE_DIR, dirName);
+    const targetDir = path30.join(skillsDir, dirName);
+    const relativeDir = `${path30.relative(projectRoot, targetDir)}/`;
     if (!await exists(targetDir)) {
       await copyDirRecursive({ src: sourceDir, dest: targetDir });
       console.log(chalk11.green(`Created ${relativeDir}`));
@@ -8149,7 +8571,7 @@ async function installSkillsWithChecksums(projectRoot, skipPrompts) {
     const shouldOverwrite = await promptFileOverwrite(dirName, skipPrompts);
     if (!shouldOverwrite)
       continue;
-    await fs31.rm(targetDir, { recursive: true, force: true });
+    await fs32.rm(targetDir, { recursive: true, force: true });
     await copyDirRecursive({ src: sourceDir, dest: targetDir });
     console.log(chalk11.green(`Updated ${relativeDir}`));
   }
@@ -8158,7 +8580,7 @@ async function installExternalFiles(projectRoot, devAdapters, skipPrompts) {
   await installSkillsWithChecksums(projectRoot, skipPrompts);
   await installHooksForAdapters(projectRoot, devAdapters, skipPrompts);
 }
-function printPostInitInstructions(devCLINames) {
+async function printPostInitInstructions(devCLINames) {
   const hasNative = devCLINames.some((name) => NATIVE_CLIS.has(name));
   const nonNativeNames = devCLINames.filter((name) => !NATIVE_CLIS.has(name));
   const hasNonNative = nonNativeNames.length > 0;
@@ -8170,8 +8592,8 @@ function printPostInitInstructions(devCLINames) {
     console.log(chalk11.bold("To complete setup, reference the setup skill in your CLI: @.claude/skills/gauntlet-setup/SKILL.md. This will guide you through configuring the static checks (unit tests, linters, etc.) that Agent Gauntlet will run."));
     console.log();
     console.log("Available skills:");
-    for (const action of SKILL_ACTIONS) {
-      console.log(`  @.claude/skills/gauntlet-${action}/SKILL.md — ${SKILL_DESCRIPTIONS[action]}`);
+    for (const dirName of await getSkillDirNames()) {
+      console.log(`  @.claude/skills/${dirName}/SKILL.md`);
     }
   }
 }
@@ -8233,14 +8655,14 @@ entry_points: []
 #     enabled: true
 #     format: text                # Options: text, json
 `;
-  await fs31.writeFile(path29.join(targetDir, "config.yml"), content);
+  await fs32.writeFile(path30.join(targetDir, "config.yml"), content);
   console.log(chalk11.green("Created .gauntlet/config.yml"));
 }
 async function addToGitignore(projectRoot, entry) {
-  const gitignorePath = path29.join(projectRoot, ".gitignore");
+  const gitignorePath = path30.join(projectRoot, ".gitignore");
   let content = "";
   if (await exists(gitignorePath)) {
-    content = await fs31.readFile(gitignorePath, "utf-8");
+    content = await fs32.readFile(gitignorePath, "utf-8");
     const lines = content.split(`
 `).map((l) => l.trim());
     if (lines.includes(entry))
@@ -8249,7 +8671,7 @@ async function addToGitignore(projectRoot, entry) {
   const suffix = content.length > 0 && !content.endsWith(`
 `) ? `
 ` : "";
-  await fs31.appendFile(gitignorePath, `${suffix}${entry}
+  await fs32.appendFile(gitignorePath, `${suffix}${entry}
 `);
   console.log(chalk11.green(`Added ${entry} to .gitignore`));
 }
@@ -8298,348 +8720,411 @@ ${lines.join(`
 `;
 }
 async function detectAvailableCLIs() {
-  const allAdapters = [...getAllAdapters()].sort((a, b) => CLI_PREFERENCE_ORDER.indexOf(a.name) - CLI_PREFERENCE_ORDER.indexOf(b.name));
-  const available = [];
-  for (const adapter of allAdapters) {
-    const isAvailable = await adapter.isAvailable();
-    if (isAvailable) {
-      console.log(chalk11.green(`  ✓ ${adapter.name}`));
-      available.push(adapter);
-    } else {
-      console.log(chalk11.dim(`  ✗ ${adapter.name} (not installed)`));
-    }
-  }
-  return available;
-}
-// src/commands/list.ts
-import chalk12 from "chalk";
-function registerListCommand(program) {
-  program.command("list").description("List configured gates").action(async () => {
-    try {
-      const config = await loadConfig();
-      console.log(chalk12.bold("Check Gates:"));
-      for (const c of Object.values(config.checks)) {
-        console.log(` - ${c.name}`);
-      }
-      console.log(chalk12.bold(`
-Review Gates:`));
-      for (const r of Object.values(config.reviews)) {
-        console.log(` - ${r.name} (Tools: ${r.cli_preference?.join(", ")})`);
-      }
-      console.log(chalk12.bold(`
-Entry Points:`));
-      for (const ep of config.project.entry_points) {
-        console.log(` - ${ep.path}`);
-        if (ep.checks)
-          console.log(`   Checks: ${ep.checks.join(", ")}`);
-        if (ep.reviews)
-          console.log(`   Reviews: ${ep.reviews.join(", ")}`);
-      }
-    } catch (error) {
-      const err = error;
-      console.error(chalk12.red("Error:"), err.message);
-    }
-  });
-}
-// src/commands/review.ts
-function registerReviewCommand(program) {
-  program.command("review").description("Run only applicable reviews for detected changes").option("-b, --base-branch <branch>", "Override base branch for change detection").option("-g, --gate <name>", "Run specific review gate only").option("-c, --commit <sha>", "Use diff for a specific commit").option("-u, --uncommitted", "Use diff for current uncommitted changes (staged and unstaged)").action((options) => executeGateCommand("review", options));
-}
-// src/core/diff-stats.ts
-import { execFile } from "node:child_process";
-import { promisify as promisify9 } from "node:util";
-var execFileAsyncOriginal = promisify9(execFile);
-var execFileAsync = execFileAsyncOriginal;
-async function gitExec(args) {
-  const { stdout } = await execFileAsync("git", args);
-  return stdout;
-}
-async function computeDiffStats(baseBranch, options = {}) {
-  if (options.commit) {
-    return computeCommitDiffStats(options.commit);
-  }
-  if (options.fixBase) {
-    return computeFixBaseDiffStats(options.fixBase);
-  }
-  if (options.uncommitted) {
-    return computeUncommittedDiffStats();
-  }
-  const isCI = process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true";
-  if (isCI) {
-    return computeCIDiffStats(baseBranch);
-  }
-  return computeLocalDiffStats(baseBranch);
-}
-async function computeCommitDiffStats(commit) {
-  try {
-    const numstat = await gitExec([
-      "diff",
-      "--numstat",
-      `${commit}^..${commit}`
-    ]);
-    const lineStats = parseNumstat(numstat);
-    const nameStatus = await gitExec([
-      "diff",
-      "--name-status",
-      `${commit}^..${commit}`
-    ]);
-    const fileStats = parseNameStatus(nameStatus);
-    return {
-      baseRef: `${commit}^`,
-      ...fileStats,
-      ...lineStats
-    };
-  } catch {
-    try {
-      const numstat = await gitExec(["diff", "--numstat", "--root", commit]);
-      const lineStats = parseNumstat(numstat);
-      const nameStatus = await gitExec([
-        "diff",
-        "--name-status",
-        "--root",
-        commit
-      ]);
-      const fileStats = parseNameStatus(nameStatus);
-      return {
-        baseRef: "root",
-        ...fileStats,
-        ...lineStats
-      };
-    } catch {
-      return emptyDiffStats(commit);
-    }
-  }
-}
-async function computeUncommittedDiffStats() {
-  const stagedNumstat = await gitExec(["diff", "--numstat", "--cached"]);
-  const stagedLines = parseNumstat(stagedNumstat);
-  const stagedStatus = await gitExec(["diff", "--name-status", "--cached"]);
-  const stagedFiles = parseNameStatus(stagedStatus);
-  const unstagedNumstat = await gitExec(["diff", "--numstat"]);
-  const unstagedLines = parseNumstat(unstagedNumstat);
-  const unstagedStatus = await gitExec(["diff", "--name-status"]);
-  const unstagedFiles = parseNameStatus(unstagedStatus);
-  const untrackedList = await gitExec([
-    "ls-files",
-    "--others",
-    "--exclude-standard"
-  ]);
-  const untrackedFiles = untrackedList.split(`
-`).filter((f) => f.trim().length > 0);
-  return {
-    baseRef: "uncommitted",
-    total: stagedFiles.total + unstagedFiles.total + untrackedFiles.length - countOverlap(stagedStatus, unstagedStatus),
-    newFiles: stagedFiles.newFiles + unstagedFiles.newFiles + untrackedFiles.length,
-    modifiedFiles: stagedFiles.modifiedFiles + unstagedFiles.modifiedFiles,
-    deletedFiles: stagedFiles.deletedFiles + unstagedFiles.deletedFiles,
-    linesAdded: stagedLines.linesAdded + unstagedLines.linesAdded,
-    linesRemoved: stagedLines.linesRemoved + unstagedLines.linesRemoved
-  };
-}
-async function computeFixBaseDiffStats(fixBase) {
-  try {
-    const numstat = await gitExec(["diff", "--numstat", fixBase]);
-    const lineStats = parseNumstat(numstat);
-    const nameStatus = await gitExec(["diff", "--name-status", fixBase]);
-    const fileStats = parseNameStatus(nameStatus);
-    const currentUntracked = (await gitExec(["ls-files", "--others", "--exclude-standard"])).split(`
-`).filter((f) => f.trim().length > 0);
-    let fixBaseFiles;
-    try {
-      const treeFiles = await gitExec([
-        "ls-tree",
-        "-r",
-        "--name-only",
-        fixBase
-      ]);
-      fixBaseFiles = new Set(treeFiles.split(`
-`).filter((f) => f.trim().length > 0));
-    } catch {
-      fixBaseFiles = new Set;
+  const allAdapters = [...getAllAdapters()].sort((a, b) => CLI_PREFERENCE_ORDER.indexOf(a.name) - CLI_PREFERENCE_ORDER.indexOf(b.name));
+  const available = [];
+  for (const adapter of allAdapters) {
+    const isAvailable = await adapter.isAvailable();
+    if (isAvailable) {
+      console.log(chalk11.green(`  ✓ ${adapter.name}`));
+      available.push(adapter);
+    } else {
+      console.log(chalk11.dim(`  ✗ ${adapter.name} (not installed)`));
     }
-    const newUntrackedFiles = currentUntracked.filter((f) => !fixBaseFiles.has(f));
-    return {
-      baseRef: fixBase,
-      total: fileStats.total + newUntrackedFiles.length,
-      newFiles: fileStats.newFiles + newUntrackedFiles.length,
-      modifiedFiles: fileStats.modifiedFiles,
-      deletedFiles: fileStats.deletedFiles,
-      linesAdded: lineStats.linesAdded,
-      linesRemoved: lineStats.linesRemoved
-    };
-  } catch {
-    return emptyDiffStats(fixBase);
   }
+  return available;
 }
-async function computeCIDiffStats(baseBranch) {
-  const headRef = process.env.GITHUB_SHA || "HEAD";
-  try {
-    const numstat = await gitExec([
-      "diff",
-      "--numstat",
-      `${baseBranch}...${headRef}`
-    ]);
-    const lineStats = parseNumstat(numstat);
-    const nameStatus = await gitExec([
-      "diff",
-      "--name-status",
-      `${baseBranch}...${headRef}`
-    ]);
-    const fileStats = parseNameStatus(nameStatus);
-    return {
-      baseRef: baseBranch,
-      ...fileStats,
-      ...lineStats
-    };
-  } catch {
+// src/commands/list.ts
+import chalk12 from "chalk";
+function registerListCommand(program) {
+  program.command("list").description("List configured gates").action(async () => {
     try {
-      const numstat = await gitExec(["diff", "--numstat", "HEAD^...HEAD"]);
-      const lineStats = parseNumstat(numstat);
-      const nameStatus = await gitExec([
-        "diff",
-        "--name-status",
-        "HEAD^...HEAD"
-      ]);
-      const fileStats = parseNameStatus(nameStatus);
-      return {
-        baseRef: "HEAD^",
-        ...fileStats,
-        ...lineStats
-      };
-    } catch {
-      return emptyDiffStats(baseBranch);
+      const config = await loadConfig();
+      console.log(chalk12.bold("Check Gates:"));
+      for (const c of Object.values(config.checks)) {
+        console.log(` - ${c.name}`);
+      }
+      console.log(chalk12.bold(`
+Review Gates:`));
+      for (const r of Object.values(config.reviews)) {
+        console.log(` - ${r.name} (Tools: ${r.cli_preference?.join(", ")})`);
+      }
+      console.log(chalk12.bold(`
+Entry Points:`));
+      for (const ep of config.project.entry_points) {
+        console.log(` - ${ep.path}`);
+        if (ep.checks)
+          console.log(`   Checks: ${ep.checks.join(", ")}`);
+        if (ep.reviews)
+          console.log(`   Reviews: ${ep.reviews.join(", ")}`);
+      }
+    } catch (error) {
+      const err = error;
+      console.error(chalk12.red("Error:"), err.message);
     }
-  }
+  });
 }
-async function computeLocalDiffStats(baseBranch) {
-  const committedNumstat = await gitExec([
-    "diff",
-    "--numstat",
-    `${baseBranch}...HEAD`
-  ]);
-  const committedLines = parseNumstat(committedNumstat);
-  const committedStatus = await gitExec([
-    "diff",
-    "--name-status",
-    `${baseBranch}...HEAD`
-  ]);
-  const committedFiles = parseNameStatus(committedStatus);
-  const uncommittedNumstat = await gitExec(["diff", "--numstat", "HEAD"]);
-  const uncommittedLines = parseNumstat(uncommittedNumstat);
-  const uncommittedStatus = await gitExec(["diff", "--name-status", "HEAD"]);
-  const uncommittedFiles = parseNameStatus(uncommittedStatus);
-  const untrackedList = await gitExec([
-    "ls-files",
-    "--others",
-    "--exclude-standard"
-  ]);
-  const untrackedFiles = untrackedList.split(`
-`).filter((f) => f.trim().length > 0);
-  const totalNew = committedFiles.newFiles + uncommittedFiles.newFiles + untrackedFiles.length;
-  const totalModified = committedFiles.modifiedFiles + uncommittedFiles.modifiedFiles;
-  const totalDeleted = committedFiles.deletedFiles + uncommittedFiles.deletedFiles;
+// src/commands/review.ts
+function registerReviewCommand(program) {
+  program.command("review").description("Run only applicable reviews for detected changes").option("-b, --base-branch <branch>", "Override base branch for change detection").option("-g, --gate <name>", "Run specific review gate only").option("-c, --commit <sha>", "Use diff for a specific commit").option("-u, --uncommitted", "Use diff for current uncommitted changes (staged and unstaged)").option("-e, --enable-review <name>", "Activate a disabled review for this run (repeatable)", (value, prev = []) => [...prev, value], []).action((options) => executeGateCommand("review", {
+    ...options,
+    enableReviews: new Set(options.enableReview ?? [])
+  }));
+}
+// src/scripts/review-audit.ts
+import fs33 from "node:fs";
+import path31 from "node:path";
+import readline from "node:readline";
+function parseKeyValue2(text) {
+  const result = {};
+  for (const [, key, value] of text.matchAll(/(\w+)=(\S+)/g))
+    if (key && value)
+      result[key] = value;
+  return result;
+}
+var parseTimestamp2 = (line) => line.match(/^\[([^\]]+)\]/)?.[1] ?? "";
+var parseEventType2 = (line) => line.match(/^\[[^\]]+\]\s+(\S+)/)?.[1] ?? "";
+var parseEventBody2 = (line) => line.match(/^\[[^\]]+\]\s+\S+\s*(.*)/)?.[1] ?? "";
+var safeNum = (v) => {
+  const n = Number(v ?? 0);
+  return Number.isNaN(n) ? 0 : n;
+};
+var parseDuration = (d) => {
+  const m = d.match(/^([\d.]+)(ms|s|m)?$/);
+  const val = safeNum(m?.[1]);
+  if (m?.[2] === "ms")
+    return val / 1000;
+  if (m?.[2] === "m")
+    return val * 60;
+  return val;
+};
+function getLogDir3(cwd) {
+  const configPath = path31.join(cwd, ".gauntlet", "config.yml");
+  try {
+    const content = fs33.readFileSync(configPath, "utf-8");
+    const match = content.match(/^log_dir:\s*(.+)$/m);
+    if (match?.[1])
+      return match[1].trim();
+  } catch {}
+  return "gauntlet_logs";
+}
+function handleRunStart(ts, body) {
+  const kv = parseKeyValue2(body);
   return {
-    baseRef: baseBranch,
-    total: totalNew + totalModified + totalDeleted,
-    newFiles: totalNew,
-    modifiedFiles: totalModified,
-    deletedFiles: totalDeleted,
-    linesAdded: committedLines.linesAdded + uncommittedLines.linesAdded,
-    linesRemoved: committedLines.linesRemoved + uncommittedLines.linesRemoved
+    timestamp: ts,
+    mode: kv.mode ?? "unknown",
+    linesAdded: safeNum(kv.lines_added),
+    linesRemoved: safeNum(kv.lines_removed),
+    reviewGates: [],
+    priorPassSkips: 0,
+    telemetry: []
   };
 }
-function parseNumstat(output) {
-  let linesAdded = 0;
-  let linesRemoved = 0;
-  for (const line of output.split(`
-`)) {
-    if (!line.trim())
-      continue;
-    const parts = line.split("\t");
-    if (parts.length < 3)
-      continue;
-    const added = parts[0];
-    const removed = parts[1];
-    if (added && added !== "-") {
-      linesAdded += parseInt(added, 10) || 0;
-    }
-    if (removed && removed !== "-") {
-      linesRemoved += parseInt(removed, 10) || 0;
-    }
+function handleGateResult(current, body) {
+  const gateIdMatch = body.match(/^(\S+)/);
+  const gateId = gateIdMatch?.[1] ?? "";
+  if (!gateId.startsWith("review:"))
+    return;
+  const kv = parseKeyValue2(body);
+  if (kv.cli) {
+    current.reviewGates.push({
+      reviewType: gateId.split(":").at(-1) ?? "other",
+      cli: kv.cli,
+      durationS: parseDuration(kv.duration ?? "0s"),
+      violations: safeNum(kv.violations)
+    });
+  } else {
+    current.priorPassSkips++;
   }
-  return { linesAdded, linesRemoved };
 }
-function parseNameStatus(output) {
-  let newFiles = 0;
-  let modifiedFiles = 0;
-  let deletedFiles = 0;
-  for (const line of output.split(`
-`)) {
-    if (!line.trim())
-      continue;
-    const status = line[0];
-    switch (status) {
-      case "A":
-        newFiles++;
-        break;
-      case "M":
-      case "R":
-      case "C":
-      case "T":
-        modifiedFiles++;
-        break;
-      case "D":
-        deletedFiles++;
-        break;
-    }
-  }
-  return {
-    total: newFiles + modifiedFiles + deletedFiles,
-    newFiles,
-    modifiedFiles,
-    deletedFiles
+function handleTelemetry(current, body) {
+  const kv = parseKeyValue2(body);
+  if (!kv.adapter)
+    return;
+  current.telemetry.push({
+    adapter: kv.adapter,
+    inTokens: safeNum(kv.in),
+    cacheTokens: safeNum(kv.cache),
+    outTokens: safeNum(kv.out),
+    thoughtTokens: safeNum(kv.thought),
+    toolTokens: safeNum(kv.tool),
+    apiRequests: safeNum(kv.api_requests),
+    cacheRead: safeNum(kv.cacheRead),
+    cacheWrite: safeNum(kv.cacheWrite)
+  });
+}
+function handleRunEnd(current, body) {
+  const kv = parseKeyValue2(body);
+  current.end = {
+    status: kv.status ?? "unknown",
+    fixed: safeNum(kv.fixed),
+    skipped: safeNum(kv.skipped),
+    failed: safeNum(kv.failed)
   };
 }
-function countOverlap(status1, status2) {
-  const files1 = new Set;
-  for (const line of status1.split(`
-`)) {
-    if (!line.trim())
-      continue;
-    const parts = line.split("\t");
-    const file = parts[1];
-    if (parts.length >= 2 && file) {
-      files1.add(file);
-    }
+var emptyStat = () => ({
+  count: 0,
+  totalDuration: 0,
+  totalViolations: 0
+});
+function addGate(s, g) {
+  s.count++;
+  s.totalDuration += g.durationS;
+  s.totalViolations += g.violations;
+}
+function getOrCreate(map, key, init) {
+  if (!map.has(key))
+    map.set(key, init());
+  return map.get(key);
+}
+var REVIEW_TYPES = ["code-quality", "task-compliance", "artifact-review"];
+function accumulateBlock(block, a) {
+  for (const g of block.reviewGates) {
+    const inner = getOrCreate(a.cells, g.reviewType, () => new Map);
+    addGate(getOrCreate(inner, g.cli, emptyStat), g);
+    addGate(getOrCreate(a.cliTotals, g.cli, emptyStat), g);
+    addGate(getOrCreate(a.typeTotals, g.reviewType, emptyStat), g);
+    addGate(a.grandTotal, g);
+  }
+  const diff = block.linesAdded + block.linesRemoved;
+  if (diff <= 0)
+    return;
+  for (const cli of new Set(block.reviewGates.map((g) => g.cli))) {
+    const dur = block.reviewGates.filter((g) => g.cli === cli).reduce((s, g) => s + g.durationS, 0);
+    const p = getOrCreate(a.per100, cli, () => ({ dur: 0, diff: 0 }));
+    p.dur += dur;
+    p.diff += diff;
+  }
+}
+function buildCrossTab(blocks) {
+  const a = {
+    cells: new Map,
+    cliTotals: new Map,
+    typeTotals: new Map,
+    per100: new Map,
+    grandTotal: emptyStat()
+  };
+  for (const block of blocks)
+    accumulateBlock(block, a);
+  const allTypes = [
+    ...REVIEW_TYPES.filter((t) => a.typeTotals.has(t)),
+    ...[...a.typeTotals.keys()].filter((t) => !REVIEW_TYPES.includes(t))
+  ];
+  return { ...a, allTypes, allClis: [...a.cliTotals.keys()] };
+}
+var emptyTokenStats = (adapter) => ({
+  adapter,
+  inTokens: 0,
+  cacheTokens: 0,
+  outTokens: 0,
+  thoughtTokens: 0,
+  toolTokens: 0,
+  apiRequests: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+  runsWithTelemetry: 0
+});
+function accumulateTelemetryEntry(t, statsMap) {
+  const s = statsMap.get(t.adapter) ?? emptyTokenStats(t.adapter);
+  statsMap.set(t.adapter, s);
+  s.inTokens += t.inTokens;
+  s.cacheTokens += t.cacheTokens;
+  s.outTokens += t.outTokens;
+  s.thoughtTokens += t.thoughtTokens;
+  s.toolTokens += t.toolTokens;
+  s.apiRequests += t.apiRequests;
+  s.cacheRead += t.cacheRead;
+  s.cacheWrite += t.cacheWrite;
+}
+function aggregateTokenStats(blocks) {
+  const statsMap = new Map;
+  for (const block of blocks) {
+    const adaptersInBlock = new Set(block.telemetry.map((t) => t.adapter));
+    for (const t of block.telemetry)
+      accumulateTelemetryEntry(t, statsMap);
+    for (const adapter of adaptersInBlock) {
+      const s = statsMap.get(adapter);
+      if (s)
+        s.runsWithTelemetry++;
+    }
+  }
+  return Array.from(statsMap.values());
+}
+var formatNum = (n) => n.toLocaleString("en-US");
+var padRight = (s, w) => s + " ".repeat(Math.max(0, w - s.length));
+var padLeft = (s, w) => " ".repeat(Math.max(0, w - s.length)) + s;
+var capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+var fmtType = (t) => t.split("-").map(capitalize).join("-");
+function formatCrossTable(title, rowLabels, colLabels, cell, rowTotal, colTotal, grandTotal) {
+  const rlW = Math.max(17, ...rowLabels.map((r) => fmtType(r).length)) + 2;
+  const cW = 12;
+  const hdr = padRight("", rlW) + colLabels.map((c) => padRight(capitalize(c), cW)).join("") + "Total";
+  const rows = rowLabels.map((r) => padRight(fmtType(r), rlW) + colLabels.map((c) => padRight(cell(r, c), cW)).join("") + rowTotal(r));
+  const totalRow = padRight("Total", rlW) + colLabels.map((c) => padRight(colTotal(c), cW)).join("") + grandTotal;
+  return [title, hdr, ...rows, totalRow, ""];
+}
+function formatRunCounts(ct) {
+  return formatCrossTable("=== Run Counts ===", ct.allTypes, ct.allClis, (t, c) => String(ct.cells.get(t)?.get(c)?.count ?? 0), (t) => String(ct.typeTotals.get(t)?.count ?? 0), (c) => String(ct.cliTotals.get(c)?.count ?? 0), String(ct.grandTotal.count));
+}
+function formatTiming(ct) {
+  const avg = (s) => s && s.count > 0 ? `${(s.totalDuration / s.count).toFixed(1)}s` : "n/a";
+  const lines = formatCrossTable("=== Timing ===", ct.allTypes, ct.allClis, (t, c) => avg(ct.cells.get(t)?.get(c)), (t) => avg(ct.typeTotals.get(t)), (c) => avg(ct.cliTotals.get(c)), avg(ct.grandTotal));
+  const p100parts = ct.allClis.map((c) => {
+    const p = ct.per100.get(c);
+    return p && p.diff > 0 ? `${c}=${(p.dur / p.diff * 100).toFixed(1)}s` : "";
+  }).filter(Boolean);
+  if (p100parts.length > 0)
+    lines.splice(lines.length - 1, 0, `Per 100 diff lines (excl. zero-diff): ${p100parts.join("  ")}`);
+  return lines;
+}
+function formatViolations(ct) {
+  const avg = (s) => s && s.count > 0 ? (s.totalViolations / s.count).toFixed(2) : "n/a";
+  return formatCrossTable("=== Violations (avg per run) ===", ct.allTypes, ct.allClis, (t, c) => avg(ct.cells.get(t)?.get(c)), (t) => avg(ct.typeTotals.get(t)), (c) => avg(ct.cliTotals.get(c)), avg(ct.grandTotal));
+}
+function formatTokenEntry(t, totalRuns) {
+  const out = [
+    `${capitalize(t.adapter)} (${t.runsWithTelemetry} of ${totalRuns} runs had telemetry):`
+  ];
+  if (t.inTokens > 0 || t.cacheTokens > 0) {
+    const total = t.inTokens + t.cacheTokens;
+    out.push(`  Input:        ${padLeft(formatNum(total), 12)}   (non-cached: ${formatNum(t.inTokens)} | cached: ${formatNum(t.cacheTokens)})`);
+  }
+  if (t.outTokens > 0)
+    out.push(`  Output:       ${padLeft(formatNum(t.outTokens), 12)}`);
+  if (t.thoughtTokens > 0)
+    out.push(`  Thinking:     ${padLeft(formatNum(t.thoughtTokens), 12)}`);
+  if (t.toolTokens > 0)
+    out.push(`  Tool tokens:  ${padLeft(formatNum(t.toolTokens), 12)}`);
+  if (t.cacheRead > 0 || t.cacheWrite > 0) {
+    out.push(`  Cache reads:  ${padLeft(formatNum(t.cacheRead), 12)}`);
+    out.push(`  Cache writes: ${padLeft(formatNum(t.cacheWrite), 12)}`);
+  }
+  if (t.apiRequests > 0) {
+    const avg = t.runsWithTelemetry > 0 ? (t.apiRequests / t.runsWithTelemetry).toFixed(1) : "?";
+    out.push(`  API requests: ${padLeft(formatNum(t.apiRequests), 12)}    (avg ${avg}/run)`);
+  }
+  out.push("");
+  return out;
+}
+function formatTokenUsage(ts, m) {
+  if (ts.length === 0)
+    return ["=== Token Usage ===", "No telemetry data found.", ""];
+  return [
+    "=== Token Usage ===",
+    ...ts.flatMap((t) => formatTokenEntry(t, m.get(t.adapter) ?? t.runsWithTelemetry))
+  ];
+}
+function formatFixSkip(blocks) {
+  const withEnd = blocks.filter((b) => b.end);
+  const total = withEnd.length;
+  const passed = withEnd.filter((b) => b.end?.status === "pass").length;
+  const fixed = withEnd.reduce((s, b) => s + (b.end?.fixed ?? 0), 0);
+  const skipped = withEnd.reduce((s, b) => s + (b.end?.skipped ?? 0), 0);
+  const failed = withEnd.reduce((s, b) => s + (b.end?.failed ?? 0), 0);
+  const priorPass = blocks.reduce((s, b) => s + b.priorPassSkips, 0);
+  const lines = [
+    "=== Fix / Skip ===",
+    `Gauntlet runs: ${total} total  (${passed} passed, ${total - passed} failed)`,
+    `  Violations fixed:   ${fixed}`,
+    `  Violations skipped: ${skipped}`,
+    `  Gates failed:       ${failed}`,
+    `  Review gates skipped (prior pass): ${priorPass}`
+  ];
+  const totalFixedSkipped = fixed + skipped;
+  if (totalFixedSkipped > 0) {
+    const fp = (fixed / totalFixedSkipped * 100).toFixed(1);
+    const sp = (skipped / totalFixedSkipped * 100).toFixed(1);
+    lines.push(`  (fixed: ${fp}% | skipped: ${sp}% of fixed+skipped)`);
   }
-  let overlap = 0;
-  for (const line of status2.split(`
-`)) {
+  return lines;
+}
+function formatAuditReport(blocks, date) {
+  if (blocks.length === 0)
+    return `Review Execution Audit — ${date}
+
+No gauntlet runs found for this date.`;
+  const ct = buildCrossTab(blocks);
+  const tokenStats = aggregateTokenStats(blocks);
+  const cliBlockCount = new Map;
+  for (const block of blocks) {
+    for (const cli of new Set(block.reviewGates.map((g) => g.cli)))
+      cliBlockCount.set(cli, (cliBlockCount.get(cli) ?? 0) + 1);
+  }
+  return [
+    `Review Execution Audit — ${date}`,
+    "",
+    ...formatRunCounts(ct),
+    ...formatTiming(ct),
+    ...formatViolations(ct),
+    ...formatTokenUsage(tokenStats, cliBlockCount),
+    ...formatFixSkip(blocks)
+  ].join(`
+`);
+}
+function todayLocalDate() {
+  const now = new Date;
+  const y = now.getFullYear();
+  const mo = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  return `${y}-${mo}-${d}`;
+}
+async function readBlocks(filePath, date) {
+  const rl = readline.createInterface({
+    input: fs33.createReadStream(filePath)
+  });
+  const blocks = [];
+  let current = null;
+  for await (const line of rl) {
     if (!line.trim())
       continue;
-    const parts = line.split("\t");
-    const file = parts[1];
-    if (parts.length >= 2 && file && files1.has(file)) {
-      overlap++;
+    const ts = parseTimestamp2(line);
+    if (!ts.startsWith(date))
+      continue;
+    const event = parseEventType2(line);
+    const body = parseEventBody2(line);
+    if (event === "RUN_START") {
+      current = handleRunStart(ts, body);
+      blocks.push(current);
+      continue;
     }
+    if (!current)
+      continue;
+    if (event === "GATE_RESULT")
+      handleGateResult(current, body);
+    else if (event === "TELEMETRY")
+      handleTelemetry(current, body);
+    else if (event === "RUN_END")
+      handleRunEnd(current, body);
   }
-  return overlap;
+  return blocks;
 }
-function emptyDiffStats(baseRef) {
-  return {
-    baseRef,
-    total: 0,
-    newFiles: 0,
-    modifiedFiles: 0,
-    deletedFiles: 0,
-    linesAdded: 0,
-    linesRemoved: 0
-  };
+async function main2(date) {
+  const cwd = process.cwd();
+  if (date && !/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+    console.error("Invalid --date. Expected YYYY-MM-DD");
+    process.exit(1);
+  }
+  const targetDate = date ?? todayLocalDate();
+  const debugLogPath = path31.join(cwd, getLogDir3(cwd), ".debug.log");
+  if (!fs33.existsSync(debugLogPath)) {
+    console.log(`No debug log found. (looked in ${getLogDir3(cwd)}/.debug.log)`);
+    process.exit(0);
+  }
+  const blocks = await readBlocks(debugLogPath, targetDate);
+  console.log(formatAuditReport(blocks, targetDate));
 }
+var isDirectRun2 = (import.meta.url === `file://${process.argv[1]}` || typeof Bun !== "undefined" && import.meta.url === `file://${Bun.main}`) && (process.argv[1]?.endsWith("review-audit.ts") || process.argv[1]?.endsWith("review-audit.js"));
+if (isDirectRun2)
+  main2();
 
+// src/commands/review-audit.ts
+function registerReviewAuditCommand(program) {
+  program.command("review-audit").description("Audit review execution for a given date from the debug log").option("--date <YYYY-MM-DD>", "Date to filter (default: today)").action(async (opts) => {
+    await main2(opts.date);
+  });
+}
 // src/core/run-executor-lock.ts
-import fs32 from "node:fs/promises";
-import path30 from "node:path";
+import fs34 from "node:fs/promises";
+import path32 from "node:path";
 var LOCK_FILENAME2 = ".gauntlet-run.lock";
 var STALE_LOCK_MS = 10 * 60 * 1000;
 function isProcessAlive(pid) {
@@ -8655,9 +9140,9 @@ function isProcessAlive(pid) {
 }
 async function isLockStale(lockPath) {
   try {
-    const lockContent = await fs32.readFile(lockPath, "utf-8");
+    const lockContent = await fs34.readFile(lockPath, "utf-8");
     const lockPid = Number.parseInt(lockContent.trim(), 10);
-    const lockStat = await fs32.stat(lockPath);
+    const lockStat = await fs34.stat(lockPath);
     const lockAgeMs = Date.now() - lockStat.mtimeMs;
     const pidValid = !Number.isNaN(lockPid);
     if (pidValid && !isProcessAlive(lockPid)) {
@@ -8672,10 +9157,10 @@ async function isLockStale(lockPath) {
   }
 }
 async function tryAcquireLock(logDir) {
-  await fs32.mkdir(logDir, { recursive: true });
-  const lockPath = path30.resolve(logDir, LOCK_FILENAME2);
+  await fs34.mkdir(logDir, { recursive: true });
+  const lockPath = path32.resolve(logDir, LOCK_FILENAME2);
   try {
-    await fs32.writeFile(lockPath, String(process.pid), { flag: "wx" });
+    await fs34.writeFile(lockPath, String(process.pid), { flag: "wx" });
     return true;
   } catch (err) {
     const isExist = typeof err === "object" && err !== null && "code" in err && err.code === "EEXIST";
@@ -8686,9 +9171,9 @@ async function tryAcquireLock(logDir) {
     if (!stale) {
       return false;
     }
-    await fs32.rm(lockPath, { force: true });
+    await fs34.rm(lockPath, { force: true });
     try {
-      await fs32.writeFile(lockPath, String(process.pid), { flag: "wx" });
+      await fs34.writeFile(lockPath, String(process.pid), { flag: "wx" });
       return true;
     } catch {
       return false;
@@ -8697,7 +9182,7 @@ async function tryAcquireLock(logDir) {
 }
 async function findLatestConsoleLog(logDir) {
   try {
-    const files = await fs32.readdir(logDir);
+    const files = await fs34.readdir(logDir);
     let maxNum = -1;
     let latestFile = null;
     for (const file of files) {
@@ -8713,7 +9198,7 @@ async function findLatestConsoleLog(logDir) {
         }
       }
     }
-    return latestFile ? path30.join(logDir, latestFile) : null;
+    return latestFile ? path32.join(logDir, latestFile) : null;
   } catch {
     return null;
   }
@@ -8894,7 +9379,7 @@ async function detectAndPrepareChanges(ctx, isRerun, failuresMap, changeOptions)
   };
   const changeDetector = new ChangeDetector(ctx.effectiveBaseBranch, effectiveChangeOptions);
   const expander = new EntryPointExpander;
-  const jobGen = new JobGenerator(ctx.config);
+  const jobGen = new JobGenerator(ctx.config, ctx.options.enableReviews);
   log10.debug("Detecting changes...");
   const changes = await changeDetector.getChangedFiles();
   if (changes.length === 0 && isRerun) {
@@ -9071,12 +9556,13 @@ async function executeRun(options = {}) {
 
 // src/commands/run.ts
 function registerRunCommand(program) {
-  program.command("run").description("Run gates for detected changes").option("-b, --base-branch <branch>", "Override base branch for change detection").option("-g, --gate <name>", "Run specific gate only").option("-c, --commit <sha>", "Use diff for a specific commit").option("-u, --uncommitted", "Use diff for current uncommitted changes (staged and unstaged)").action(async (options) => {
+  program.command("run").description("Run gates for detected changes").option("-b, --base-branch <branch>", "Override base branch for change detection").option("-g, --gate <name>", "Run specific gate only").option("-c, --commit <sha>", "Use diff for a specific commit").option("-u, --uncommitted", "Use diff for current uncommitted changes (staged and unstaged)").option("-e, --enable-review <name>", "Activate a disabled review for this run (repeatable)", (value, prev = []) => [...prev, value], []).action(async (options) => {
     const result = await executeRun({
       baseBranch: options.baseBranch,
       gate: options.gate,
       commit: options.commit,
-      uncommitted: options.uncommitted
+      uncommitted: options.uncommitted,
+      enableReviews: new Set(options.enableReview ?? [])
     });
     const code = isSuccessStatus(result.status) ? 0 : 1;
     process.exit(code);
@@ -9114,8 +9600,8 @@ function registerSkipCommand(program) {
   });
 }
 // src/commands/start-hook.ts
-import fs33 from "node:fs/promises";
-import path31 from "node:path";
+import fs35 from "node:fs/promises";
+import path33 from "node:path";
 import YAML8 from "yaml";
 var START_HOOK_MESSAGE = `<IMPORTANT>
 This project uses Agent Gauntlet for automated quality verification.
@@ -9163,9 +9649,9 @@ function isValidConfig(content) {
 }
 function registerStartHookCommand(program) {
   program.command("start-hook").description("Session start hook - primes agent with gauntlet verification instructions").option("--adapter <adapter>", "Output format: claude or cursor", "claude").action(async (options) => {
-    const configPath = path31.join(process.cwd(), ".gauntlet", "config.yml");
+    const configPath = path33.join(process.cwd(), ".gauntlet", "config.yml");
     try {
-      const content = await fs33.readFile(configPath, "utf-8");
+      const content = await fs35.readFile(configPath, "utf-8");
       if (!isValidConfig(content)) {
         return;
       }
@@ -9175,7 +9661,7 @@ function registerStartHookCommand(program) {
     const adapter = options.adapter;
     try {
       const cwd = process.cwd();
-      const logDir = path31.join(cwd, await getLogDir2(cwd));
+      const logDir = path33.join(cwd, await getLogDir2(cwd));
       const globalConfig = await loadGlobalConfig();
       const projectDebugLogConfig = await getDebugLogConfig(cwd);
       const debugLogConfig = mergeDebugLogConfig(projectDebugLogConfig, globalConfig.debug_log);
@@ -9214,6 +9700,7 @@ registerRunCommand(program);
 registerCheckCommand(program);
 registerCICommand(program);
 registerCleanCommand(program);
+registerReviewAuditCommand(program);
 registerReviewCommand(program);
 registerDetectCommand(program);
 registerListCommand(program);
@@ -9230,4 +9717,4 @@ if (process.argv.length < 3) {
 }
 program.parse(process.argv);
 
-//# debugId=E93D541AB16DB2CC64756E2164756E21
+//# debugId=CAFA132ED75F0B9564756E2164756E21