agent-gauntlet 0.14.0 → 0.15.1

package/dist/index.js

@@ -2,12 +2,292 @@
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/scripts/status.ts
+import fs from "node:fs";
+import path from "node:path";
+function parseKeyValue(text) {
+  const result = {};
+  for (const match of text.matchAll(/(\w+)=(\S+)/g)) {
+    const key = match[1];
+    const value = match[2];
+    if (key && value)
+      result[key] = value;
+  }
+  return result;
+}
+function parseTimestamp(line) {
+  const m = line.match(/^\[([^\]]+)\]/);
+  return m?.[1] ?? "";
+}
+function parseEventType(line) {
+  const m = line.match(/^\[[^\]]+\]\s+(\S+)/);
+  return m?.[1] ?? "";
+}
+function parseEventBody(line) {
+  const m = line.match(/^\[[^\]]+\]\s+\S+\s*(.*)/);
+  return m?.[1] ?? "";
+}
+function parseDebugLog(content, sessionStartTime) {
+  const lines = content.split(`
+`).filter((l) => l.trim());
+  const sessions = [];
+  let current = null;
+  for (const line of lines) {
+    const event = parseEventType(line);
+    const body = parseEventBody(line);
+    const ts = parseTimestamp(line);
+    switch (event) {
+      case "RUN_START": {
+        if (sessionStartTime && new Date(ts) < sessionStartTime) {
+          current = null;
+          break;
+        }
+        const kv = parseKeyValue(body);
+        current = {
+          start: {
+            timestamp: ts,
+            mode: kv.mode ?? "unknown",
+            baseRef: kv.base_ref,
+            filesChanged: Number(kv.files_changed ?? kv.changes ?? 0),
+            linesAdded: Number(kv.lines_added ?? 0),
+            linesRemoved: Number(kv.lines_removed ?? 0),
+            gates: Number(kv.gates ?? 0)
+          },
+          gates: []
+        };
+        sessions.push(current);
+        break;
+      }
+      case "GATE_RESULT": {
+        if (!current)
+          break;
+        const gateIdMatch = body.match(/^(\S+)/);
+        const kv = parseKeyValue(body);
+        current.gates.push({
+          timestamp: ts,
+          gateId: gateIdMatch?.[1] ?? "unknown",
+          cli: kv.cli,
+          status: kv.status ?? "unknown",
+          duration: kv.duration ?? "?",
+          violations: kv.violations !== undefined ? Number(kv.violations) : undefined
+        });
+        break;
+      }
+      case "RUN_END": {
+        if (!current)
+          break;
+        const kv = parseKeyValue(body);
+        current.end = {
+          timestamp: ts,
+          status: kv.status ?? "unknown",
+          fixed: Number(kv.fixed ?? 0),
+          skipped: Number(kv.skipped ?? 0),
+          failed: Number(kv.failed ?? 0),
+          iterations: Number(kv.iterations ?? 0),
+          duration: kv.duration ?? "?"
+        };
+        break;
+      }
+      case "STOP_HOOK": {
+        if (!current)
+          break;
+        const kv = parseKeyValue(body);
+        current.stopHook = {
+          timestamp: ts,
+          decision: kv.decision ?? "unknown",
+          reason: kv.reason ?? "unknown"
+        };
+        break;
+      }
+    }
+  }
+  return sessions;
+}
+function getSessionStartTime(logDir) {
+  const entries = fs.readdirSync(logDir).filter((f) => !f.startsWith(".") && f !== "previous");
+  let earliest;
+  for (const entry of entries) {
+    const mtime = fs.statSync(path.join(logDir, entry)).mtimeMs;
+    if (earliest === undefined || mtime < earliest) {
+      earliest = mtime;
+    }
+  }
+  return earliest !== undefined ? new Date(earliest) : undefined;
+}
+function formatFileInventory(logDir) {
+  const lines = [];
+  const entries = fs.readdirSync(logDir).filter((f) => !f.startsWith(".") && f !== "previous");
+  if (entries.length === 0)
+    return lines;
+  const checks = [];
+  const reviews = [];
+  const other = [];
+  for (const entry of entries.sort()) {
+    const fullPath = path.join(logDir, entry);
+    const stat = fs.statSync(fullPath);
+    const sizeKB = (stat.size / 1024).toFixed(1);
+    const line = `- ${fullPath} (${sizeKB} KB)`;
+    if (entry.startsWith("review_")) {
+      reviews.push(line);
+    } else if (entry.startsWith("check_")) {
+      checks.push(line);
+    } else {
+      other.push(line);
+    }
+  }
+  lines.push("### Log Files");
+  lines.push("");
+  if (checks.length > 0) {
+    lines.push("**Check logs:**");
+    lines.push(...checks);
+  }
+  if (reviews.length > 0) {
+    lines.push("**Review logs/JSON:**");
+    lines.push(...reviews);
+  }
+  if (other.length > 0) {
+    lines.push("**Other:**");
+    lines.push(...other);
+  }
+  lines.push("");
+  return lines;
+}
+function formatStatusLine(end) {
+  return end.status === "pass" ? "PASSED" : end.status === "fail" ? "FAILED" : end.status.toUpperCase();
+}
+function formatAllRuns(sessions) {
+  const lines = [];
+  lines.push("### All Runs in Session");
+  lines.push("");
+  for (let i = 0;i < sessions.length; i++) {
+    const s = sessions[i];
+    if (!s)
+      continue;
+    const status = s.end ? s.end.status : "in-progress";
+    const duration = s.end ? s.end.duration : "?";
+    lines.push(`${i + 1}. [${s.start.timestamp}] mode=${s.start.mode} status=${status} duration=${duration}`);
+  }
+  lines.push("");
+  return lines;
+}
+function formatSession(sessions, logDir) {
+  if (sessions.length === 0) {
+    return "No gauntlet runs found in logs.";
+  }
+  const lastComplete = [...sessions].reverse().find((s) => s.end);
+  const session = lastComplete ?? sessions[sessions.length - 1];
+  if (!session)
+    return "No gauntlet runs found in logs.";
+  const lines = [];
+  lines.push("## Gauntlet Session Summary");
+  lines.push("");
+  if (session.end) {
+    lines.push(`**Status:** ${formatStatusLine(session.end)}`);
+    lines.push(`**Iterations:** ${session.end.iterations}`);
+    lines.push(`**Duration:** ${session.end.duration}`);
+    lines.push(`**Fixed:** ${session.end.fixed} | **Skipped:** ${session.end.skipped} | **Failed:** ${session.end.failed}`);
+  } else {
+    lines.push("**Status:** In Progress (no RUN_END found)");
+  }
+  lines.push("");
+  lines.push("### Diff Stats");
+  lines.push(`- Mode: ${session.start.mode}`);
+  if (session.start.baseRef) {
+    lines.push(`- Base ref: ${session.start.baseRef}`);
+  }
+  lines.push(`- Files changed: ${session.start.filesChanged}`);
+  lines.push(`- Lines: +${session.start.linesAdded} / -${session.start.linesRemoved}`);
+  lines.push(`- Gates: ${session.start.gates}`);
+  lines.push("");
+  lines.push("### Gate Results");
+  lines.push("");
+  lines.push("| Gate | CLI | Status | Duration | Violations |");
+  lines.push("|------|-----|--------|----------|------------|");
+  for (const gate of session.gates) {
+    const violations = gate.violations !== undefined ? String(gate.violations) : "-";
+    const statusIcon = gate.status === "pass" ? "pass" : "FAIL";
+    lines.push(`| ${gate.gateId} | ${gate.cli ?? "-"} | ${statusIcon} | ${gate.duration} | ${violations} |`);
+  }
+  lines.push("");
+  if (session.stopHook) {
+    lines.push("### Stop Hook");
+    lines.push(`- Decision: ${session.stopHook.decision}`);
+    lines.push(`- Reason: ${session.stopHook.reason}`);
+    lines.push("");
+  }
+  lines.push(...formatFileInventory(logDir));
+  if (sessions.length > 1) {
+    lines.push(...formatAllRuns(sessions));
+  }
+  return lines.join(`
+`);
+}
+function getLogDir(cwd) {
+  const configPath = path.join(cwd, ".gauntlet", "config.yml");
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    const match = content.match(/^log_dir:\s*(.+)$/m);
+    if (match?.[1])
+      return match[1].trim();
+  } catch {}
+  return "gauntlet_logs";
+}
+function resolveLogPaths(activeDir) {
+  const previousDir = path.join(activeDir, "previous");
+  const debugLogPath = path.join(activeDir, ".debug.log");
+  const activeHasLogs = fs.existsSync(activeDir) && fs.readdirSync(activeDir).some((f) => !f.startsWith(".") && f !== "previous");
+  if (activeHasLogs) {
+    return { logDir: activeDir, debugLogPath };
+  }
+  if (!fs.existsSync(previousDir)) {
+    console.log("No gauntlet_logs directory found.");
+    return null;
+  }
+  const logDir = resolvePreviousLogDir(previousDir);
+  if (!logDir)
+    return null;
+  return { logDir, debugLogPath };
+}
+function resolvePreviousLogDir(previousDir) {
+  const prevEntries = fs.readdirSync(previousDir);
+  const hasDirectFiles = prevEntries.some((f) => f.endsWith(".log") || f.endsWith(".json"));
+  if (hasDirectFiles)
+    return previousDir;
+  const prevDirs = prevEntries.map((d) => path.join(previousDir, d)).filter((d) => fs.statSync(d).isDirectory()).sort().reverse();
+  if (prevDirs.length === 0) {
+    console.log("No gauntlet logs found.");
+    return null;
+  }
+  return prevDirs[0];
+}
+function main() {
+  const cwd = process.cwd();
+  const logDirName = getLogDir(cwd);
+  const activeDir = path.join(cwd, logDirName);
+  const paths = resolveLogPaths(activeDir);
+  if (!paths) {
+    process.exit(0);
+  }
+  let sessions = [];
+  if (fs.existsSync(paths.debugLogPath)) {
+    const debugContent = fs.readFileSync(paths.debugLogPath, "utf-8");
+    const sessionStart = getSessionStartTime(paths.logDir);
+    sessions = parseDebugLog(debugContent, sessionStart);
+  }
+  const output = formatSession(sessions, paths.logDir);
+  console.log(output);
+}
+var isDirectRun = (import.meta.url === `file://${process.argv[1]}` || typeof Bun !== "undefined" && import.meta.url === `file://${Bun.main}`) && (process.argv[1]?.endsWith("status.ts") || process.argv[1]?.endsWith("status.js"));
+if (isDirectRun) {
+  main();
+}
+
 // src/index.ts
 import { Command } from "commander";
 // package.json
 var package_default = {
   name: "agent-gauntlet",
-  version: "0.14.0",
+  version: "0.15.1",
   description: "A CLI tool for testing AI coding agents",
   license: "MIT",
   author: "Paul Caplan",
@@ -28,6 +308,7 @@ var package_default = {
   ],
   files: [
     "dist",
+    "skills",
     "README.md",
     "LICENSE"
   ],
@@ -85,12 +366,12 @@ var package_default = {
 import chalk3 from "chalk";
 
 // src/config/global.ts
-import fs from "node:fs/promises";
+import fs2 from "node:fs/promises";
 import os from "node:os";
-import path from "node:path";
+import path2 from "node:path";
 import YAML from "yaml";
 import { z } from "zod";
-var GLOBAL_CONFIG_PATH = path.join(os.homedir(), ".config", "agent-gauntlet", "config.yml");
+var GLOBAL_CONFIG_PATH = path2.join(os.homedir(), ".config", "agent-gauntlet", "config.yml");
 var debugLogConfigSchema = z.object({
   enabled: z.boolean().default(false),
   max_size_mb: z.number().default(10)
@@ -123,7 +404,7 @@ var DEFAULT_GLOBAL_CONFIG = {
 };
 async function loadGlobalConfig() {
   try {
-    const content = await fs.readFile(GLOBAL_CONFIG_PATH, "utf-8");
+    const content = await fs2.readFile(GLOBAL_CONFIG_PATH, "utf-8");
     const raw = YAML.parse(content);
     return globalConfigSchema.parse(raw);
   } catch (error) {
@@ -136,30 +417,59 @@ async function loadGlobalConfig() {
 }
 
 // src/config/loader.ts
-import fs2 from "node:fs/promises";
-import path2 from "node:path";
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
 import matter from "gray-matter";
 import YAML2 from "yaml";
 
 // src/built-in-reviews/code-quality.md
 var code_quality_default = `# Code Quality Review
 
-You are a senior software engineer performing a code review. Your primary goal is to identify **real problems** that could cause bugs, security vulnerabilities, or performance issues in production. Do not report style, formatting, naming conventions, or maintainability suggestions unless you see something egregious.
+You are a senior software engineer performing a code review. Your goal is to identify **real problems** that could cause bugs, security vulnerabilities, performance issues, or silent failures in production.
+
+## Review Strategy
+
+Use a multi-lens approach covering three analysis areas. For each lens, first check whether the corresponding pr-review-toolkit agent is available. If it is, dispatch that agent against the diff. If it is not available, perform the analysis inline using the framework below.
+
+### Lens 1: Code Quality, Bugs & Security
 
-## Focus Areas (in priority order)
+**Agent:** \`code-reviewer\` (from pr-review-toolkit)
 
-1. **Bugs** — Logic errors, null/undefined issues, race conditions, unhandled edge cases, resource leaks
-2. **Security** — Injection vulnerabilities, auth/authz flaws, sensitive data exposure, input validation gaps
-3. **Performance** — Algorithmic complexity issues, N+1 queries, blocking operations, memory problems
-4. **Maintainability** — Unclear code, missing error handling, duplication
+If the \`code-reviewer\` agent is unavailable, review inline for:
+- **Logic errors** — off-by-one, null/undefined, race conditions, unhandled edge cases
+- **Security flaws** — injection, auth/authz gaps, sensitive data exposure, input validation
+- **Performance** — algorithmic complexity, N+1 queries, blocking operations, memory leaks
+- **Resource leaks** — unclosed handles, missing cleanup in error paths
+
+### Lens 2: Silent Failures & Error Handling
+
+**Agent:** \`silent-failure-hunter\` (from pr-review-toolkit)
+
+If the \`silent-failure-hunter\` agent is unavailable, review inline for:
+- **Swallowed errors** — empty catch blocks, catch-and-return-default, ignored promise rejections
+- **Missing logging** — error paths with no observability, failures that disappear silently
+- **Inadequate error handling** — overly broad catch, lost error context, fallbacks that hide bugs
+
+### Lens 3: Type Design
+
+**Agent:** \`type-design-analyzer\` (from pr-review-toolkit)
+
+If the \`type-design-analyzer\` agent is unavailable, review inline for:
+- **Type invariants** — types that permit invalid states, missing constraints
+- **Encapsulation** — exposed internals, mutable shared state, leaky abstractions
+- **Enforcement** — runtime validation gaps at system boundaries
+
+## Merging Results
+
+After completing all three lenses (whether via agents or inline analysis), merge the findings. Deduplicate any overlapping issues. For each violation, report it exactly once under whichever lens found it first.
 
 ## Do NOT Report
 
 - Style, formatting, or naming preferences
 - Missing documentation, comments, or type annotations
-- Suggestions for "better" abstractions or patterns that aren't broken
-- Hypothetical issues that require unlikely preconditions
-- Issues in code that wasn't changed in this diff
+- Suggestions for "better" abstractions that aren't broken
+- Hypothetical issues requiring unlikely preconditions
+- Issues in code not changed in this diff
 
 ## Guidelines
 
@@ -189,7 +499,8 @@ function loadBuiltInReview(name) {
 import { z as z2 } from "zod";
 var adapterConfigSchema = z2.object({
   allow_tool_use: z2.boolean().default(true),
-  thinking_budget: z2.enum(["off", "low", "medium", "high"]).optional()
+  thinking_budget: z2.enum(["off", "low", "medium", "high"]).optional(),
+  model: z2.string().optional()
 });
 var cliConfigSchema = z2.object({
   default_preference: z2.array(z2.string().min(1)).min(1),
@@ -326,24 +637,24 @@ var CONFIG_FILE = "config.yml";
 var CHECKS_DIR = "checks";
 var REVIEWS_DIR = "reviews";
 async function loadConfig(rootDir = process.cwd()) {
-  const gauntletPath = path2.join(rootDir, GAUNTLET_DIR);
-  const configPath = path2.join(gauntletPath, CONFIG_FILE);
+  const gauntletPath = path3.join(rootDir, GAUNTLET_DIR);
+  const configPath = path3.join(gauntletPath, CONFIG_FILE);
   if (!await fileExists(configPath)) {
     throw new Error(`Configuration file not found at ${configPath}`);
   }
-  const configContent = await fs2.readFile(configPath, "utf-8");
+  const configContent = await fs3.readFile(configPath, "utf-8");
   const projectConfigRaw = YAML2.parse(configContent);
   const projectConfig = gauntletConfigSchema.parse(projectConfigRaw);
-  const checksPath = path2.join(gauntletPath, CHECKS_DIR);
+  const checksPath = path3.join(gauntletPath, CHECKS_DIR);
   const checks = {};
   if (await dirExists(checksPath)) {
-    const checkFiles = await fs2.readdir(checksPath);
+    const checkFiles = await fs3.readdir(checksPath);
     for (const file of checkFiles) {
       if (file.endsWith(".yml") || file.endsWith(".yaml")) {
-        const filePath = path2.join(checksPath, file);
-        const content = await fs2.readFile(filePath, "utf-8");
+        const filePath = path3.join(checksPath, file);
+        const content = await fs3.readFile(filePath, "utf-8");
         const raw = YAML2.parse(content);
-        const name = path2.basename(file, path2.extname(file));
+        const name = path3.basename(file, path3.extname(file));
         const parsed = checkGateSchema.parse(raw);
         const fixFile = parsed.fix_instructions_file || parsed.fix_instructions;
         const loadedCheck = {
@@ -360,14 +671,14 @@ async function loadConfig(rootDir = process.cwd()) {
       }
     }
   }
-  const reviewsPath = path2.join(gauntletPath, REVIEWS_DIR);
+  const reviewsPath = path3.join(gauntletPath, REVIEWS_DIR);
   const reviews = {};
   if (await dirExists(reviewsPath)) {
-    const reviewFiles = await fs2.readdir(reviewsPath);
+    const reviewFiles = await fs3.readdir(reviewsPath);
     const reviewNameSources = new Map;
     for (const file of reviewFiles) {
       if (file.endsWith(".md") || file.endsWith(".yml") || file.endsWith(".yaml")) {
-        const name = path2.basename(file, path2.extname(file));
+        const name = path3.basename(file, path3.extname(file));
         if (isBuiltInReview(name)) {
           throw new Error(`Review file "${file}" uses the reserved "built-in:" prefix. Rename the file to avoid conflicts with built-in reviews.`);
         }
@@ -383,11 +694,11 @@ async function loadConfig(rootDir = process.cwd()) {
     }
     for (const file of reviewFiles) {
       if (file.endsWith(".md")) {
-        const filePath = path2.join(reviewsPath, file);
-        const content = await fs2.readFile(filePath, "utf-8");
+        const filePath = path3.join(reviewsPath, file);
+        const content = await fs3.readFile(filePath, "utf-8");
         const { data: frontmatter, content: promptBody } = matter(content);
         const parsedFrontmatter = reviewPromptFrontmatterSchema.parse(frontmatter);
-        const name = path2.basename(file, ".md");
+        const name = path3.basename(file, ".md");
         const review = {
           name,
           prompt: file,
@@ -409,11 +720,11 @@ async function loadConfig(rootDir = process.cwd()) {
         }
         reviews[name] = review;
       } else if (file.endsWith(".yml") || file.endsWith(".yaml")) {
-        const filePath = path2.join(reviewsPath, file);
-        const content = await fs2.readFile(filePath, "utf-8");
+        const filePath = path3.join(reviewsPath, file);
+        const content = await fs3.readFile(filePath, "utf-8");
         const raw = YAML2.parse(content);
         const parsed = reviewYamlSchema.parse(raw);
-        const name = path2.basename(file, path2.extname(file));
+        const name = path3.basename(file, path3.extname(file));
         const review = {
           name,
           prompt: file,
@@ -476,33 +787,33 @@ async function loadConfig(rootDir = process.cwd()) {
 }
 async function loadPromptFile(filePath, gauntletPath, source) {
   let resolvedPath;
-  if (path2.isAbsolute(filePath)) {
+  if (path3.isAbsolute(filePath)) {
     console.warn(`Warning: ${source} uses absolute path "${filePath}". Prefer relative paths for portability.`);
     resolvedPath = filePath;
   } else {
-    resolvedPath = path2.resolve(gauntletPath, filePath);
+    resolvedPath = path3.resolve(gauntletPath, filePath);
   }
-  const normalizedGauntletPath = path2.resolve(gauntletPath);
-  const relativeToDotGauntlet = path2.relative(normalizedGauntletPath, resolvedPath);
-  if (relativeToDotGauntlet.startsWith("..") || path2.isAbsolute(relativeToDotGauntlet)) {
+  const normalizedGauntletPath = path3.resolve(gauntletPath);
+  const relativeToDotGauntlet = path3.relative(normalizedGauntletPath, resolvedPath);
+  if (relativeToDotGauntlet.startsWith("..") || path3.isAbsolute(relativeToDotGauntlet)) {
     console.warn(`Warning: ${source} references file outside .gauntlet/ directory: "${filePath}" (resolves to ${resolvedPath}). Review .gauntlet/ config changes carefully in PRs.`);
   }
   if (!await fileExists(resolvedPath)) {
     throw new Error(`File not found: ${resolvedPath} (referenced by ${source})`);
   }
-  return fs2.readFile(resolvedPath, "utf-8");
+  return fs3.readFile(resolvedPath, "utf-8");
 }
-async function fileExists(path3) {
+async function fileExists(path4) {
   try {
-    const stat = await fs2.stat(path3);
+    const stat = await fs3.stat(path4);
     return stat.isFile();
   } catch {
     return false;
   }
 }
-async function dirExists(path3) {
+async function dirExists(path4) {
   try {
-    const stat = await fs2.stat(path3);
+    const stat = await fs3.stat(path4);
     return stat.isDirectory();
   } catch {
     return false;
@@ -601,8 +912,8 @@ class ChangeDetector {
 }
 
 // src/core/entry-point.ts
-import fs3 from "node:fs/promises";
-import path3 from "node:path";
+import fs4 from "node:fs/promises";
+import path4 from "node:path";
 import picomatch from "picomatch";
 
 class EntryPointExpander {
@@ -695,15 +1006,15 @@ class EntryPointExpander {
       const relPath = file.slice(parentDir.length + 1);
       const subDirName = relPath.split("/")[0];
       if (subDirName) {
-        affectedSubDirs.add(path3.join(parentDir, subDirName));
+        affectedSubDirs.add(path4.join(parentDir, subDirName));
       }
     }
     return Array.from(affectedSubDirs);
   }
   async listSubDirectories(parentDir) {
     try {
-      const dirents = await fs3.readdir(parentDir, { withFileTypes: true });
-      return dirents.filter((d) => d.isDirectory()).map((d) => path3.join(parentDir, d.name));
+      const dirents = await fs4.readdir(parentDir, { withFileTypes: true });
+      return dirents.filter((d) => d.isDirectory()).map((d) => path4.join(parentDir, d.name));
     } catch {
       return [];
     }
@@ -905,25 +1216,25 @@ ${config.fixInstructionsContent}
 
 // src/gates/review.ts
 import { exec as exec8 } from "node:child_process";
-import fs16 from "node:fs/promises";
-import path15 from "node:path";
+import fs17 from "node:fs/promises";
+import path16 from "node:path";
 import { promisify as promisify9 } from "node:util";
 
 // src/cli-adapters/index.ts
 import { spawn as spawn2 } from "node:child_process";
-import fs15 from "node:fs/promises";
+import fs16 from "node:fs/promises";
 
 // src/cli-adapters/claude.ts
 import { exec as exec3 } from "node:child_process";
-import fs10 from "node:fs/promises";
+import fs11 from "node:fs/promises";
 import os2 from "node:os";
-import path10 from "node:path";
+import path11 from "node:path";
 import { promisify as promisify4 } from "node:util";
 
 // src/commands/stop-hook.ts
 import fsSync from "node:fs";
-import fs9 from "node:fs/promises";
-import path9 from "node:path";
+import fs10 from "node:fs/promises";
+import path10 from "node:path";
 
 // src/hooks/adapters/claude-stop-hook.ts
 class ClaudeStopHookAdapter {
@@ -1017,8 +1328,8 @@ class CursorStopHookAdapter {
 
 // src/hooks/stop-hook-handler.ts
 import { execFile } from "node:child_process";
-import fs8 from "node:fs/promises";
-import path8 from "node:path";
+import fs9 from "node:fs/promises";
+import path9 from "node:path";
 import { promisify as promisify3 } from "node:util";
 import YAML3 from "yaml";
 
@@ -1077,9 +1388,9 @@ function resolveStopHookConfig(projectConfig, globalConfig) {
 }
 
 // src/output/app-logger.ts
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 import fsPromises from "node:fs/promises";
-import path4 from "node:path";
+import path5 from "node:path";
 import {
   configure,
   getLogger
@@ -1137,8 +1448,8 @@ function safeStringify2(value) {
   }
 }
 function createDebugLogSink(logDir) {
-  const debugLogPath = path4.join(logDir, ".debug.log");
-  debugLogFd = fs4.openSync(debugLogPath, fs4.constants.O_WRONLY | fs4.constants.O_CREAT | fs4.constants.O_APPEND);
+  const debugLogPath = path5.join(logDir, ".debug.log");
+  debugLogFd = fs5.openSync(debugLogPath, fs5.constants.O_WRONLY | fs5.constants.O_CREAT | fs5.constants.O_APPEND);
   return (record) => {
     if (debugLogFd === null)
       return;
@@ -1149,7 +1460,7 @@ function createDebugLogSink(logDir) {
     const line = `[${timestamp}] ${level} [${category}] ${message}
 `;
     try {
-      fs4.writeSync(debugLogFd, line);
+      fs5.writeSync(debugLogFd, line);
     } catch {}
   };
 }
@@ -1192,7 +1503,7 @@ async function initLogger(config) {
   } catch (error) {
     if (debugLogFd !== null) {
       try {
-        fs4.closeSync(debugLogFd);
+        fs5.closeSync(debugLogFd);
       } catch {}
       debugLogFd = null;
     }
@@ -1202,7 +1513,7 @@ async function initLogger(config) {
 async function resetLogger() {
   if (debugLogFd !== null) {
     try {
-      fs4.closeSync(debugLogFd);
+      fs5.closeSync(debugLogFd);
     } catch {}
     debugLogFd = null;
   }
@@ -1227,17 +1538,17 @@ function isLoggerConfigured() {
 }
 
 // src/hooks/stop-hook-state.ts
-import fs7 from "node:fs/promises";
-import path7 from "node:path";
+import fs8 from "node:fs/promises";
+import path8 from "node:path";
 
 // src/utils/execution-state.ts
 import { spawn } from "node:child_process";
-import fs6 from "node:fs/promises";
-import path6 from "node:path";
+import fs7 from "node:fs/promises";
+import path7 from "node:path";
 
 // src/utils/debug-log.ts
-import fs5 from "node:fs/promises";
-import path5 from "node:path";
+import fs6 from "node:fs/promises";
+import path6 from "node:path";
 var DEBUG_LOG_FILENAME = ".debug.log";
 var DEBUG_LOG_BACKUP_FILENAME = ".debug.log.1";
 function getDebugLogFilename() {
@@ -1254,8 +1565,8 @@ class DebugLogger {
   enabled;
   runStartTime;
   constructor(logDir, config) {
-    this.logPath = path5.join(logDir, DEBUG_LOG_FILENAME);
-    this.backupPath = path5.join(logDir, DEBUG_LOG_BACKUP_FILENAME);
+    this.logPath = path6.join(logDir, DEBUG_LOG_FILENAME);
+    this.backupPath = path6.join(logDir, DEBUG_LOG_BACKUP_FILENAME);
     this.maxSizeBytes = config.maxSizeMb * 1024 * 1024;
     this.enabled = config.enabled;
   }
@@ -1358,18 +1669,18 @@ class DebugLogger {
 `;
     try {
       await this.rotateIfNeeded();
-      await fs5.mkdir(path5.dirname(this.logPath), { recursive: true });
-      await fs5.appendFile(this.logPath, entry, "utf-8");
+      await fs6.mkdir(path6.dirname(this.logPath), { recursive: true });
+      await fs6.appendFile(this.logPath, entry, "utf-8");
     } catch {}
   }
   async rotateIfNeeded() {
     try {
-      const stat = await fs5.stat(this.logPath);
+      const stat = await fs6.stat(this.logPath);
       if (stat.size >= this.maxSizeBytes) {
         try {
-          await fs5.rm(this.backupPath, { force: true });
+          await fs6.rm(this.backupPath, { force: true });
         } catch {}
-        await fs5.rename(this.logPath, this.backupPath);
+        await fs6.rename(this.logPath, this.backupPath);
       }
     } catch {}
   }
@@ -1427,8 +1738,8 @@ function isValidStateData(data) {
 }
 async function readExecutionState(logDir) {
   try {
-    const statePath = path6.join(logDir, EXECUTION_STATE_FILENAME);
-    const content = await fs6.readFile(statePath, "utf-8");
+    const statePath = path7.join(logDir, EXECUTION_STATE_FILENAME);
+    const content = await fs7.readFile(statePath, "utf-8");
     const data = JSON.parse(content);
     if (!isValidStateData(data))
       return null;
@@ -1483,7 +1794,7 @@ async function createWorkingTreeRef() {
   });
 }
 async function writeExecutionState(logDir) {
-  const statePath = path6.join(logDir, EXECUTION_STATE_FILENAME);
+  const statePath = path7.join(logDir, EXECUTION_STATE_FILENAME);
   const [branch, commit, workingTreeRef, rawState] = await Promise.all([
     getCurrentBranch(),
     getCurrentCommit(),
@@ -1515,11 +1826,11 @@ async function writeExecutionState(logDir) {
     changes.working_tree_ref = workingTreeRef;
   }
   await getDebugLogger()?.logStateWrite(changes);
-  await fs6.mkdir(logDir, { recursive: true });
-  await fs6.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
+  await fs7.mkdir(logDir, { recursive: true });
+  await fs7.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
   try {
-    const sessionRefPath = path6.join(logDir, SESSION_REF_FILENAME);
-    await fs6.rm(sessionRefPath, { force: true });
+    const sessionRefPath = path7.join(logDir, SESSION_REF_FILENAME);
+    await fs7.rm(sessionRefPath, { force: true });
   } catch {}
 }
 async function getCurrentBranch() {
@@ -1650,13 +1961,13 @@ function isAdapterCoolingDown(entry) {
   return Date.now() - markedAt < COOLDOWN_MS;
 }
 async function getUnhealthyAdapters(logDir) {
-  const statePath = path6.join(logDir, EXECUTION_STATE_FILENAME);
+  const statePath = path7.join(logDir, EXECUTION_STATE_FILENAME);
   const rawState = await readRawState(statePath);
   return extractUnhealthyAdapters(rawState) ?? {};
 }
 async function readRawState(statePath) {
   try {
-    const content = await fs6.readFile(statePath, "utf-8");
+    const content = await fs7.readFile(statePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -1664,7 +1975,7 @@ async function readRawState(statePath) {
 }
 async function markAdapterUnhealthy(logDir, adapterName, reason) {
   await getDebugLogger()?.logAdapterHealthChange(adapterName, false, reason);
-  const statePath = path6.join(logDir, EXECUTION_STATE_FILENAME);
+  const statePath = path7.join(logDir, EXECUTION_STATE_FILENAME);
   const rawData = await readRawState(statePath) ?? {};
   const adapters = rawData.unhealthy_adapters ?? {};
   adapters[adapterName] = {
@@ -1672,12 +1983,12 @@ async function markAdapterUnhealthy(logDir, adapterName, reason) {
     reason
   };
   rawData.unhealthy_adapters = adapters;
-  await fs6.mkdir(logDir, { recursive: true });
-  await fs6.writeFile(statePath, JSON.stringify(rawData, null, 2), "utf-8");
+  await fs7.mkdir(logDir, { recursive: true });
+  await fs7.writeFile(statePath, JSON.stringify(rawData, null, 2), "utf-8");
 }
 async function markAdapterHealthy(logDir, adapterName) {
   await getDebugLogger()?.logAdapterHealthChange(adapterName, true);
-  const statePath = path6.join(logDir, EXECUTION_STATE_FILENAME);
+  const statePath = path7.join(logDir, EXECUTION_STATE_FILENAME);
   const rawData = await readRawState(statePath);
   if (!rawData)
     return;
@@ -1690,13 +2001,13 @@ async function markAdapterHealthy(logDir, adapterName) {
   } else {
     rawData.unhealthy_adapters = adapters;
   }
-  await fs6.writeFile(statePath, JSON.stringify(rawData, null, 2), "utf-8");
+  await fs7.writeFile(statePath, JSON.stringify(rawData, null, 2), "utf-8");
 }
 async function deleteExecutionState(logDir) {
   try {
     await getDebugLogger()?.logStateDelete();
-    const statePath = path6.join(logDir, EXECUTION_STATE_FILENAME);
-    await fs6.rm(statePath, { force: true });
+    const statePath = path7.join(logDir, EXECUTION_STATE_FILENAME);
+    await fs7.rm(statePath, { force: true });
   } catch {}
 }
 
@@ -1708,14 +2019,14 @@ var BLOCK_TIMESTAMPS_LOCK = ".block-timestamps.lock";
 var LOCK_TIMEOUT_MS = 2000;
 var LOCK_RETRY_MS = 50;
 async function acquireTimestampLock(logDir) {
-  const lockPath = path7.join(logDir, BLOCK_TIMESTAMPS_LOCK);
+  const lockPath = path8.join(logDir, BLOCK_TIMESTAMPS_LOCK);
   const deadline = Date.now() + LOCK_TIMEOUT_MS;
   while (Date.now() < deadline) {
     try {
-      const handle = await fs7.open(lockPath, "wx");
+      const handle = await fs8.open(lockPath, "wx");
       await handle.close();
       return async () => {
-        await fs7.rm(lockPath, { force: true }).catch(() => {});
+        await fs8.rm(lockPath, { force: true }).catch(() => {});
       };
     } catch (err) {
       const code = err.code;
@@ -1728,7 +2039,7 @@ async function acquireTimestampLock(logDir) {
 }
 async function hasFailedRunLogs(logDir) {
   try {
-    const entries = await fs7.readdir(logDir);
+    const entries = await fs8.readdir(logDir);
     return entries.some((f) => (f.endsWith(".log") || f.endsWith(".json")) && f !== "previous" && !f.startsWith("console.") && !f.startsWith("."));
   } catch {
     return false;
@@ -1777,8 +2088,8 @@ async function getLastRunStatus(logDir) {
 }
 async function readBlockTimestamps(logDir) {
   try {
-    const filePath = path7.join(logDir, BLOCK_TIMESTAMPS_FILE);
-    const content = await fs7.readFile(filePath, "utf-8");
+    const filePath = path8.join(logDir, BLOCK_TIMESTAMPS_FILE);
+    const content = await fs8.readFile(filePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!Array.isArray(parsed))
       return [];
@@ -1794,8 +2105,8 @@ async function recordBlockTimestamp(logDir) {
     const existing = await readBlockTimestamps(logDir);
     const recent = existing.filter((ts) => now - ts < LOOP_WINDOW_MS);
     recent.push(now);
-    const filePath = path7.join(logDir, BLOCK_TIMESTAMPS_FILE);
-    await fs7.writeFile(filePath, JSON.stringify(recent), "utf-8");
+    const filePath = path8.join(logDir, BLOCK_TIMESTAMPS_FILE);
+    await fs8.writeFile(filePath, JSON.stringify(recent), "utf-8");
     return recent;
   } finally {
     await release();
@@ -1803,8 +2114,8 @@ async function recordBlockTimestamp(logDir) {
 }
 async function resetBlockTimestamps(logDir) {
   try {
-    const filePath = path7.join(logDir, BLOCK_TIMESTAMPS_FILE);
-    await fs7.rm(filePath, { force: true });
+    const filePath = path8.join(logDir, BLOCK_TIMESTAMPS_FILE);
+    await fs8.rm(filePath, { force: true });
   } catch {}
 }
 
@@ -1820,8 +2131,8 @@ var SKILL_INSTRUCTIONS = {
 };
 async function readProjectConfig(projectCwd) {
   try {
-    const configPath = path8.join(projectCwd, ".gauntlet", "config.yml");
-    const content = await fs8.readFile(configPath, "utf-8");
+    const configPath = path9.join(projectCwd, ".gauntlet", "config.yml");
+    const content = await fs9.readFile(configPath, "utf-8");
     return YAML3.parse(content);
   } catch {
     return;
@@ -1858,7 +2169,7 @@ function getStatusMessage(status, context) {
   }
   return STATUS_MESSAGES[status] ?? `Unknown status: ${status}`;
 }
-async function getLogDir(projectCwd) {
+async function getLogDir2(projectCwd) {
   const config = await readProjectConfig(projectCwd);
   return config?.log_dir || DEFAULT_LOG_DIR;
 }
@@ -1868,8 +2179,8 @@ async function getDebugLogConfig(projectCwd) {
 }
 async function getResolvedStopHookConfig(projectCwd) {
   try {
-    const configPath = path8.join(projectCwd, ".gauntlet", "config.yml");
-    const content = await fs8.readFile(configPath, "utf-8");
+    const configPath = path9.join(projectCwd, ".gauntlet", "config.yml");
+    const content = await fs9.readFile(configPath, "utf-8");
     const raw = YAML3.parse(content);
     const projectStopHookConfig = raw?.stop_hook;
     const globalConfig = await loadGlobalConfig();
@@ -2126,7 +2437,7 @@ async function readStdin() {
 }
 async function fileExists2(filePath) {
   try {
-    await fs9.stat(filePath);
+    await fs10.stat(filePath);
     return true;
   } catch {
     return false;
@@ -2203,12 +2514,12 @@ function registerStopHookCommand(program) {
         outputResult(adapter, createEarlyExitResult("stop_hook_active"));
         return;
       }
-      const quickConfigCheck = path9.join(process.cwd(), ".gauntlet", "config.yml");
+      const quickConfigCheck = path10.join(process.cwd(), ".gauntlet", "config.yml");
       if (!await fileExists2(quickConfigCheck)) {
         outputResult(adapter, createEarlyExitResult("no_config"));
         return;
       }
-      const earlyLogDir = path9.join(process.cwd(), await getLogDir(process.cwd()));
+      const earlyLogDir = path10.join(process.cwd(), await getLogDir2(process.cwd()));
       try {
         const globalConfig = await loadGlobalConfig();
         const projectDebugLogConfig = await getDebugLogConfig(process.cwd());
@@ -2218,16 +2529,16 @@ function registerStopHookCommand(program) {
         log.warn(`Debug logger init failed: ${initErr.message ?? "unknown"}`);
       }
       await debugLogger?.logCommand("stop-hook", []);
-      const markerLogDir = await getLogDir(process.cwd());
-      const markerPath = path9.join(process.cwd(), markerLogDir, STOP_HOOK_MARKER_FILE);
+      const markerLogDir = await getLogDir2(process.cwd());
+      const markerPath = path10.join(process.cwd(), markerLogDir, STOP_HOOK_MARKER_FILE);
       if (await fileExists2(markerPath)) {
         const STALE_MARKER_MS = 10 * 60 * 1000;
         try {
-          const stat = await fs9.stat(markerPath);
+          const stat = await fs10.stat(markerPath);
           const ageMs = Date.now() - stat.mtimeMs;
           if (ageMs > STALE_MARKER_MS) {
             await debugLogger?.logStopHookEarlyExit("marker_stale", "proceeding", `age=${Math.round(ageMs / 1000)}s threshold=${Math.round(STALE_MARKER_MS / 1000)}s`);
-            await fs9.rm(markerPath, { force: true });
+            await fs10.rm(markerPath, { force: true });
           } else {
             await debugLogger?.logStopHookEarlyExit("marker_fresh", "stop_hook_active", `age=${Math.round(ageMs / 1000)}s`);
             outputResult(adapter, createEarlyExitResult("stop_hook_active"));
@@ -2269,7 +2580,7 @@ function registerStopHookCommand(program) {
       log.info("Starting gauntlet validation...");
       const projectCwd = ctx.cwd;
       if (ctx.cwd !== process.cwd()) {
-        const configPath = path9.join(projectCwd, ".gauntlet", "config.yml");
+        const configPath = path10.join(projectCwd, ".gauntlet", "config.yml");
         if (!await fileExists2(configPath)) {
           log.info("No gauntlet config found at hook cwd, allowing stop");
           await debugLogger?.logStopHookEarlyExit("no_config_at_cwd", "no_config", `cwd=${projectCwd}`);
@@ -2277,7 +2588,7 @@ function registerStopHookCommand(program) {
           return;
         }
       }
-      const logDir = path9.join(projectCwd, await getLogDir(projectCwd));
+      const logDir = path10.join(projectCwd, await getLogDir2(projectCwd));
       await initLogger({
         mode: "stop-hook",
         logDir
@@ -2294,9 +2605,9 @@ function registerStopHookCommand(program) {
         }
       }
       await debugLogger?.logStopHookDiagnostics(diagnostics);
-      markerFilePath = path9.join(logDir, STOP_HOOK_MARKER_FILE);
+      markerFilePath = path10.join(logDir, STOP_HOOK_MARKER_FILE);
       try {
-        await fs9.writeFile(markerFilePath, `${process.pid}`, "utf-8");
+        await fs10.writeFile(markerFilePath, `${process.pid}`, "utf-8");
       } catch (mkErr) {
         const errMsg = mkErr.message ?? "unknown";
         log.warn(`Failed to create marker file: ${errMsg}`);
@@ -2311,7 +2622,7 @@ function registerStopHookCommand(program) {
       } finally {
         if (markerFilePath) {
           try {
-            await fs9.rm(markerFilePath, { force: true });
+            await fs10.rm(markerFilePath, { force: true });
           } catch (rmErr) {
             const errMsg = rmErr.message ?? "unknown";
             log.warn(`Failed to remove marker file: ${errMsg}`);
@@ -2337,7 +2648,7 @@ function registerStopHookCommand(program) {
       outputResult(adapter, createEarlyExitResult("error", { errorMessage }));
       if (markerFilePath) {
         try {
-          await fs9.rm(markerFilePath, { force: true });
+          await fs10.rm(markerFilePath, { force: true });
         } catch (rmErr) {
           const rmMsg = rmErr.message ?? "unknown";
           log.warn(`Failed to remove marker file in error handler: ${rmMsg}`);
@@ -2539,13 +2850,13 @@ class ClaudeAdapter {
     return ".claude/commands";
   }
   getUserCommandDir() {
-    return path10.join(os2.homedir(), ".claude", "commands");
+    return path11.join(os2.homedir(), ".claude", "commands");
   }
   getProjectSkillDir() {
     return ".claude/skills";
   }
   getUserSkillDir() {
-    return path10.join(os2.homedir(), ".claude", "skills");
+    return path11.join(os2.homedir(), ".claude", "skills");
   }
   getCommandExtension() {
     return ".md";
@@ -2564,24 +2875,24 @@ class ClaudeAdapter {
 
 --- DIFF ---
 ${opts.diff}`;
-    const tmpDir = os2.tmpdir();
-    const tmpFile = path10.join(tmpDir, `gauntlet-claude-${process.pid}-${Date.now()}.txt`);
-    await fs10.writeFile(tmpFile, fullContent);
+    const tmpFile = path11.join(os2.tmpdir(), `gauntlet-claude-${process.pid}-${Date.now()}.txt`);
+    await fs11.writeFile(tmpFile, fullContent);
     const args = ["-p"];
     if (opts.allowToolUse === false) {
-      args.push("--tools", "");
+      args.push("--allowedTools", "Task");
     } else {
-      args.push("--allowedTools", "Read,Glob,Grep");
+      args.push("--allowedTools", "Read,Glob,Grep,Task");
     }
-    args.push("--max-turns", "10");
+    args.push("--max-turns", "25");
     const otelEnv = buildOtelEnv();
     const thinkingEnv = {};
     if (opts.thinkingBudget && opts.thinkingBudget in CLAUDE_THINKING_TOKENS) {
       thinkingEnv.MAX_THINKING_TOKENS = String(CLAUDE_THINKING_TOKENS[opts.thinkingBudget]);
     }
-    const cleanup = () => fs10.unlink(tmpFile).catch(() => {});
+    const cleanup = () => fs11.unlink(tmpFile).catch(() => {});
+    const { CLAUDECODE: _, ...parentEnv } = process.env;
     const execEnv = {
-      ...process.env,
+      ...parentEnv,
       [GAUNTLET_STOP_HOOK_ACTIVE_ENV]: "1",
       ...otelEnv,
       ...thinkingEnv
@@ -2619,9 +2930,9 @@ ${opts.diff}`;
 
 // src/cli-adapters/codex.ts
 import { exec as exec4 } from "node:child_process";
-import fs11 from "node:fs/promises";
+import fs12 from "node:fs/promises";
 import os3 from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 import { promisify as promisify5 } from "node:util";
 var execAsync4 = promisify5(exec4);
 var MAX_BUFFER_BYTES3 = 10 * 1024 * 1024;
@@ -2741,7 +3052,7 @@ class CodexAdapter {
     return null;
   }
   getUserCommandDir() {
-    return path11.join(os3.homedir(), ".codex", "prompts");
+    return path12.join(os3.homedir(), ".codex", "prompts");
   }
   getProjectSkillDir() {
     return null;
@@ -2787,10 +3098,10 @@ class CodexAdapter {
 --- DIFF ---
 ${opts.diff}`;
     const tmpDir = os3.tmpdir();
-    const tmpFile = path11.join(tmpDir, `gauntlet-codex-${Date.now()}.txt`);
-    await fs11.writeFile(tmpFile, fullContent);
+    const tmpFile = path12.join(tmpDir, `gauntlet-codex-${Date.now()}.txt`);
+    await fs12.writeFile(tmpFile, fullContent);
     const args = this.buildArgs(opts.allowToolUse, opts.thinkingBudget);
-    const cleanup = () => fs11.unlink(tmpFile).catch(() => {});
+    const cleanup = () => fs12.unlink(tmpFile).catch(() => {});
     if (opts.onOutput) {
       const raw = await runStreamingCommand({
         command: "codex",
@@ -2822,12 +3133,58 @@ ${opts.diff}`;
 
 // src/cli-adapters/cursor.ts
 import { exec as exec5 } from "node:child_process";
-import fs12 from "node:fs/promises";
+import fs13 from "node:fs/promises";
 import os4 from "node:os";
-import path12 from "node:path";
+import path13 from "node:path";
 import { promisify as promisify6 } from "node:util";
+
+// src/cli-adapters/model-resolution.ts
+var TIER_SUFFIXES = ["-low", "-high", "-xhigh", "-fast"];
+var SAFE_MODEL_ID_PATTERN = /^[a-zA-Z0-9._-]+$/;
+function applyThinkingFilter(candidates, preferThinking) {
+  if (preferThinking) {
+    const thinking = candidates.filter((id) => id.endsWith("-thinking"));
+    return thinking.length > 0 ? thinking : candidates;
+  }
+  return candidates.filter((id) => !id.endsWith("-thinking"));
+}
+function compareVersionsDesc(a, b) {
+  if (!a && !b)
+    return 0;
+  if (!a)
+    return 1;
+  if (!b)
+    return -1;
+  if (a[0] !== b[0])
+    return b[0] - a[0];
+  return b[1] - a[1];
+}
+function resolveModelFromList(allModels, opts) {
+  const candidates = allModels.filter((id) => id.split("-").includes(opts.baseName)).filter((id) => !TIER_SUFFIXES.some((s) => id.endsWith(s)));
+  if (candidates.length === 0)
+    return;
+  const filtered = applyThinkingFilter(candidates, opts.preferThinking);
+  if (filtered.length === 0)
+    return;
+  filtered.sort((a, b) => {
+    const vA = a.match(/(\d+)\.(\d+)/);
+    const vB = b.match(/(\d+)\.(\d+)/);
+    return compareVersionsDesc(vA ? [Number(vA[1]), Number(vA[2])] : null, vB ? [Number(vB[1]), Number(vB[2])] : null);
+  });
+  return filtered[0];
+}
+
+// src/cli-adapters/cursor.ts
 var execAsync5 = promisify6(exec5);
 var MAX_BUFFER_BYTES4 = 10 * 1024 * 1024;
+var log = getCategoryLogger("cursor");
+function parseModelList(output) {
+  return output.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => {
+    const dashIndex = line.indexOf(" - ");
+    return dashIndex >= 0 ? line.substring(0, dashIndex).trim() : line.trim();
+  }).filter((id) => id.length > 0);
+}
 
 class CursorAdapter {
   name = "cursor";
@@ -2874,19 +3231,57 @@ class CursorAdapter {
   supportsHooks() {
     return true;
   }
+  async resolveModel(baseName, thinkingBudget) {
+    try {
+      const stdout = await new Promise((resolve, reject) => {
+        exec5("agent --list-models", { timeout: 1e4 }, (error, stdout2) => {
+          if (error)
+            reject(error);
+          else
+            resolve(stdout2);
+        });
+      });
+      const models = parseModelList(stdout);
+      const preferThinking = thinkingBudget !== undefined && thinkingBudget !== "off";
+      const resolved = resolveModelFromList(models, {
+        baseName,
+        preferThinking
+      });
+      if (resolved === undefined) {
+        log.warn(`No matching model found for "${baseName}"`);
+        return;
+      }
+      if (!SAFE_MODEL_ID_PATTERN.test(resolved)) {
+        log.warn(`Resolved model "${resolved}" contains unsafe characters`);
+        return;
+      }
+      return resolved;
+    } catch (err) {
+      log.warn(`Failed to resolve model "${baseName}": ${err instanceof Error ? err.message : String(err)}`);
+      return;
+    }
+  }
   async execute(opts) {
     const fullContent = `${opts.prompt}
 
 --- DIFF ---
 ${opts.diff}`;
     const tmpDir = os4.tmpdir();
-    const tmpFile = path12.join(tmpDir, `gauntlet-cursor-${process.pid}-${Date.now()}.txt`);
-    await fs12.writeFile(tmpFile, fullContent);
-    const cleanup = () => fs12.unlink(tmpFile).catch(() => {});
+    const tmpFile = path13.join(tmpDir, `gauntlet-cursor-${process.pid}-${Date.now()}.txt`);
+    await fs13.writeFile(tmpFile, fullContent);
+    let resolvedModel;
+    if (opts.model) {
+      resolvedModel = await this.resolveModel(opts.model, opts.thinkingBudget);
+    }
+    const cleanup = () => fs13.unlink(tmpFile).catch(() => {});
+    const args = ["--trust"];
+    if (resolvedModel) {
+      args.push("--model", resolvedModel);
+    }
     if (opts.onOutput) {
       return runStreamingCommand({
         command: "agent",
-        args: [],
+        args,
         tmpFile,
         timeoutMs: opts.timeoutMs,
         onOutput: opts.onOutput,
@@ -2894,7 +3289,8 @@ ${opts.diff}`;
       });
     }
     try {
-      const cmd = `cat "${tmpFile}" | agent`;
+      const modelFlag = resolvedModel ? ` --model ${resolvedModel}` : "";
+      const cmd = `cat "${tmpFile}" | agent --trust${modelFlag}`;
       const { stdout } = await execAsync5(cmd, {
         timeout: opts.timeoutMs,
         maxBuffer: MAX_BUFFER_BYTES4
@@ -2908,9 +3304,9 @@ ${opts.diff}`;
 
 // src/cli-adapters/gemini.ts
 import { exec as exec6 } from "node:child_process";
-import fs13 from "node:fs/promises";
+import fs14 from "node:fs/promises";
 import os5 from "node:os";
-import path13 from "node:path";
+import path14 from "node:path";
 import { promisify as promisify7 } from "node:util";
 var execAsync6 = promisify7(exec6);
 var MAX_BUFFER_BYTES5 = 10 * 1024 * 1024;
@@ -3042,7 +3438,7 @@ async function parseGeminiTelemetry(filePath) {
   const usage = {};
   let content;
   try {
-    content = await fs13.readFile(filePath, "utf-8");
+    content = await fs14.readFile(filePath, "utf-8");
   } catch {
     return usage;
   }
@@ -3103,7 +3499,7 @@ class GeminiAdapter {
     return ".gemini/commands";
   }
   getUserCommandDir() {
-    return path13.join(os5.homedir(), ".gemini", "commands");
+    return path14.join(os5.homedir(), ".gemini", "commands");
   }
   getProjectSkillDir() {
     return null;
@@ -3160,12 +3556,12 @@ ${summary}
       releaseLock = resolve;
     });
     await prev;
-    const settingsPath = path13.join(process.cwd(), ".gemini", "settings.json");
+    const settingsPath = path14.join(process.cwd(), ".gemini", "settings.json");
     let backup = null;
     let existed = false;
     try {
       try {
-        backup = await fs13.readFile(settingsPath, "utf-8");
+        backup = await fs14.readFile(settingsPath, "utf-8");
         existed = true;
       } catch {}
       const existing = backup ? JSON.parse(backup) : {};
@@ -3173,8 +3569,8 @@ ${summary}
         ...existing,
         thinkingConfig: { ...existing.thinkingConfig, thinkingBudget: budget }
       };
-      await fs13.mkdir(path13.dirname(settingsPath), { recursive: true });
-      await fs13.writeFile(settingsPath, JSON.stringify(merged, null, 2));
+      await fs14.mkdir(path14.dirname(settingsPath), { recursive: true });
+      await fs14.writeFile(settingsPath, JSON.stringify(merged, null, 2));
     } catch (err) {
       releaseLock();
       throw err;
@@ -3182,9 +3578,9 @@ ${summary}
     return async () => {
       try {
         if (existed && backup !== null) {
-          await fs13.writeFile(settingsPath, backup);
+          await fs14.writeFile(settingsPath, backup);
         } else {
-          await fs13.unlink(settingsPath).catch(() => {});
+          await fs14.unlink(settingsPath).catch(() => {});
         }
       } finally {
         releaseLock();
@@ -3223,14 +3619,14 @@ ${summary}
 --- DIFF ---
 ${opts.diff}`;
     const tmpDir = os5.tmpdir();
-    const tmpFile = path13.join(tmpDir, `gauntlet-gemini-${process.pid}-${Date.now()}.txt`);
-    await fs13.writeFile(tmpFile, fullContent);
-    const telemetryFile = path13.join(process.cwd(), `.gauntlet-gemini-telemetry-${process.pid}-${Date.now()}.log`);
+    const tmpFile = path14.join(tmpDir, `gauntlet-gemini-${process.pid}-${Date.now()}.txt`);
+    await fs14.writeFile(tmpFile, fullContent);
+    const telemetryFile = path14.join(process.cwd(), `.gauntlet-gemini-telemetry-${process.pid}-${Date.now()}.log`);
     const telemetryEnv = this.buildTelemetryEnv(telemetryFile);
     const args = this.buildArgs(opts.allowToolUse);
     const cleanupThinking = await this.maybeApplyThinking(opts.thinkingBudget);
-    const cleanup = () => fs13.unlink(tmpFile).catch(() => {});
-    const cleanupTelemetry = () => fs13.unlink(telemetryFile).catch(() => {});
+    const cleanup = () => fs14.unlink(tmpFile).catch(() => {});
+    const cleanupTelemetry = () => fs14.unlink(telemetryFile).catch(() => {});
     try {
       if (opts.onOutput) {
         try {
@@ -3270,12 +3666,19 @@ ${opts.diff}`;
 
 // src/cli-adapters/github-copilot.ts
 import { exec as exec7 } from "node:child_process";
-import fs14 from "node:fs/promises";
+import fs15 from "node:fs/promises";
 import os6 from "node:os";
-import path14 from "node:path";
+import path15 from "node:path";
 import { promisify as promisify8 } from "node:util";
 var execAsync7 = promisify8(exec7);
 var MAX_BUFFER_BYTES6 = 10 * 1024 * 1024;
+var log2 = getCategoryLogger("github-copilot");
+function parseCopilotModels(helpOutput) {
+  const match = helpOutput.match(/choices:\s*(.+?)\)/);
+  if (!match?.[1])
+    return [];
+  return [...match[1].matchAll(/"([^"]+)"/g)].map((m) => m[1]).filter((id) => id !== undefined);
+}
 
 class GitHubCopilotAdapter {
   name = "github-copilot";
@@ -3322,14 +3725,47 @@ class GitHubCopilotAdapter {
   supportsHooks() {
     return false;
   }
+  async resolveModel(baseName, _thinkingBudget) {
+    try {
+      const stdout = await new Promise((resolve, reject) => {
+        exec7("copilot --help", { timeout: 1e4 }, (error, stdout2) => {
+          if (error)
+            reject(error);
+          else
+            resolve(stdout2);
+        });
+      });
+      const models = parseCopilotModels(stdout);
+      const resolved = resolveModelFromList(models, {
+        baseName,
+        preferThinking: false
+      });
+      if (resolved === undefined) {
+        log2.warn(`No matching model found for "${baseName}"`);
+        return;
+      }
+      if (!SAFE_MODEL_ID_PATTERN.test(resolved)) {
+        log2.warn(`Resolved model "${resolved}" contains unsafe characters`);
+        return;
+      }
+      return resolved;
+    } catch (err) {
+      log2.warn(`Failed to resolve model "${baseName}": ${err instanceof Error ? err.message : String(err)}`);
+      return;
+    }
+  }
   async execute(opts) {
     const fullContent = `${opts.prompt}
 
 --- DIFF ---
 ${opts.diff}`;
     const tmpDir = os6.tmpdir();
-    const tmpFile = path14.join(tmpDir, `gauntlet-copilot-${process.pid}-${Date.now()}.txt`);
-    await fs14.writeFile(tmpFile, fullContent);
+    const tmpFile = path15.join(tmpDir, `gauntlet-copilot-${process.pid}-${Date.now()}.txt`);
+    await fs15.writeFile(tmpFile, fullContent);
+    let resolvedModel;
+    if (opts.model) {
+      resolvedModel = await this.resolveModel(opts.model, opts.thinkingBudget);
+    }
     const args = [
       "--allow-tool",
       "shell(cat)",
@@ -3344,7 +3780,10 @@ ${opts.diff}`;
       "--allow-tool",
       "shell(tail)"
     ];
-    const cleanup = () => fs14.unlink(tmpFile).catch(() => {});
+    if (resolvedModel) {
+      args.push("--model", resolvedModel);
+    }
+    const cleanup = () => fs15.unlink(tmpFile).catch(() => {});
     if (opts.onOutput) {
       return runStreamingCommand({
         command: "copilot",
@@ -3356,7 +3795,8 @@ ${opts.diff}`;
       });
     }
     try {
-      const cmd = `cat "${tmpFile}" | copilot --allow-tool "shell(cat)" --allow-tool "shell(grep)" --allow-tool "shell(ls)" --allow-tool "shell(find)" --allow-tool "shell(head)" --allow-tool "shell(tail)"`;
+      const modelFlag = resolvedModel ? ` --model ${resolvedModel}` : "";
+      const cmd = `cat "${tmpFile}" | copilot --allow-tool "shell(cat)" --allow-tool "shell(grep)" --allow-tool "shell(ls)" --allow-tool "shell(find)" --allow-tool "shell(head)" --allow-tool "shell(tail)"${modelFlag}`;
       const { stdout } = await execAsync7(cmd, {
         timeout: opts.timeoutMs,
         maxBuffer: MAX_BUFFER_BYTES6
@@ -3389,7 +3829,7 @@ ${output}` : ""}`);
 async function runStreamingCommand(opts) {
   return new Promise((resolve, reject) => {
     const chunks = [];
-    const inputStream = fs15.open(opts.tmpFile, "r").then((handle) => {
+    const inputStream = fs16.open(opts.tmpFile, "r").then((handle) => {
       const stream = handle.createReadStream();
       return { stream, handle };
     });
@@ -3554,7 +3994,7 @@ function isValidViolationLocation(file, line, diffRanges) {
 }
 
 // src/gates/review.ts
-var log = getCategoryLogger("gate", "review");
+var log3 = getCategoryLogger("gate", "review");
 var execAsync8 = promisify9(exec8);
 var MAX_BUFFER_BYTES7 = 10 * 1024 * 1024;
 var MAX_LOG_BUFFER_SIZE = 1e4;
@@ -3646,7 +4086,7 @@ ${JSON_SYSTEM_INSTRUCTION}`;
       return logger;
     };
     try {
-      log.debug(`Starting review: ${config.name} | entry=${entryPointPath}`);
+      log3.debug(`Starting review: ${config.name} | entry=${entryPointPath}`);
       await mainLogger(`Starting review: ${config.name}
 `);
       await mainLogger(`Entry point: ${entryPointPath}
@@ -3661,11 +4101,11 @@ ${JSON_SYSTEM_INSTRUCTION}`;
       const diffFileRanges = parseDiff(diff);
       const diffFiles = diffFileRanges.size;
       const diffSizeMsg = `[diff-stats] files=${diffFiles} lines=${diffLines} chars=${diffChars} est_tokens=${diffEstTokens}`;
-      log.debug(diffSizeMsg);
+      log3.debug(diffSizeMsg);
       await mainLogger(`${diffSizeMsg}
 `);
       if (!diff.trim()) {
-        log.debug(`Empty diff after trim, returning pass`);
+        log3.debug(`Empty diff after trim, returning pass`);
         await mainLogger(`No changes found in entry point, skipping review.
 `);
         await mainLogger(`Result: pass - No changes to review
@@ -3682,31 +4122,31 @@ ${JSON_SYSTEM_INSTRUCTION}`;
       const outputs = [];
       const preferences = config.cli_preference || [];
       const parallel = config.parallel ?? false;
-      log.debug(`Checking adapters: ${preferences.join(", ") || "(none configured)"}`);
+      log3.debug(`Checking adapters: ${preferences.join(", ") || "(none configured)"}`);
       const healthyAdapters = [];
       const unhealthyMap = logDir ? await getUnhealthyAdapters(logDir) : {};
       for (const toolName of preferences) {
         const adapter = getAdapter(toolName);
         if (!adapter) {
-          log.debug(`Adapter ${toolName}: not found`);
+          log3.debug(`Adapter ${toolName}: not found`);
           continue;
         }
         const unhealthyEntry = unhealthyMap[toolName];
         if (unhealthyEntry) {
           if (isAdapterCoolingDown(unhealthyEntry)) {
-            log.debug(`Adapter ${toolName}: cooling down`);
+            log3.debug(`Adapter ${toolName}: cooling down`);
             await mainLogger(`Skipping ${toolName}: cooling down (${unhealthyEntry.reason})
 `);
             continue;
           }
           const health = await adapter.checkHealth();
           if (health.status === "healthy") {
-            log.debug(`Adapter ${toolName}: cooldown expired, binary available, clearing unhealthy flag`);
+            log3.debug(`Adapter ${toolName}: cooldown expired, binary available, clearing unhealthy flag`);
             if (logDir) {
               await markAdapterHealthy(logDir, toolName);
             }
           } else {
-            log.debug(`Adapter ${toolName}: cooldown expired but binary missing`);
+            log3.debug(`Adapter ${toolName}: cooldown expired but binary missing`);
             await mainLogger(`Skipping ${toolName}: ${health.message || "Missing"}
 `);
             continue;
@@ -3714,7 +4154,7 @@ ${JSON_SYSTEM_INSTRUCTION}`;
         } else {
           const health = await adapter.checkHealth();
           if (health.status !== "healthy") {
-            log.debug(`Adapter ${toolName}: ${health.status}${health.message ? ` - ${health.message}` : ""}`);
+            log3.debug(`Adapter ${toolName}: ${health.status}${health.message ? ` - ${health.message}` : ""}`);
             await mainLogger(`Skipping ${toolName}: ${health.message || "Unhealthy"}
 `);
             continue;
@@ -3724,7 +4164,7 @@ ${JSON_SYSTEM_INSTRUCTION}`;
       }
       if (healthyAdapters.length === 0) {
         const msg = "Review dispatch failed: no healthy adapters available";
-        log.error(`ERROR: ${msg}`);
+        log3.error(`ERROR: ${msg}`);
         await mainLogger(`Result: error - ${msg}
 `);
         return {
@@ -3735,7 +4175,7 @@ ${JSON_SYSTEM_INSTRUCTION}`;
           logPaths
         };
       }
-      log.debug(`Healthy adapters: ${healthyAdapters.join(", ")}`);
+      log3.debug(`Healthy adapters: ${healthyAdapters.join(", ")}`);
       const assignments = [];
       for (let i = 0;i < required; i++) {
         const adapter = healthyAdapters[i % healthyAdapters.length];
@@ -3785,12 +4225,12 @@ ${JSON_SYSTEM_INSTRUCTION}`;
         }
       }
       const dispatchMsg = `Dispatching ${required} review(s) via round-robin: ${assignments.map((a) => `${a.adapter}@${a.reviewIndex}`).join(", ")}`;
-      log.debug(dispatchMsg);
+      log3.debug(dispatchMsg);
       await mainLogger(`${dispatchMsg}
 `);
       const runningAssignments = assignments.filter((a) => !a.skip);
       const skippedAssignments = assignments.filter((a) => a.skip);
-      log.debug(`Running: ${runningAssignments.length}, Skipped: ${skippedAssignments.length}`);
+      log3.debug(`Running: ${runningAssignments.length}, Skipped: ${skippedAssignments.length}`);
       const skippedSlotOutputs = [];
       for (const assignment of skippedAssignments) {
         const { logger, logPath } = await loggerFactory(assignment.adapter, assignment.reviewIndex);
@@ -3812,7 +4252,7 @@ ${JSON_SYSTEM_INSTRUCTION}`;
           violations: [],
           passIteration: assignment.passIteration
         };
-        await fs16.writeFile(jsonPath, JSON.stringify(skippedOutput, null, 2));
+        await fs17.writeFile(jsonPath, JSON.stringify(skippedOutput, null, 2));
         if (!logPathsSet.has(logPath)) {
           logPathsSet.add(logPath);
           logPaths.push(logPath);
@@ -3879,7 +4319,7 @@ ${JSON_SYSTEM_INSTRUCTION}`;
       }
       const subResults = outputs.map((out) => {
         const specificLog = logPaths.find((p) => {
-          const filename = path15.basename(p);
+          const filename = path16.basename(p);
           return filename.includes(`_${out.adapter}@${out.reviewIndex}.`) && filename.endsWith(".log");
         });
         let logPath = specificLog;
@@ -3901,7 +4341,7 @@ ${JSON_SYSTEM_INSTRUCTION}`;
       });
       for (const skipped of skippedSlotOutputs) {
         const specificLog = logPaths.find((p) => {
-          const filename = path15.basename(p);
+          const filename = path16.basename(p);
           return filename.includes(`_${skipped.adapter}@${skipped.reviewIndex}.`) && filename.endsWith(".log");
         });
         subResults.push({
@@ -3920,7 +4360,7 @@ ${JSON_SYSTEM_INSTRUCTION}`;
         const bIndex = parseInt(b.nameSuffix.match(/@(\d+)/)?.[1] || "0", 10);
         return aIndex - bIndex;
       });
-      log.debug(`Complete: ${status} - ${message}`);
+      log3.debug(`Complete: ${status} - ${message}`);
       await mainLogger(`Result: ${status} - ${message}
 `);
       return {
@@ -3936,7 +4376,7 @@ ${JSON_SYSTEM_INSTRUCTION}`;
       const err = error;
       const errMsg = err.message || "Unknown error";
       const errStack = err.stack || "";
-      log.error(`CRITICAL ERROR: ${errMsg} ${errStack}`);
+      log3.error(`CRITICAL ERROR: ${errMsg} ${errStack}`);
       await mainLogger(`Critical Error: ${errMsg}
 `);
       await mainLogger(`Result: error
@@ -3985,7 +4425,7 @@ ${diff}
       const output = await adapter.execute({
         prompt: finalPrompt,
         diff,
-        model: config.model,
+        model: adapterCfg?.model ?? config.model,
         timeoutMs: config.timeout ? config.timeout * 1000 : REVIEW_ADAPTER_TIMEOUT_MS,
         onOutput: (chunk) => {
           adapterLogger(chunk);
@@ -4002,7 +4442,7 @@ ${output}
         const reason = "Usage limit exceeded";
         if (logDir) {
           await markAdapterUnhealthy(logDir, adapter.name, reason);
-          log.debug(`Adapter ${adapter.name} marked unhealthy for 1 hour: ${reason}`);
+          log3.debug(`Adapter ${adapter.name} marked unhealthy for 1 hour: ${reason}`);
           await mainLogger(`${adapter.name} marked unhealthy for 1 hour: ${reason}
 `);
         }
@@ -4120,7 +4560,7 @@ ${output}
     } catch (error) {
       const err = error;
       const errorMsg = `Error running ${adapter.name}@${reviewIndex}: ${err.message}`;
-      log.error(errorMsg);
+      log3.error(errorMsg);
       await adapterLogger(`${errorMsg}
 `);
       await mainLogger(`${errorMsg}
@@ -4129,7 +4569,7 @@ ${output}
         const reason = "Usage limit exceeded";
         if (logDir) {
           await markAdapterUnhealthy(logDir, adapter.name, reason);
-          log.debug(`Adapter ${adapter.name} marked unhealthy for 1 hour: ${reason}`);
+          log3.debug(`Adapter ${adapter.name} marked unhealthy for 1 hour: ${reason}`);
           await mainLogger(`${adapter.name} marked unhealthy for 1 hour: ${reason}
 `);
         }
@@ -4147,7 +4587,7 @@ ${output}
     }
   }
   async getDiff(entryPointPath, baseBranch, options) {
-    log.debug(`getDiff: entryPoint=${entryPointPath}, fixBase=${options?.fixBase ?? "none"}, uncommitted=${options?.uncommitted ?? false}, commit=${options?.commit ?? "none"}`);
+    log3.debug(`getDiff: entryPoint=${entryPointPath}, fixBase=${options?.fixBase ?? "none"}, uncommitted=${options?.uncommitted ?? false}, commit=${options?.commit ?? "none"}`);
     if (options?.fixBase) {
       if (!/^[a-f0-9]+$/.test(options.fixBase)) {
         throw new Error(`Invalid session ref: ${options.fixBase}`);
@@ -4177,15 +4617,15 @@ ${output}
         }
         const scopedDiff = [diff, ...newUntrackedDiffs].filter(Boolean).join(`
 `);
-        log.debug(`Scoped diff via fixBase: ${scopedDiff.split(`
+        log3.debug(`Scoped diff via fixBase: ${scopedDiff.split(`
 `).length} lines`);
         return scopedDiff;
       } catch (error) {
-        log.warn(`Failed to compute diff against fixBase ${options.fixBase}, falling back to full uncommitted diff. ${error instanceof Error ? error.message : error}`);
+        log3.warn(`Failed to compute diff against fixBase ${options.fixBase}, falling back to full uncommitted diff. ${error instanceof Error ? error.message : error}`);
       }
     }
     if (options?.uncommitted) {
-      log.debug(`Using full uncommitted diff (no fixBase)`);
+      log3.debug(`Using full uncommitted diff (no fixBase)`);
       const pathArg = this.pathArg(entryPointPath);
       const staged = await this.execDiff(`git diff --cached${pathArg}`);
       const unstaged = await this.execDiff(`git diff${pathArg}`);
@@ -4411,7 +4851,7 @@ The following violations were NOT marked as fixed or skipped and are still activ
       rawOutput,
       violations: json.violations || []
     };
-    await fs16.writeFile(jsonPath, JSON.stringify(fullOutput, null, 2));
+    await fs17.writeFile(jsonPath, JSON.stringify(fullOutput, null, 2));
     return jsonPath;
   }
   parseLines(stdout) {
@@ -4597,13 +5037,13 @@ class Runner {
 }
 
 // src/output/console.ts
-import fs18 from "node:fs/promises";
+import fs19 from "node:fs/promises";
 import chalk2 from "chalk";
 
 // src/utils/log-parser.ts
-import fs17 from "node:fs/promises";
-import path16 from "node:path";
-var log2 = getCategoryLogger("log-parser");
+import fs18 from "node:fs/promises";
+import path17 from "node:path";
+var log4 = getCategoryLogger("log-parser");
 function parseReviewFilename(filename) {
   const m = filename.match(/^(.+)_([^@]+)@(\d+)\.(\d+)\.(log|json)$/);
   if (!m)
@@ -4621,9 +5061,9 @@ function parseReviewFilename(filename) {
 }
 async function parseJsonReviewFile(jsonPath) {
   try {
-    const content = await fs17.readFile(jsonPath, "utf-8");
+    const content = await fs18.readFile(jsonPath, "utf-8");
     const data = JSON.parse(content);
-    const filename = path16.basename(jsonPath);
+    const filename = path17.basename(jsonPath);
     const parsed = parseReviewFilename(filename);
     const jobId = parsed ? parsed.jobId : filename.replace(/\.\d+\.json$/, "");
     if (data.status === "pass" || data.status === "skipped_prior_pass") {
@@ -4657,7 +5097,7 @@ async function parseJsonReviewFile(jsonPath) {
       logPath: jsonPath.replace(/\.json$/, ".log")
     };
   } catch (error) {
-    log2.warn(`Failed to parse JSON review file: ${jsonPath} - ${error}`);
+    log4.warn(`Failed to parse JSON review file: ${jsonPath} - ${error}`);
     return null;
   }
 }
@@ -4669,8 +5109,8 @@ function extractPrefix(filename) {
 }
 async function parseLogFile(logPath) {
   try {
-    const content = await fs17.readFile(logPath, "utf-8");
-    const filename = path16.basename(logPath);
+    const content = await fs18.readFile(logPath, "utf-8");
+    const filename = path17.basename(logPath);
     const parsed = parseReviewFilename(filename);
     const jobId = parsed ? parsed.jobId : extractPrefix(filename);
     if (content.includes("--- Review Output")) {
@@ -4794,7 +5234,7 @@ async function parseLogFile(logPath) {
 }
 async function reconstructHistory(logDir) {
   try {
-    const files = await fs17.readdir(logDir);
+    const files = await fs18.readdir(logDir);
     const runNumbers = new Set;
     for (const file of files) {
       const m = file.match(/\.(\d+)\.(log|json)$/);
@@ -4818,9 +5258,9 @@ async function reconstructHistory(logDir) {
         const logFile = runFiles.find((f) => f.startsWith(`${prefix}.${runNum}.`) && f.endsWith(".log"));
         let failure = null;
         if (jsonFile) {
-          failure = await parseJsonReviewFile(path16.join(logDir, jsonFile));
+          failure = await parseJsonReviewFile(path17.join(logDir, jsonFile));
         } else if (logFile) {
-          failure = await parseLogFile(path16.join(logDir, logFile));
+          failure = await parseLogFile(path17.join(logDir, logFile));
         }
         if (failure) {
           for (const af of failure.adapterFailures) {
@@ -4878,7 +5318,7 @@ async function reconstructHistory(logDir) {
 }
 async function isJsonReviewPassing(jsonPath) {
   try {
-    const content = await fs17.readFile(jsonPath, "utf-8");
+    const content = await fs18.readFile(jsonPath, "utf-8");
     const data = JSON.parse(content);
     return data.status === "pass" || data.status === "skipped_prior_pass";
   } catch {
@@ -4887,7 +5327,7 @@ async function isJsonReviewPassing(jsonPath) {
 }
 async function isLogReviewPassing(logPath) {
   try {
-    const content = await fs17.readFile(logPath, "utf-8");
+    const content = await fs18.readFile(logPath, "utf-8");
     if (content.includes("Status: skipped_prior_pass")) {
       return true;
     }
@@ -4901,7 +5341,7 @@ async function isLogReviewPassing(logPath) {
 }
 async function findPreviousFailures(logDir, gateFilter, includePassedSlots) {
   try {
-    const files = await fs17.readdir(logDir);
+    const files = await fs18.readdir(logDir);
     const gateFailures = [];
     const passedSlots = new Map;
     const reviewSlotMap = new Map;
@@ -4952,7 +5392,7 @@ async function findPreviousFailures(logDir, gateFilter, includePassedSlots) {
       const reviewIndex = parseInt(slotKey.substring(sepIdx + 1), 10);
       const parsed = parseReviewFilename(fileInfo.filename);
       const adapter = parsed?.adapter || "unknown";
-      const filePath = path16.join(logDir, fileInfo.filename);
+      const filePath = path17.join(logDir, fileInfo.filename);
       let isPassing = false;
       if (fileInfo.ext === "json") {
         isPassing = await isJsonReviewPassing(filePath);
@@ -4987,7 +5427,7 @@ async function findPreviousFailures(logDir, gateFilter, includePassedSlots) {
             if (status === "skipped")
               continue;
             if (status !== "new" && status !== "fixed" && status !== "skipped") {
-              log2.warn(`Unexpected status "${status}" for violation in ${jobId}. Treating as "new".`);
+              log4.warn(`Unexpected status "${status}" for violation in ${jobId}. Treating as "new".`);
               v.status = "new";
             }
             filteredViolations.push(v);
@@ -5010,7 +5450,7 @@ async function findPreviousFailures(logDir, gateFilter, includePassedSlots) {
         gateName: "",
         entryPoint: "",
         adapterFailures,
-        logPath: path16.join(logDir, `${jobId}.log`)
+        logPath: path17.join(logDir, `${jobId}.log`)
       });
     }
     for (const [prefix, runMap] of checkPrefixMap.entries()) {
@@ -5020,9 +5460,9 @@ async function findPreviousFailures(logDir, gateFilter, includePassedSlots) {
         continue;
       let failure = null;
       if (exts.has("json")) {
-        failure = await parseJsonReviewFile(path16.join(logDir, `${prefix}.${latestRun}.json`));
+        failure = await parseJsonReviewFile(path17.join(logDir, `${prefix}.${latestRun}.json`));
       } else if (exts.has("log")) {
-        failure = await parseLogFile(path16.join(logDir, `${prefix}.${latestRun}.log`));
+        failure = await parseLogFile(path17.join(logDir, `${prefix}.${latestRun}.log`));
       }
       if (failure) {
         for (const af of failure.adapterFailures) {
@@ -5032,7 +5472,7 @@ async function findPreviousFailures(logDir, gateFilter, includePassedSlots) {
             if (status === "skipped")
               continue;
             if (status !== "new" && status !== "fixed" && status !== "skipped") {
-              log2.warn(`Unexpected status "${status}" for violation in ${failure.jobId}. Treating as "new".`);
+              log4.warn(`Unexpected status "${status}" for violation in ${failure.jobId}. Treating as "new".`);
               v.status = "new";
             }
             filteredViolations.push(v);
@@ -5056,6 +5496,26 @@ async function findPreviousFailures(logDir, gateFilter, includePassedSlots) {
     return includePassedSlots ? { failures: [], passedSlots: new Map } : [];
   }
 }
+async function hasSkippedViolationsInLogs(opts) {
+  const { logDir } = opts;
+  try {
+    const files = await fs18.readdir(logDir);
+    for (const file of files) {
+      if (!file.endsWith(".json"))
+        continue;
+      try {
+        const content = await fs18.readFile(path17.join(logDir, file), "utf-8");
+        const data = JSON.parse(content);
+        if (data.violations?.some((v) => v.status === "skipped")) {
+          return true;
+        }
+      } catch {}
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
 
 // src/output/console.ts
 class ConsoleReporter {
@@ -5173,7 +5633,7 @@ ${chalk2.bold("━━━━━━━━━━━━━━━━━━━━━
     const allDetails = [];
     for (const logPath of logPaths) {
       try {
-        const logContent = await fs18.readFile(logPath, "utf-8");
+        const logContent = await fs19.readFile(logPath, "utf-8");
         const details = this.parseLogContent(logContent, result.jobId);
         allDetails.push(...details);
       } catch (_error) {
@@ -5283,9 +5743,9 @@ ${chalk2.bold("━━━━━━━━━━━━━━━━━━━━━
 }
 
 // src/output/console-log.ts
-import fs19 from "node:fs";
+import fs20 from "node:fs";
 import fsPromises2 from "node:fs/promises";
-import path17 from "node:path";
+import path18 from "node:path";
 import { inspect } from "node:util";
 var ANSI_REGEX = /\x1b(?:\[[0-9;?]*[A-Za-z]|[78])/g;
 function stripAnsi(text) {
@@ -5295,9 +5755,9 @@ function formatArgs(args) {
   return args.map((a) => typeof a === "string" ? a : inspect(a, { depth: 4 })).join(" ");
 }
 function openLogFileExclusive(logDir, runNum) {
-  const logPath = path17.join(logDir, `console.${runNum}.log`);
+  const logPath = path18.join(logDir, `console.${runNum}.log`);
   try {
-    const fd = fs19.openSync(logPath, fs19.constants.O_WRONLY | fs19.constants.O_CREAT | fs19.constants.O_EXCL);
+    const fd = fs20.openSync(logPath, fs20.constants.O_WRONLY | fs20.constants.O_CREAT | fs20.constants.O_EXCL);
     return { fd, logPath };
   } catch (e) {
     const error = e;
@@ -5311,9 +5771,9 @@ function openLogFileExclusive(logDir, runNum) {
 function openLogFileFallback(logDir, startNum) {
   let runNum = startNum;
   for (let attempts = 0;attempts < 100; attempts++) {
-    const logPath = path17.join(logDir, `console.${runNum}.log`);
+    const logPath = path18.join(logDir, `console.${runNum}.log`);
     try {
-      const fd = fs19.openSync(logPath, fs19.constants.O_WRONLY | fs19.constants.O_CREAT | fs19.constants.O_EXCL);
+      const fd = fs20.openSync(logPath, fs20.constants.O_WRONLY | fs20.constants.O_CREAT | fs20.constants.O_EXCL);
       return { fd, logPath };
     } catch (e) {
       const error = e;
@@ -5334,7 +5794,7 @@ async function startConsoleLog(logDir, runNumber) {
       if (isClosed)
         return;
       try {
-        fs19.writeSync(fd, stripAnsi(text));
+        fs20.writeSync(fd, stripAnsi(text));
       } catch {}
     };
     const originalLog = console.log;
@@ -5382,7 +5842,7 @@ async function startConsoleLog(logDir, runNumber) {
         process.stdout.write = originalStdoutWrite;
         process.stderr.write = originalStderrWrite;
         try {
-          fs19.closeSync(fd);
+          fs20.closeSync(fd);
         } catch {}
       },
       writeToLogOnly: (text) => {
@@ -5390,20 +5850,20 @@ async function startConsoleLog(logDir, runNumber) {
       }
     };
   } catch (error) {
-    fs19.closeSync(fd);
+    fs20.closeSync(fd);
     throw error;
   }
 }
 
 // src/output/logger.ts
-import fs20 from "node:fs/promises";
-import path18 from "node:path";
+import fs21 from "node:fs/promises";
+import path19 from "node:path";
 function formatTimestamp() {
   return new Date().toISOString();
 }
 async function computeGlobalRunNumber(logDir) {
   try {
-    const files = await fs20.readdir(logDir);
+    const files = await fs21.readdir(logDir);
     let max = 0;
     for (const file of files) {
       if (!file.endsWith(".log") && !file.endsWith(".json"))
@@ -5429,7 +5889,7 @@ class Logger {
     this.logDir = logDir;
   }
   async init() {
-    await fs20.mkdir(this.logDir, { recursive: true });
+    await fs21.mkdir(this.logDir, { recursive: true });
     this.globalRunNumber = await computeGlobalRunNumber(this.logDir);
   }
   async close() {}
@@ -5447,14 +5907,14 @@ class Logger {
     } else {
       filename = `${safeName}.${runNum}.log`;
     }
-    return path18.join(this.logDir, filename);
+    return path19.join(this.logDir, filename);
   }
   async initFile(logPath) {
     if (this.initializedFiles.has(logPath)) {
       return;
     }
     this.initializedFiles.add(logPath);
-    await fs20.writeFile(logPath, "");
+    await fs21.writeFile(logPath, "");
   }
   async createJobLogger(jobId) {
     const logPath = await this.getLogPath(jobId);
@@ -5466,7 +5926,7 @@ class Logger {
       if (lines.length > 0) {
         lines[0] = `[${timestamp}] ${lines[0]}`;
       }
-      await fs20.appendFile(logPath, lines.join(`
+      await fs21.appendFile(logPath, lines.join(`
 `) + (text.endsWith(`
 `) ? "" : `
 `));
@@ -5483,7 +5943,7 @@ class Logger {
         if (lines.length > 0) {
           lines[0] = `[${timestamp}] ${lines[0]}`;
         }
-        await fs20.appendFile(logPath, lines.join(`
+        await fs21.appendFile(logPath, lines.join(`
 `) + (text.endsWith(`
 `) ? "" : `
 `));
@@ -5494,8 +5954,8 @@ class Logger {
 }
 
 // src/commands/shared.ts
-import fs21 from "node:fs/promises";
-import path19 from "node:path";
+import fs22 from "node:fs/promises";
+import path20 from "node:path";
 var LOCK_FILENAME = ".gauntlet-run.lock";
 var SESSION_REF_FILENAME2 = ".session_ref";
 async function shouldAutoClean(logDir, baseBranch) {
@@ -5530,17 +5990,17 @@ async function performAutoClean(logDir, result, maxPreviousLogs = 3) {
 }
 async function exists(filePath) {
   try {
-    await fs21.stat(filePath);
+    await fs22.stat(filePath);
     return true;
   } catch {
     return false;
   }
 }
 async function acquireLock(logDir) {
-  await fs21.mkdir(logDir, { recursive: true });
-  const lockPath = path19.resolve(logDir, LOCK_FILENAME);
+  await fs22.mkdir(logDir, { recursive: true });
+  const lockPath = path20.resolve(logDir, LOCK_FILENAME);
   try {
-    await fs21.writeFile(lockPath, String(process.pid), { flag: "wx" });
+    await fs22.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}).`);
@@ -5551,14 +6011,14 @@ async function acquireLock(logDir) {
   }
 }
 async function releaseLock(logDir) {
-  const lockPath = path19.resolve(logDir, LOCK_FILENAME);
+  const lockPath = path20.resolve(logDir, LOCK_FILENAME);
   try {
-    await fs21.rm(lockPath, { force: true });
+    await fs22.rm(lockPath, { force: true });
   } catch {}
 }
 async function hasExistingLogs(logDir) {
   try {
-    const entries = await fs21.readdir(logDir);
+    const entries = await fs22.readdir(logDir);
     return entries.some((f) => (f.endsWith(".log") || f.endsWith(".json")) && f !== "previous" && !f.startsWith("console.") && !f.startsWith("."));
   } catch {
     return false;
@@ -5577,7 +6037,7 @@ function getPersistentFiles() {
 }
 async function hasCurrentLogs(logDir) {
   try {
-    const files = await fs21.readdir(logDir);
+    const files = await fs22.readdir(logDir);
     const persistentFiles = getPersistentFiles();
     return files.some((f) => (f.endsWith(".log") || f.endsWith(".json")) && f !== "previous" && !persistentFiles.has(f));
   } catch {
@@ -5589,23 +6049,23 @@ function getCurrentLogFiles(files) {
   return files.filter((file) => !file.startsWith("previous") && !persistentFiles.has(file));
 }
 async function deleteCurrentLogs(logDir) {
-  const files = await fs21.readdir(logDir);
-  await Promise.all(getCurrentLogFiles(files).map((file) => fs21.rm(path19.join(logDir, file), { recursive: true, force: true })));
+  const files = await fs22.readdir(logDir);
+  await Promise.all(getCurrentLogFiles(files).map((file) => fs22.rm(path20.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 = path19.join(logDir, oldestDir);
+  const oldestPath = path20.join(logDir, oldestDir);
   if (await exists(oldestPath)) {
-    await fs21.rm(oldestPath, { recursive: true, force: true });
+    await fs22.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 = path19.join(logDir, fromName);
-    const toPath = path19.join(logDir, toName);
+    const fromPath = path20.join(logDir, fromName);
+    const toPath = path20.join(logDir, toName);
     if (await exists(fromPath)) {
-      await fs21.rename(fromPath, toPath);
+      await fs22.rename(fromPath, toPath);
     }
   }
 }
@@ -5620,12 +6080,12 @@ async function cleanLogs(logDir, maxPreviousLogs = 3) {
       return;
     }
     await rotatePreviousDirs(logDir, maxPreviousLogs);
-    const previousDir = path19.join(logDir, "previous");
-    await fs21.mkdir(previousDir, { recursive: true });
-    const files = await fs21.readdir(logDir);
-    await Promise.all(getCurrentLogFiles(files).map((file) => fs21.rename(path19.join(logDir, file), path19.join(previousDir, file))));
+    const previousDir = path20.join(logDir, "previous");
+    await fs22.mkdir(previousDir, { recursive: true });
+    const files = await fs22.readdir(logDir);
+    await Promise.all(getCurrentLogFiles(files).map((file) => fs22.rename(path20.join(logDir, file), path20.join(previousDir, file))));
     try {
-      await fs21.rm(path19.join(logDir, SESSION_REF_FILENAME2), { force: true });
+      await fs22.rm(path20.join(logDir, SESSION_REF_FILENAME2), { force: true });
     } catch {}
   } catch (error) {
     console.warn("Failed to clean logs in", logDir, ":", error instanceof Error ? error.message : error);
@@ -5769,14 +6229,14 @@ function registerCheckCommand(program) {
   });
 }
 // src/commands/ci/init.ts
-import fs23 from "node:fs/promises";
-import path21 from "node:path";
+import fs24 from "node:fs/promises";
+import path22 from "node:path";
 import chalk4 from "chalk";
 import YAML5 from "yaml";
 
 // src/config/ci-loader.ts
-import fs22 from "node:fs/promises";
-import path20 from "node:path";
+import fs23 from "node:fs/promises";
+import path21 from "node:path";
 import YAML4 from "yaml";
 
 // src/config/ci-schema.ts
@@ -5806,17 +6266,17 @@ var ciConfigSchema = z3.object({
 var GAUNTLET_DIR2 = ".gauntlet";
 var CI_FILE = "ci.yml";
 async function loadCIConfig(rootDir = process.cwd()) {
-  const ciPath = path20.join(rootDir, GAUNTLET_DIR2, CI_FILE);
+  const ciPath = path21.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 fs22.readFile(ciPath, "utf-8");
+  const content = await fs23.readFile(ciPath, "utf-8");
   const raw = YAML4.parse(content);
   return ciConfigSchema.parse(raw);
 }
-async function fileExists3(path21) {
+async function fileExists3(path22) {
   try {
-    const stat = await fs22.stat(path21);
+    const stat = await fs23.stat(path22);
     return stat.isFile();
   } catch {
     return false;
@@ -5907,13 +6367,13 @@ jobs:
 
 // src/commands/ci/init.ts
 async function initCI() {
-  const workflowDir = path21.join(process.cwd(), ".github", "workflows");
-  const workflowPath = path21.join(workflowDir, "gauntlet.yml");
-  const gauntletDir = path21.join(process.cwd(), ".gauntlet");
-  const ciConfigPath = path21.join(gauntletDir, "ci.yml");
+  const workflowDir = path22.join(process.cwd(), ".github", "workflows");
+  const workflowPath = path22.join(workflowDir, "gauntlet.yml");
+  const gauntletDir = path22.join(process.cwd(), ".gauntlet");
+  const ciConfigPath = path22.join(gauntletDir, "ci.yml");
   if (!await fileExists4(ciConfigPath)) {
     console.log(chalk4.yellow("Creating starter .gauntlet/ci.yml..."));
-    await fs23.mkdir(gauntletDir, { recursive: true });
+    await fs24.mkdir(gauntletDir, { recursive: true });
     const starterContent = `# CI Configuration for Agent Gauntlet
 # Define runtimes, services, and which checks to run in CI.
 
@@ -5935,7 +6395,7 @@ checks:
   # - name: linter
   #   requires_runtimes: [ruby]
 `;
-    await fs23.writeFile(ciConfigPath, starterContent);
+    await fs24.writeFile(ciConfigPath, starterContent);
   } else {
     console.log(chalk4.dim("Found existing .gauntlet/ci.yml"));
   }
@@ -5946,7 +6406,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 fs23.mkdir(workflowDir, { recursive: true });
+  await fs24.mkdir(workflowDir, { recursive: true });
   let templateContent = workflow_default;
   if (ciConfig?.services && Object.keys(ciConfig.services).length > 0) {
     const servicesYaml = YAML5.stringify({ services: ciConfig.services });
@@ -5958,12 +6418,12 @@ checks:
     templateContent = templateContent.replace(`    # Services will be injected here by agent-gauntlet
 `, "");
   }
-  await fs23.writeFile(workflowPath, templateContent);
+  await fs24.writeFile(workflowPath, templateContent);
   console.log(chalk4.green("Successfully generated GitHub Actions workflow!"));
 }
-async function fileExists4(path22) {
+async function fileExists4(path23) {
   try {
-    const stat = await fs23.stat(path22);
+    const stat = await fs24.stat(path23);
     return stat.isFile();
   } catch {
     return false;
@@ -6164,12 +6624,12 @@ function printJobsByWorkDir(jobs) {
   }
 }
 // src/commands/health.ts
-import path23 from "node:path";
+import path24 from "node:path";
 import chalk7 from "chalk";
 
 // src/config/validator.ts
-import fs24 from "node:fs/promises";
-import path22 from "node:path";
+import fs25 from "node:fs/promises";
+import path23 from "node:path";
 import matter2 from "gray-matter";
 import YAML6 from "yaml";
 import { ZodError } from "zod";
@@ -6180,10 +6640,10 @@ var REVIEWS_DIR2 = "reviews";
 async function validateConfig(rootDir = process.cwd()) {
   const issues = [];
   const filesChecked = [];
-  const gauntletPath = path22.join(rootDir, GAUNTLET_DIR3);
+  const gauntletPath = path23.join(rootDir, GAUNTLET_DIR3);
   const existingCheckNames = new Set;
   const existingReviewNames = new Set;
-  const configPath = path22.join(gauntletPath, CONFIG_FILE2);
+  const configPath = path23.join(gauntletPath, CONFIG_FILE2);
   let projectConfig = null;
   const checks = {};
   const reviews = {};
@@ -6191,7 +6651,7 @@ async function validateConfig(rootDir = process.cwd()) {
   try {
     if (await fileExists5(configPath)) {
       filesChecked.push(configPath);
-      const configContent = await fs24.readFile(configPath, "utf-8");
+      const configContent = await fs25.readFile(configPath, "utf-8");
       try {
         const raw = YAML6.parse(configContent);
         projectConfig = gauntletConfigSchema.parse(raw);
@@ -6237,17 +6697,17 @@ async function validateConfig(rootDir = process.cwd()) {
       message: `Error reading file: ${err.message}`
     });
   }
-  const checksPath = path22.join(gauntletPath, CHECKS_DIR2);
+  const checksPath = path23.join(gauntletPath, CHECKS_DIR2);
   if (await dirExists2(checksPath)) {
     try {
-      const checkFiles = await fs24.readdir(checksPath);
+      const checkFiles = await fs25.readdir(checksPath);
       for (const file of checkFiles) {
         if (file.endsWith(".yml") || file.endsWith(".yaml")) {
-          const filePath = path22.join(checksPath, file);
+          const filePath = path23.join(checksPath, file);
           filesChecked.push(filePath);
-          const name = path22.basename(file, path22.extname(file));
+          const name = path23.basename(file, path23.extname(file));
           try {
-            const content = await fs24.readFile(filePath, "utf-8");
+            const content = await fs25.readFile(filePath, "utf-8");
             const raw = YAML6.parse(content);
             const parsed = checkGateSchema.parse(raw);
             existingCheckNames.add(name);
@@ -6299,14 +6759,14 @@ async function validateConfig(rootDir = process.cwd()) {
       });
     }
   }
-  const reviewsPath = path22.join(gauntletPath, REVIEWS_DIR2);
+  const reviewsPath = path23.join(gauntletPath, REVIEWS_DIR2);
   if (await dirExists2(reviewsPath)) {
     try {
-      const reviewFiles = await fs24.readdir(reviewsPath);
+      const reviewFiles = await fs25.readdir(reviewsPath);
       const reviewNameSources = new Map;
       for (const file of reviewFiles) {
         if (file.endsWith(".md") || file.endsWith(".yml") || file.endsWith(".yaml")) {
-          const name = path22.basename(file, path22.extname(file));
+          const name = path23.basename(file, path23.extname(file));
           const sources = reviewNameSources.get(name) || [];
           sources.push(file);
           reviewNameSources.set(name, sources);
@@ -6323,12 +6783,12 @@ async function validateConfig(rootDir = process.cwd()) {
       }
       for (const file of reviewFiles) {
         if (file.endsWith(".md")) {
-          const filePath = path22.join(reviewsPath, file);
-          const reviewName = path22.basename(file, ".md");
+          const filePath = path23.join(reviewsPath, file);
+          const reviewName = path23.basename(file, ".md");
           existingReviewNames.add(reviewName);
           filesChecked.push(filePath);
           try {
-            const content = await fs24.readFile(filePath, "utf-8");
+            const content = await fs25.readFile(filePath, "utf-8");
             const { data: frontmatter, content: _promptBody } = matter2(content);
             if (!frontmatter || Object.keys(frontmatter).length === 0) {
               issues.push({
@@ -6340,7 +6800,7 @@ async function validateConfig(rootDir = process.cwd()) {
             }
             validateCliPreferenceTools(frontmatter, filePath, issues);
             const parsedFrontmatter = reviewPromptFrontmatterSchema.parse(frontmatter);
-            const name = path22.basename(file, ".md");
+            const name = path23.basename(file, ".md");
             reviews[name] = parsedFrontmatter;
             reviewSourceFiles[name] = filePath;
             validateReviewSemantics(parsedFrontmatter, filePath, issues);
@@ -6348,12 +6808,12 @@ async function validateConfig(rootDir = process.cwd()) {
             handleReviewValidationError(error, filePath, issues);
           }
         } else if (file.endsWith(".yml") || file.endsWith(".yaml")) {
-          const filePath = path22.join(reviewsPath, file);
-          const reviewName = path22.basename(file, path22.extname(file));
+          const filePath = path23.join(reviewsPath, file);
+          const reviewName = path23.basename(file, path23.extname(file));
           existingReviewNames.add(reviewName);
           filesChecked.push(filePath);
           try {
-            const content = await fs24.readFile(filePath, "utf-8");
+            const content = await fs25.readFile(filePath, "utf-8");
             const raw = YAML6.parse(content);
             validateCliPreferenceTools(raw, filePath, issues);
             const parsed = reviewYamlSchema.parse(raw);
@@ -6484,7 +6944,7 @@ async function validateConfig(rootDir = process.cwd()) {
         for (const [reviewName, reviewConfig] of Object.entries(reviews)) {
           const pref = reviewConfig.cli_preference;
           if (pref && Array.isArray(pref)) {
-            const reviewFile = reviewSourceFiles[reviewName] || path22.join(reviewsPath, `${reviewName}.md`);
+            const reviewFile = reviewSourceFiles[reviewName] || path23.join(reviewsPath, `${reviewName}.md`);
             for (let i = 0;i < pref.length; i++) {
               const tool = pref[i];
               if (!allowedTools.has(tool)) {
@@ -6610,17 +7070,17 @@ function handleReviewValidationError(error, filePath, issues) {
     }
   }
 }
-async function fileExists5(path23) {
+async function fileExists5(path24) {
   try {
-    const stat = await fs24.stat(path23);
+    const stat = await fs25.stat(path24);
     return stat.isFile();
   } catch {
     return false;
   }
 }
-async function dirExists2(path23) {
+async function dirExists2(path24) {
   try {
-    const stat = await fs24.stat(path23);
+    const stat = await fs25.stat(path24);
     return stat.isDirectory();
   } catch {
     return false;
@@ -6636,7 +7096,7 @@ function registerHealthCommand(program) {
       console.log(chalk7.yellow("  No config files found"));
     } else {
       for (const file of validationResult.filesChecked) {
-        const relativePath = path23.relative(process.cwd(), file);
+        const relativePath = path24.relative(process.cwd(), file);
         console.log(chalk7.dim(`  ${relativePath}`));
       }
       if (validationResult.valid && validationResult.issues.length === 0) {
@@ -6644,7 +7104,7 @@ function registerHealthCommand(program) {
       } else {
         const issuesByFile = new Map;
         for (const issue of validationResult.issues) {
-          const relativeFile = path23.relative(process.cwd(), issue.file);
+          const relativeFile = path24.relative(process.cwd(), issue.file);
           if (!issuesByFile.has(relativeFile)) {
             issuesByFile.set(relativeFile, []);
           }
@@ -6763,16 +7223,15 @@ function registerHelpCommand(program) {
   });
 }
 // src/commands/init.ts
-import { readFileSync } from "node:fs";
-import fs26 from "node:fs/promises";
-import path25 from "node:path";
+import fs27 from "node:fs/promises";
+import path26 from "node:path";
 import { fileURLToPath } from "node:url";
 import chalk10 from "chalk";
 
 // src/commands/init-checksums.ts
 import { createHash } from "node:crypto";
-import fs25 from "node:fs/promises";
-import path24 from "node:path";
+import fs26 from "node:fs/promises";
+import path25 from "node:path";
 async function computeSkillChecksum(skillDir) {
   const files = await collectFiles(skillDir);
   files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
@@ -6783,26 +7242,6 @@ async function computeSkillChecksum(skillDir) {
   }
   return hash.digest("hex");
 }
-function computeExpectedSkillChecksum(content, references) {
-  const entries = [
-    { relativePath: "SKILL.md", content }
-  ];
-  if (references) {
-    for (const [name, refContent] of Object.entries(references)) {
-      entries.push({
-        relativePath: path24.join("references", name),
-        content: refContent
-      });
-    }
-  }
-  entries.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
-  const hash = createHash("sha256");
-  for (const entry of entries) {
-    hash.update(entry.relativePath);
-    hash.update(entry.content);
-  }
-  return hash.digest("hex");
-}
 function computeHookChecksum(entries) {
   const gauntletEntries = entries.filter((entry) => isGauntletHookEntry(entry));
   const hash = createHash("sha256");
@@ -6825,14 +7264,14 @@ function isGauntletHookEntry(entry) {
 async function collectFiles(dir, baseDir) {
   const base = baseDir ?? dir;
   const results = [];
-  const entries = await fs25.readdir(dir, { withFileTypes: true });
+  const entries = await fs26.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path24.join(dir, entry.name);
+    const fullPath = path25.join(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...await collectFiles(fullPath, base));
     } else if (entry.isFile()) {
-      const content = await fs25.readFile(fullPath, "utf-8");
-      results.push({ relativePath: path24.relative(base, fullPath), content });
+      const content = await fs26.readFile(fullPath, "utf-8");
+      results.push({ relativePath: path25.relative(base, fullPath), content });
     }
   }
   return results;
@@ -6896,11 +7335,26 @@ async function promptHookOverwrite(hookFile, skipPrompts) {
 }
 
 // src/commands/init.ts
-var __dirname2 = path25.dirname(fileURLToPath(import.meta.url));
-function readSkillTemplate(filename) {
-  const templatePath = path25.join(__dirname2, "skill-templates", filename);
-  return readFileSync(templatePath, "utf-8");
-}
+var __dirname2 = path26.dirname(fileURLToPath(import.meta.url));
+var SKILLS_SOURCE_DIR = path26.join(__dirname2, "..", "..", "skills");
+var SKILL_ACTIONS = [
+  "run",
+  "check",
+  "push-pr",
+  "fix-pr",
+  "status",
+  "help",
+  "setup"
+];
+var SKILL_DESCRIPTIONS = {
+  run: "Run the verification suite",
+  check: "Run checks only (no reviews)",
+  "push-pr": "Commit, push, and create a PR",
+  "fix-pr": "Fix PR review comments and CI failures",
+  status: "Show gauntlet status",
+  help: "Diagnose and explain gauntlet behavior",
+  setup: "Configure checks and reviews interactively"
+};
 var CLI_PREFERENCE_ORDER = [
   "codex",
   "claude",
@@ -6911,156 +7365,19 @@ var CLI_PREFERENCE_ORDER = [
 var ADAPTER_CONFIG = {
   claude: { allow_tool_use: false, thinking_budget: "high" },
   codex: { allow_tool_use: false, thinking_budget: "low" },
-  gemini: { allow_tool_use: false, thinking_budget: "low" }
-};
-function buildGauntletSkillContent(mode) {
-  const isRun = mode === "run";
-  const name = isRun ? "run" : "check";
-  const description = isRun ? "Run the full verification gauntlet. Use this as the final step after completing a coding task — verifies quality, runs checks, and ensures all gates pass. Must be run before committing, pushing, or creating PRs." : "Run checks only (no reviews)";
-  const command = isRun ? "agent-gauntlet run" : "agent-gauntlet check";
-  const heading = isRun ? "Execute the autonomous verification suite." : "Run the gauntlet checks only — no AI reviews.";
-  const disableModelInvocation = isRun ? "false" : "true";
-  const frontmatter = `---
-name: gauntlet-${name}
-description: >-
-  ${description}
-disable-model-invocation: ${disableModelInvocation}
-allowed-tools: Bash
----`;
-  const steps = [
-    `1. Run \`agent-gauntlet clean\` to archive any previous log files`,
-    `2. Run \`${command}\``
-  ];
-  if (isRun) {
-    steps.push(`3. If it fails:
-   - Identify the failed gates from the console output.
-   - For CHECK failures: Read the \`.log\` file path provided in the output. If the log contains a \`--- Fix Instructions ---\` section, follow those instructions to fix the issue. If it contains a \`--- Fix Skill: <name> ---\` section, invoke that skill.
-   - For REVIEW failures: Read the \`.json\` file path provided in the "Review: <path>" output.
-4. Address the violations:
-   - For REVIEW violations: You MUST update the \`"status"\` and \`"result"\` fields in the provided \`.json\` file for EACH violation.
-     - Set \`"status": "fixed"\` and add a brief description to \`"result"\` for issues you fix.
-     - Set \`"status": "skipped"\` and add a brief reason to \`"result"\` for issues you skip (based on the trust level).
-     - Do NOT modify any other attributes (file, line, issue, priority) in the JSON file.
-   - Apply the trust level above when deciding whether to act on AI reviewer feedback.
-5. Run \`${command}\` again to verify your fixes. Do NOT run \`agent-gauntlet clean\` between retries. The tool detects existing logs and automatically switches to verification mode.
-6. Repeat steps 3-5 until one of the following termination conditions is met:
-   - "Status: Passed" appears in the output (logs are automatically archived)
-   - "Status: Passed with warnings" appears in the output (remaining issues were skipped)
-   - "Status: Retry limit exceeded" appears in the output -> Run \`agent-gauntlet clean\` to archive logs for the session record. Do NOT retry after cleaning.
-7. Provide a summary of the session:
-   - Issues Fixed: (list key fixes)
-   - Issues Skipped: (list skipped items and reasons)
-   - Outstanding Failures: (if retry limit exceeded, list unverified fixes and remaining issues)`);
-  } else {
-    steps.push(`3. If any checks fail:
-   - Read the \`.log\` file path provided in the output for each failed check. If the log contains a \`--- Fix Instructions ---\` section, follow those instructions. If it contains a \`--- Fix Skill: <name> ---\` section, invoke that skill.
-   - Fix the issues found.
-4. Run \`${command}\` again to verify your fixes. Do NOT run \`agent-gauntlet clean\` between retries.
-5. Repeat steps 3-4 until all checks pass or you've made 3 attempts.
-6. Provide a summary of the session:
-   - Checks Passed: (list)
-   - Checks Failed: (list with brief reason)
-   - Fixes Applied: (list key fixes)`);
-  }
-  if (isRun) {
-    return `${frontmatter}
-<!--
-  REVIEW TRUST LEVEL
-  Controls how aggressively the agent acts on AI reviewer feedback.
-  Change the trust_level value below to one of: high, medium, low
-
-  - high:   Fix all issues unless you strongly disagree or have low confidence the human wants the change.
-  - medium: Fix issues you reasonably agree with or believe the human wants fixed. (DEFAULT)
-  - low:    Fix only issues you strongly agree with or are confident the human wants fixed.
--->
-<!-- trust_level: medium -->
-
-# /gauntlet-${name}
-${heading}
-
-**Review trust level: medium** — Fix issues you reasonably agree with or believe the human wants to be fixed. Skip issues that are purely stylistic, subjective, or that you believe the human would not want changed. When you skip an issue, briefly state what was skipped and why.
-
-${steps.join(`
-`)}
-`;
-  }
-  return `${frontmatter}
-
-# /gauntlet-${name}
-${heading}
-
-${steps.join(`
-`)}
-`;
-}
-var GAUNTLET_RUN_SKILL_CONTENT = buildGauntletSkillContent("run");
-var GAUNTLET_CHECK_SKILL_CONTENT = buildGauntletSkillContent("check");
-var PUSH_PR_SKILL_CONTENT = readSkillTemplate("push-pr.md");
-var FIX_PR_SKILL_CONTENT = readSkillTemplate("fix-pr.md");
-var GAUNTLET_STATUS_SKILL_CONTENT = readSkillTemplate("status.md");
-var HELP_SKILL_BUNDLE = {
-  content: readSkillTemplate("help-skill.md"),
-  references: {
-    "stop-hook-troubleshooting.md": readSkillTemplate("help-ref-stop-hook-troubleshooting.md"),
-    "config-troubleshooting.md": readSkillTemplate("help-ref-config-troubleshooting.md"),
-    "gate-troubleshooting.md": readSkillTemplate("help-ref-gate-troubleshooting.md"),
-    "lock-troubleshooting.md": readSkillTemplate("help-ref-lock-troubleshooting.md"),
-    "adapter-troubleshooting.md": readSkillTemplate("help-ref-adapter-troubleshooting.md"),
-    "ci-pr-troubleshooting.md": readSkillTemplate("help-ref-ci-pr-troubleshooting.md")
+  gemini: { allow_tool_use: false, thinking_budget: "low" },
+  cursor: { allow_tool_use: false, thinking_budget: "low", model: "codex" },
+  "github-copilot": {
+    allow_tool_use: false,
+    thinking_budget: "low",
+    model: "codex"
   }
 };
-var SETUP_SKILL_CONTENT = readSkillTemplate("setup-skill.md");
-var CHECK_CATALOG_REFERENCE = readSkillTemplate("check-catalog.md");
-var PROJECT_STRUCTURE_REFERENCE = readSkillTemplate("setup-ref-project-structure.md");
-var SKILL_DEFINITIONS = [
-  {
-    action: "run",
-    content: GAUNTLET_RUN_SKILL_CONTENT,
-    description: "Run the verification suite"
-  },
-  {
-    action: "check",
-    content: GAUNTLET_CHECK_SKILL_CONTENT,
-    description: "Run a single check gate"
-  },
-  {
-    action: "push-pr",
-    content: PUSH_PR_SKILL_CONTENT,
-    description: "Commit, push, and create a PR"
-  },
-  {
-    action: "fix-pr",
-    content: FIX_PR_SKILL_CONTENT,
-    description: "Fix PR review comments and CI failures"
-  },
-  {
-    action: "status",
-    content: GAUNTLET_STATUS_SKILL_CONTENT,
-    description: "Show gauntlet status"
-  },
-  {
-    action: "help",
-    content: HELP_SKILL_BUNDLE.content,
-    references: HELP_SKILL_BUNDLE.references,
-    skillsOnly: true,
-    description: "Diagnose and explain gauntlet behavior"
-  },
-  {
-    action: "setup",
-    content: SETUP_SKILL_CONTENT,
-    references: {
-      "check-catalog.md": CHECK_CATALOG_REFERENCE,
-      "project-structure.md": PROJECT_STRUCTURE_REFERENCE
-    },
-    skillsOnly: true,
-    description: "Configure checks and reviews interactively"
-  }
-];
 var NATIVE_CLIS = new Set(["claude", "cursor"]);
 function registerInitCommand(program) {
   program.command("init").description("Initialize .gauntlet configuration").option("-y, --yes", "Skip prompts and use defaults").action(async (options) => {
     const projectRoot = process.cwd();
-    const targetDir = path25.join(projectRoot, ".gauntlet");
+    const targetDir = path26.join(projectRoot, ".gauntlet");
     const skipPrompts = options.yes ?? false;
     console.log("Detecting available CLI agents...");
     const availableAdapters = await detectAvailableCLIs();
@@ -7108,47 +7425,50 @@ async function scaffoldGauntletDir(_projectRoot, targetDir, reviewCLINames, numR
     console.log(chalk10.dim(".gauntlet/ already exists, skipping scaffolding"));
     return;
   }
-  await fs26.mkdir(targetDir);
-  await fs26.mkdir(path25.join(targetDir, "checks"));
-  await fs26.mkdir(path25.join(targetDir, "reviews"));
+  await fs27.mkdir(targetDir);
+  await fs27.mkdir(path26.join(targetDir, "checks"));
+  await fs27.mkdir(path26.join(targetDir, "reviews"));
   await writeConfigYml(targetDir, reviewCLINames);
-  await fs26.writeFile(path25.join(targetDir, "reviews", "code-quality.yml"), `builtin: code-quality
+  await fs27.writeFile(path26.join(targetDir, "reviews", "code-quality.yml"), `builtin: code-quality
 num_reviews: ${numReviews}
 `);
   console.log(chalk10.green("Created .gauntlet/reviews/code-quality.yml"));
 }
-async function writeSkillFiles(actionDir, content, references) {
-  await fs26.mkdir(actionDir, { recursive: true });
-  await fs26.writeFile(path25.join(actionDir, "SKILL.md"), content);
-  if (references) {
-    const refsDir = path25.join(actionDir, "references");
-    await fs26.mkdir(refsDir, { recursive: true });
-    for (const [fileName, fileContent] of Object.entries(references)) {
-      await fs26.writeFile(path25.join(refsDir, fileName), fileContent);
+async function copyDirRecursive(opts) {
+  await fs27.mkdir(opts.dest, { recursive: true });
+  const entries = await fs27.readdir(opts.src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path26.join(opts.src, entry.name);
+    const destPath = path26.join(opts.dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirRecursive({ src: srcPath, dest: destPath });
+    } else {
+      await fs27.copyFile(srcPath, destPath);
     }
   }
 }
 async function installSkillsWithChecksums(projectRoot, skipPrompts) {
-  const skillsDir = path25.join(projectRoot, ".claude", "skills");
-  for (const skill of SKILL_DEFINITIONS) {
-    const actionDir = path25.join(skillsDir, `gauntlet-${skill.action}`);
-    const skillPath = path25.join(actionDir, "SKILL.md");
-    const references = "references" in skill ? skill.references : undefined;
-    if (!await exists(actionDir)) {
-      await writeSkillFiles(actionDir, skill.content, references);
-      console.log(chalk10.green(`Created ${path25.relative(projectRoot, skillPath)}`));
+  const skillsDir = path26.join(projectRoot, ".claude", "skills");
+  for (const action of SKILL_ACTIONS) {
+    const dirName = `gauntlet-${action}`;
+    const sourceDir = path26.join(SKILLS_SOURCE_DIR, dirName);
+    const targetDir = path26.join(skillsDir, dirName);
+    const relativeDir = `${path26.relative(projectRoot, targetDir)}/`;
+    if (!await exists(targetDir)) {
+      await copyDirRecursive({ src: sourceDir, dest: targetDir });
+      console.log(chalk10.green(`Created ${relativeDir}`));
       continue;
     }
-    const expectedChecksum = computeExpectedSkillChecksum(skill.content, references);
-    const actualChecksum = await computeSkillChecksum(actionDir);
-    if (expectedChecksum === actualChecksum)
+    const sourceChecksum = await computeSkillChecksum(sourceDir);
+    const targetChecksum = await computeSkillChecksum(targetDir);
+    if (sourceChecksum === targetChecksum)
       continue;
-    const shouldOverwrite = await promptFileOverwrite(`gauntlet-${skill.action}`, skipPrompts);
+    const shouldOverwrite = await promptFileOverwrite(dirName, skipPrompts);
     if (!shouldOverwrite)
       continue;
-    await fs26.rm(actionDir, { recursive: true, force: true });
-    await writeSkillFiles(actionDir, skill.content, references);
-    console.log(chalk10.green(`Updated ${path25.relative(projectRoot, skillPath)}`));
+    await fs27.rm(targetDir, { recursive: true, force: true });
+    await copyDirRecursive({ src: sourceDir, dest: targetDir });
+    console.log(chalk10.green(`Updated ${relativeDir}`));
   }
 }
 async function installHookWithChecksums(target, skipPrompts) {
@@ -7156,7 +7476,7 @@ async function installHookWithChecksums(target, skipPrompts) {
   let existingConfig = {};
   if (await exists(spec.config.filePath)) {
     try {
-      existingConfig = JSON.parse(await fs26.readFile(spec.config.filePath, "utf-8"));
+      existingConfig = JSON.parse(await fs27.readFile(spec.config.filePath, "utf-8"));
     } catch {
       existingConfig = {};
     }
@@ -7193,14 +7513,13 @@ async function installHookWithChecksums(target, skipPrompts) {
       [spec.config.hookKey]: newEntries
     }
   };
-  await fs26.mkdir(path25.dirname(spec.config.filePath), { recursive: true });
-  await fs26.writeFile(spec.config.filePath, `${JSON.stringify(merged, null, 2)}
+  await fs27.mkdir(path26.dirname(spec.config.filePath), { recursive: true });
+  await fs27.writeFile(spec.config.filePath, `${JSON.stringify(merged, null, 2)}
 `);
   console.log(chalk10.green(spec.installedMsg));
 }
 async function installExternalFiles(projectRoot, devAdapters, skipPrompts) {
   await installSkillsWithChecksums(projectRoot, skipPrompts);
-  await copyStatusScript(path25.join(projectRoot, ".gauntlet"));
   for (const adapter of devAdapters) {
     if (!adapter.supportsHooks())
       continue;
@@ -7228,8 +7547,8 @@ function printPostInitInstructions(devCLINames) {
     console.log(chalk10.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 s of SKILL_DEFINITIONS) {
-      console.log(`  @.claude/skills/gauntlet-${s.action}/SKILL.md — ${s.description}`);
+    for (const action of SKILL_ACTIONS) {
+      console.log(`  @.claude/skills/gauntlet-${action}/SKILL.md — ${SKILL_DESCRIPTIONS[action]}`);
     }
   }
 }
@@ -7294,14 +7613,14 @@ entry_points: []
 #     enabled: true
 #     format: text                # Options: text, json
 `;
-  await fs26.writeFile(path25.join(targetDir, "config.yml"), content);
+  await fs27.writeFile(path26.join(targetDir, "config.yml"), content);
   console.log(chalk10.green("Created .gauntlet/config.yml"));
 }
 async function addToGitignore(projectRoot, entry) {
-  const gitignorePath = path25.join(projectRoot, ".gitignore");
+  const gitignorePath = path26.join(projectRoot, ".gitignore");
   let content = "";
   if (await exists(gitignorePath)) {
-    content = await fs26.readFile(gitignorePath, "utf-8");
+    content = await fs27.readFile(gitignorePath, "utf-8");
     const lines = content.split(`
 `).map((l) => l.trim());
     if (lines.includes(entry)) {
@@ -7311,7 +7630,7 @@ async function addToGitignore(projectRoot, entry) {
   const suffix = content.length > 0 && !content.endsWith(`
 `) ? `
 ` : "";
-  await fs26.appendFile(gitignorePath, `${suffix}${entry}
+  await fs27.appendFile(gitignorePath, `${suffix}${entry}
 `);
   console.log(chalk10.green(`Added ${entry} to .gitignore`));
 }
@@ -7346,9 +7665,14 @@ function buildAdapterSettingsBlock(adapterNames) {
     return "";
   const lines = items.map((name) => {
     const c = ADAPTER_CONFIG[name];
-    return `    ${name}:
+    let block = `    ${name}:
       allow_tool_use: ${c?.allow_tool_use}
       thinking_budget: ${c?.thinking_budget}`;
+    if (c?.model) {
+      block += `
+      model: ${c.model}`;
+    }
+    return block;
   });
   return `  # Recommended settings (see docs/eval-results.md)
   adapters:
@@ -7370,20 +7694,6 @@ async function detectAvailableCLIs() {
   }
   return available;
 }
-async function copyStatusScript(targetDir) {
-  const statusScriptDir = path25.join(targetDir, "scripts");
-  const statusScriptPath = path25.join(statusScriptDir, "status.ts");
-  await fs26.mkdir(statusScriptDir, { recursive: true });
-  if (await exists(statusScriptPath))
-    return;
-  const bundledScript = path25.join(path25.dirname(new URL(import.meta.url).pathname), "..", "scripts", "status.ts");
-  if (await exists(bundledScript)) {
-    await fs26.copyFile(bundledScript, statusScriptPath);
-    console.log(chalk10.green("Created .gauntlet/scripts/status.ts"));
-  } else {
-    console.log(chalk10.yellow("Warning: bundled status script not found; /gauntlet-status may fail."));
-  }
-}
 function hookHasCommand(entries, cmd) {
   return entries.some((hook) => {
     if (hook.command === cmd)
@@ -7401,11 +7711,11 @@ async function mergeHookConfig(opts) {
     wrapInHooksArray,
     baseConfig
   } = opts;
-  await fs26.mkdir(path25.dirname(filePath), { recursive: true });
+  await fs27.mkdir(path26.dirname(filePath), { recursive: true });
   let existing = {};
   if (await exists(filePath)) {
     try {
-      existing = JSON.parse(await fs26.readFile(filePath, "utf-8"));
+      existing = JSON.parse(await fs27.readFile(filePath, "utf-8"));
     } catch {
       existing = {};
     }
@@ -7425,7 +7735,7 @@ async function mergeHookConfig(opts) {
       [hookKey]: newEntries
     }
   };
-  await fs26.writeFile(filePath, `${JSON.stringify(merged, null, 2)}
+  await fs27.writeFile(filePath, `${JSON.stringify(merged, null, 2)}
 `);
   return true;
 }
@@ -7500,7 +7810,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: path25.join(projectRoot, cfg.dir, cfg.file),
+      filePath: path26.join(projectRoot, cfg.dir, cfg.file),
       hookKey: cfg.hookKey,
       hookEntry: cfg.entry,
       deduplicateCmd: cfg.cmd,
@@ -7679,8 +7989,8 @@ function registerReviewCommand(program) {
   });
 }
 // src/core/run-executor.ts
-import fs27 from "node:fs/promises";
-import path26 from "node:path";
+import fs28 from "node:fs/promises";
+import path27 from "node:path";
 
 // src/core/diff-stats.ts
 import { execFile as execFile2 } from "node:child_process";
@@ -7989,25 +8299,25 @@ function isProcessAlive(pid) {
   }
 }
 async function tryAcquireLock(logDir) {
-  await fs27.mkdir(logDir, { recursive: true });
-  const lockPath = path26.resolve(logDir, LOCK_FILENAME2);
+  await fs28.mkdir(logDir, { recursive: true });
+  const lockPath = path27.resolve(logDir, LOCK_FILENAME2);
   try {
-    await fs27.writeFile(lockPath, String(process.pid), { flag: "wx" });
+    await fs28.writeFile(lockPath, String(process.pid), { flag: "wx" });
     return true;
   } catch (err) {
     if (typeof err === "object" && err !== null && "code" in err && err.code === "EEXIST") {
       try {
-        const lockContent = await fs27.readFile(lockPath, "utf-8");
+        const lockContent = await fs28.readFile(lockPath, "utf-8");
         const lockPid = parseInt(lockContent.trim(), 10);
-        const lockStat = await fs27.stat(lockPath);
+        const lockStat = await fs28.stat(lockPath);
         const lockAgeMs = Date.now() - lockStat.mtimeMs;
         const pidValid = !Number.isNaN(lockPid);
         const pidDead = pidValid && !isProcessAlive(lockPid);
         const lockStale = !pidValid && lockAgeMs > STALE_LOCK_MS;
         if (pidDead || lockStale) {
-          await fs27.rm(lockPath, { force: true });
+          await fs28.rm(lockPath, { force: true });
           try {
-            await fs27.writeFile(lockPath, String(process.pid), {
+            await fs28.writeFile(lockPath, String(process.pid), {
               flag: "wx"
             });
             return true;
@@ -8023,7 +8333,7 @@ async function tryAcquireLock(logDir) {
 }
 async function findLatestConsoleLog(logDir) {
   try {
-    const files = await fs27.readdir(logDir);
+    const files = await fs28.readdir(logDir);
     let maxNum = -1;
     let latestFile = null;
     for (const file of files) {
@@ -8039,7 +8349,7 @@ async function findLatestConsoleLog(logDir) {
         }
       }
     }
-    return latestFile ? path26.join(logDir, latestFile) : null;
+    return latestFile ? path27.join(logDir, latestFile) : null;
   } catch {
     return null;
   }
@@ -8090,7 +8400,7 @@ async function executeRun(options = {}) {
   let lockAcquired = false;
   let consoleLogHandle;
   let loggerInitializedHere = false;
-  const log3 = getRunLogger();
+  const log5 = getRunLogger();
   try {
     config = await loadConfig(cwd);
     if (!isLoggerConfigured()) {
@@ -8115,7 +8425,7 @@ async function executeRun(options = {}) {
     if (options.checkInterval) {
       const stopHookConfig = resolveStopHookConfig(config.project.stop_hook, globalConfig);
       if (!stopHookConfig.enabled) {
-        log3.debug("Stop hook is disabled via configuration, skipping");
+        log5.debug("Stop hook is disabled via configuration, skipping");
         if (loggerInitializedHere) {
           await resetLogger();
         }
@@ -8129,7 +8439,7 @@ async function executeRun(options = {}) {
         const intervalMinutes = stopHookConfig.run_interval_minutes;
         const shouldRun = await shouldRunBasedOnInterval(config.project.log_dir, intervalMinutes);
         if (!shouldRun) {
-          log3.debug(`Run interval (${intervalMinutes} min) not elapsed, skipping`);
+          log5.debug(`Run interval (${intervalMinutes} min) not elapsed, skipping`);
           if (loggerInitializedHere) {
             await resetLogger();
           }
@@ -8144,7 +8454,7 @@ async function executeRun(options = {}) {
     const effectiveBaseBranch = options.baseBranch || (process.env.GITHUB_BASE_REF && (process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true") ? process.env.GITHUB_BASE_REF : null) || config.project.base_branch;
     const autoCleanResult = await shouldAutoClean(config.project.log_dir, effectiveBaseBranch);
     if (autoCleanResult.clean) {
-      log3.debug(`Auto-cleaning logs (${autoCleanResult.reason})...`);
+      log5.debug(`Auto-cleaning logs (${autoCleanResult.reason})...`);
       await debugLogger?.logClean("auto", autoCleanResult.reason || "unknown");
       await performAutoClean(config.project.log_dir, autoCleanResult, config.project.max_previous_logs);
     }
@@ -8169,7 +8479,7 @@ async function executeRun(options = {}) {
       let changeOptions;
       let passedSlotsMap;
       if (isRerun) {
-        log3.debug("Existing logs detected — running in verification mode...");
+        log5.debug("Existing logs detected — running in verification mode...");
         const { failures: previousFailures, passedSlots } = await findPreviousFailures(config.project.log_dir, options.gate, true);
         failuresMap = new Map;
         for (const gateFailure of previousFailures) {
@@ -8183,7 +8493,7 @@ async function executeRun(options = {}) {
         passedSlotsMap = passedSlots;
         if (previousFailures.length > 0) {
           const totalViolations = previousFailures.reduce((sum, gf) => sum + gf.adapterFailures.reduce((s, af) => s + af.violations.length, 0), 0);
-          log3.warn(`Found ${previousFailures.length} gate(s) with ${totalViolations} previous violation(s)`);
+          log5.warn(`Found ${previousFailures.length} gate(s) with ${totalViolations} previous violation(s)`);
         }
         changeOptions = { uncommitted: true };
         const executionState = await readExecutionState(config.project.log_dir);
@@ -8195,7 +8505,7 @@ async function executeRun(options = {}) {
         if (executionState) {
           const resolved = await resolveFixBase(executionState, effectiveBaseBranch);
           if (resolved.warning) {
-            log3.warn(`Warning: ${resolved.warning}`);
+            log5.warn(`Warning: ${resolved.warning}`);
           }
           if (resolved.fixBase) {
             changeOptions = { fixBase: resolved.fixBase };
@@ -8215,10 +8525,30 @@ async function executeRun(options = {}) {
       });
       const expander = new EntryPointExpander;
       const jobGen = new JobGenerator(config);
-      log3.debug("Detecting changes...");
+      log5.debug("Detecting changes...");
       const changes = await changeDetector.getChangedFiles();
       if (changes.length === 0) {
-        log3.info("No changes detected.");
+        if (isRerun && failuresMap && failuresMap.size === 0) {
+          const hasSkipped = await hasSkippedViolationsInLogs({
+            logDir: config.project.log_dir
+          });
+          const status2 = hasSkipped ? "passed_with_warnings" : "passed";
+          if (status2 === "passed") {
+            await debugLogger?.logClean("auto", "all_passed");
+            await cleanLogs(config.project.log_dir, config.project.max_previous_logs);
+          }
+          log5.info(getStatusMessage2(status2));
+          consoleLogHandle?.restore();
+          if (loggerInitializedHere) {
+            await resetLogger();
+          }
+          return {
+            status: status2,
+            message: getStatusMessage2(status2),
+            gatesRun: 0
+          };
+        }
+        log5.info("No changes detected.");
         consoleLogHandle?.restore();
         if (loggerInitializedHere) {
           await resetLogger();
@@ -8229,14 +8559,14 @@ async function executeRun(options = {}) {
           gatesRun: 0
         };
       }
-      log3.debug(`Found ${changes.length} changed files.`);
+      log5.debug(`Found ${changes.length} changed files.`);
       const entryPoints = await expander.expand(config.project.entry_points, changes);
       let jobs = jobGen.generateJobs(entryPoints);
       if (options.gate) {
         jobs = jobs.filter((j) => j.name === options.gate);
       }
       if (jobs.length === 0) {
-        log3.warn("No applicable gates for these changes.");
+        log5.warn("No applicable gates for these changes.");
         consoleLogHandle?.restore();
         if (loggerInitializedHere) {
           await resetLogger();
@@ -8247,7 +8577,7 @@ async function executeRun(options = {}) {
           gatesRun: 0
         };
       }
-      log3.debug(`Running ${jobs.length} gates...`);
+      log5.debug(`Running ${jobs.length} gates...`);
       const runMode = isRerun ? "verification" : "full";
       const diffStats = await computeDiffStats(effectiveBaseBranch, changeOptions || {
         commit: options.commit,
@@ -8320,8 +8650,8 @@ function registerRunCommand(program) {
   });
 }
 // src/commands/start-hook.ts
-import fs28 from "node:fs/promises";
-import path27 from "node:path";
+import fs29 from "node:fs/promises";
+import path28 from "node:path";
 import YAML7 from "yaml";
 var START_HOOK_MESSAGE = `<IMPORTANT>
 This project uses Agent Gauntlet for automated quality verification.
@@ -8369,9 +8699,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 = path27.join(process.cwd(), ".gauntlet", "config.yml");
+    const configPath = path28.join(process.cwd(), ".gauntlet", "config.yml");
     try {
-      const content = await fs28.readFile(configPath, "utf-8");
+      const content = await fs29.readFile(configPath, "utf-8");
       if (!isValidConfig(content)) {
         return;
       }
@@ -8381,7 +8711,7 @@ function registerStartHookCommand(program) {
     const adapter = options.adapter;
     try {
       const cwd = process.cwd();
-      const logDir = path27.join(cwd, await getLogDir(cwd));
+      const logDir = path28.join(cwd, await getLogDir2(cwd));
       const globalConfig = await loadGlobalConfig();
       const projectDebugLogConfig = await getDebugLogConfig(cwd);
       const debugLogConfig = mergeDebugLogConfig(projectDebugLogConfig, globalConfig.debug_log);
@@ -8392,6 +8722,12 @@ function registerStartHookCommand(program) {
     console.log(output);
   });
 }
+// src/commands/status.ts
+function registerStatusCommand(program) {
+  program.command("status").description("Show a summary of the most recent gauntlet session").action(() => {
+    main();
+  });
+}
 // src/commands/validate.ts
 import chalk13 from "chalk";
 function registerValidateCommand(program) {
@@ -8686,6 +9022,7 @@ registerHealthCommand(program);
 registerInitCommand(program);
 registerValidateCommand(program);
 registerStartHookCommand(program);
+registerStatusCommand(program);
 registerStopHookCommand(program);
 registerWaitCICommand(program);
 registerHelpCommand(program);
@@ -8694,4 +9031,4 @@ if (process.argv.length < 3) {
 }
 program.parse(process.argv);
 
-//# debugId=27272999504866CC64756E2164756E21
+//# debugId=349F4DCD1CB50C0464756E2164756E21