agent-gauntlet 0.12.0 → 0.13.0

package/dist/index.js

@@ -7,7 +7,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "agent-gauntlet",
-  version: "0.12.0",
+  version: "0.13.0",
   description: "A CLI tool for testing AI coding agents",
   license: "Apache-2.0",
   author: "Paul Caplan",
@@ -96,12 +96,12 @@ var debugLogConfigSchema = z.object({
 });
 var globalConfigSchema = z.object({
   stop_hook: z.object({
-    enabled: z.boolean().default(true),
+    enabled: z.boolean().default(false),
     run_interval_minutes: z.number().default(5),
     auto_push_pr: z.boolean().default(false),
     auto_fix_pr: z.boolean().default(false)
   }).default({
-    enabled: true,
+    enabled: false,
     run_interval_minutes: 5,
     auto_push_pr: false,
     auto_fix_pr: false
@@ -110,7 +110,7 @@ var globalConfigSchema = z.object({
 });
 var DEFAULT_GLOBAL_CONFIG = {
   stop_hook: {
-    enabled: true,
+    enabled: false,
     run_interval_minutes: 5,
     auto_push_pr: false,
     auto_fix_pr: false
@@ -905,7 +905,7 @@ ${config.fixInstructionsContent}
 // src/gates/review.ts
 import { exec as exec8 } from "node:child_process";
 import fs16 from "node:fs/promises";
-import path14 from "node:path";
+import path15 from "node:path";
 import { promisify as promisify9 } from "node:util";
 
 // src/cli-adapters/index.ts
@@ -916,13 +916,13 @@ import fs15 from "node:fs/promises";
 import { exec as exec3 } from "node:child_process";
 import fs10 from "node:fs/promises";
 import os2 from "node:os";
-import path9 from "node:path";
+import path10 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 path8 from "node:path";
+import path9 from "node:path";
 
 // src/hooks/adapters/claude-stop-hook.ts
 class ClaudeStopHookAdapter {
@@ -1014,7 +1014,7 @@ class CursorStopHookAdapter {
 // src/hooks/stop-hook-handler.ts
 import { execFile } from "node:child_process";
 import fs8 from "node:fs/promises";
-import path7 from "node:path";
+import path8 from "node:path";
 import { promisify as promisify3 } from "node:util";
 import YAML3 from "yaml";
 
@@ -1224,6 +1224,7 @@ function isLoggerConfigured() {
 
 // src/hooks/stop-hook-state.ts
 import fs7 from "node:fs/promises";
+import path7 from "node:path";
 
 // src/utils/execution-state.ts
 import { spawn } from "node:child_process";
@@ -1672,6 +1673,31 @@ async function deleteExecutionState(logDir) {
 }
 
 // src/hooks/stop-hook-state.ts
+var LOOP_WINDOW_MS = 60000;
+var LOOP_THRESHOLD = 3;
+var BLOCK_TIMESTAMPS_FILE = ".block-timestamps";
+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 deadline = Date.now() + LOCK_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    try {
+      const handle = await fs7.open(lockPath, "wx");
+      await handle.close();
+      return async () => {
+        await fs7.rm(lockPath, { force: true }).catch(() => {});
+      };
+    } catch (err) {
+      const code = err.code;
+      if (code !== "EEXIST")
+        throw err;
+      await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
+    }
+  }
+  throw new Error("Could not acquire block-timestamps lock within timeout");
+}
 async function hasFailedRunLogs(logDir) {
   try {
     const entries = await fs7.readdir(logDir);
@@ -1721,6 +1747,38 @@ async function getLastRunStatus(logDir) {
     return null;
   return null;
 }
+async function readBlockTimestamps(logDir) {
+  try {
+    const filePath = path7.join(logDir, BLOCK_TIMESTAMPS_FILE);
+    const content = await fs7.readFile(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!Array.isArray(parsed))
+      return [];
+    return parsed.filter((ts) => typeof ts === "number");
+  } catch {
+    return [];
+  }
+}
+async function recordBlockTimestamp(logDir) {
+  const release = await acquireTimestampLock(logDir);
+  try {
+    const now = Date.now();
+    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");
+    return recent;
+  } finally {
+    await release();
+  }
+}
+async function resetBlockTimestamps(logDir) {
+  try {
+    const filePath = path7.join(logDir, BLOCK_TIMESTAMPS_FILE);
+    await fs7.rm(filePath, { force: true });
+  } catch {}
+}
 
 // src/hooks/stop-hook-handler.ts
 var execFileAsync = promisify3(execFile);
@@ -1734,7 +1792,7 @@ var SKILL_INSTRUCTIONS = {
 };
 async function readProjectConfig(projectCwd) {
   try {
-    const configPath = path7.join(projectCwd, ".gauntlet", "config.yml");
+    const configPath = path8.join(projectCwd, ".gauntlet", "config.yml");
     const content = await fs8.readFile(configPath, "utf-8");
     return YAML3.parse(content);
   } catch {
@@ -1759,6 +1817,7 @@ var STATUS_MESSAGES = {
   validation_required: "✗ Validation required — changes detected that need validation before stopping.",
   no_config: "○ Not a gauntlet project — no .gauntlet/config.yml found.",
   stop_hook_active: "↺ Stop hook cycle detected — allowing stop to prevent infinite loop.",
+  loop_detected: "↺ Loop detected — stop hook blocked 3 times within 60s. Allowing stop to prevent infinite loop.",
   stop_hook_disabled: "○ Stop hook is disabled via configuration.",
   invalid_input: "⚠ Invalid hook input — could not parse JSON, allowing stop."
 };
@@ -1781,7 +1840,7 @@ async function getDebugLogConfig(projectCwd) {
 }
 async function getResolvedStopHookConfig(projectCwd) {
   try {
-    const configPath = path7.join(projectCwd, ".gauntlet", "config.yml");
+    const configPath = path8.join(projectCwd, ".gauntlet", "config.yml");
     const content = await fs8.readFile(configPath, "utf-8");
     const raw = YAML3.parse(content);
     const projectStopHookConfig = raw?.stop_hook;
@@ -2059,6 +2118,28 @@ function createEarlyExitResult(status, options) {
     intervalMinutes: options?.intervalMinutes
   };
 }
+async function applyLoopDetection(result, logDir, log, debugLogger) {
+  if (!result.shouldBlock) {
+    resetBlockTimestamps(logDir).catch(() => {});
+    return result;
+  }
+  try {
+    const timestamps = await recordBlockTimestamp(logDir);
+    if (timestamps.length >= LOOP_THRESHOLD) {
+      log.info(`Loop detected: ${timestamps.length} blocks within window — overriding to allow`);
+      await debugLogger?.logStopHook("allow", "loop_detected");
+      return {
+        status: "loop_detected",
+        shouldBlock: false,
+        message: getStatusMessage("loop_detected")
+      };
+    }
+  } catch (loopErr) {
+    const errMsg = loopErr.message ?? "unknown";
+    log.warn(`Loop detection error: ${errMsg} — proceeding with original result`);
+  }
+  return result;
+}
 function registerStopHookCommand(program) {
   program.command("stop-hook").description("Claude Code stop hook - validates gauntlet completion").action(async () => {
     let adapter = adapters[1];
@@ -2094,12 +2175,12 @@ function registerStopHookCommand(program) {
         outputResult(adapter, createEarlyExitResult("stop_hook_active"));
         return;
       }
-      const quickConfigCheck = path8.join(process.cwd(), ".gauntlet", "config.yml");
+      const quickConfigCheck = path9.join(process.cwd(), ".gauntlet", "config.yml");
       if (!await fileExists2(quickConfigCheck)) {
         outputResult(adapter, createEarlyExitResult("no_config"));
         return;
       }
-      const earlyLogDir = path8.join(process.cwd(), await getLogDir(process.cwd()));
+      const earlyLogDir = path9.join(process.cwd(), await getLogDir(process.cwd()));
       try {
         const globalConfig = await loadGlobalConfig();
         const projectDebugLogConfig = await getDebugLogConfig(process.cwd());
@@ -2110,7 +2191,7 @@ function registerStopHookCommand(program) {
       }
       await debugLogger?.logCommand("stop-hook", []);
       const markerLogDir = await getLogDir(process.cwd());
-      const markerPath = path8.join(process.cwd(), markerLogDir, STOP_HOOK_MARKER_FILE);
+      const markerPath = path9.join(process.cwd(), markerLogDir, STOP_HOOK_MARKER_FILE);
       if (await fileExists2(markerPath)) {
         const STALE_MARKER_MS = 10 * 60 * 1000;
         try {
@@ -2160,7 +2241,7 @@ function registerStopHookCommand(program) {
       log.info("Starting gauntlet validation...");
       const projectCwd = ctx.cwd;
       if (ctx.cwd !== process.cwd()) {
-        const configPath = path8.join(projectCwd, ".gauntlet", "config.yml");
+        const configPath = path9.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}`);
@@ -2168,7 +2249,7 @@ function registerStopHookCommand(program) {
           return;
         }
       }
-      const logDir = path8.join(projectCwd, await getLogDir(projectCwd));
+      const logDir = path9.join(projectCwd, await getLogDir(projectCwd));
       await initLogger({
         mode: "stop-hook",
         logDir
@@ -2185,7 +2266,7 @@ function registerStopHookCommand(program) {
         }
       }
       await debugLogger?.logStopHookDiagnostics(diagnostics);
-      markerFilePath = path8.join(logDir, STOP_HOOK_MARKER_FILE);
+      markerFilePath = path9.join(logDir, STOP_HOOK_MARKER_FILE);
       try {
         await fs9.writeFile(markerFilePath, `${process.pid}`, "utf-8");
       } catch (mkErr) {
@@ -2210,6 +2291,7 @@ function registerStopHookCommand(program) {
           markerFilePath = null;
         }
       }
+      result = await applyLoopDetection(result, logDir, log, debugLogger);
       outputResult(adapter, result);
       if (loggerInitialized) {
         try {
@@ -2429,13 +2511,13 @@ class ClaudeAdapter {
     return ".claude/commands";
   }
   getUserCommandDir() {
-    return path9.join(os2.homedir(), ".claude", "commands");
+    return path10.join(os2.homedir(), ".claude", "commands");
   }
   getProjectSkillDir() {
     return ".claude/skills";
   }
   getUserSkillDir() {
-    return path9.join(os2.homedir(), ".claude", "skills");
+    return path10.join(os2.homedir(), ".claude", "skills");
   }
   getCommandExtension() {
     return ".md";
@@ -2452,7 +2534,7 @@ class ClaudeAdapter {
 --- DIFF ---
 ${opts.diff}`;
     const tmpDir = os2.tmpdir();
-    const tmpFile = path9.join(tmpDir, `gauntlet-claude-${process.pid}-${Date.now()}.txt`);
+    const tmpFile = path10.join(tmpDir, `gauntlet-claude-${process.pid}-${Date.now()}.txt`);
     await fs10.writeFile(tmpFile, fullContent);
     const args = ["-p"];
     if (opts.allowToolUse === false) {
@@ -2508,7 +2590,7 @@ ${opts.diff}`;
 import { exec as exec4 } from "node:child_process";
 import fs11 from "node:fs/promises";
 import os3 from "node:os";
-import path10 from "node:path";
+import path11 from "node:path";
 import { promisify as promisify5 } from "node:util";
 var execAsync4 = promisify5(exec4);
 var MAX_BUFFER_BYTES3 = 10 * 1024 * 1024;
@@ -2628,7 +2710,7 @@ class CodexAdapter {
     return null;
   }
   getUserCommandDir() {
-    return path10.join(os3.homedir(), ".codex", "prompts");
+    return path11.join(os3.homedir(), ".codex", "prompts");
   }
   getProjectSkillDir() {
     return null;
@@ -2671,7 +2753,7 @@ class CodexAdapter {
 --- DIFF ---
 ${opts.diff}`;
     const tmpDir = os3.tmpdir();
-    const tmpFile = path10.join(tmpDir, `gauntlet-codex-${Date.now()}.txt`);
+    const tmpFile = path11.join(tmpDir, `gauntlet-codex-${Date.now()}.txt`);
     await fs11.writeFile(tmpFile, fullContent);
     const args = this.buildArgs(opts.allowToolUse, opts.thinkingBudget);
     const cleanup = () => fs11.unlink(tmpFile).catch(() => {});
@@ -2708,7 +2790,7 @@ ${opts.diff}`;
 import { exec as exec5 } from "node:child_process";
 import fs12 from "node:fs/promises";
 import os4 from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 import { promisify as promisify6 } from "node:util";
 var execAsync5 = promisify6(exec5);
 var MAX_BUFFER_BYTES4 = 10 * 1024 * 1024;
@@ -2761,7 +2843,7 @@ class CursorAdapter {
 --- DIFF ---
 ${opts.diff}`;
     const tmpDir = os4.tmpdir();
-    const tmpFile = path11.join(tmpDir, `gauntlet-cursor-${process.pid}-${Date.now()}.txt`);
+    const tmpFile = path12.join(tmpDir, `gauntlet-cursor-${process.pid}-${Date.now()}.txt`);
     await fs12.writeFile(tmpFile, fullContent);
     const cleanup = () => fs12.unlink(tmpFile).catch(() => {});
     if (opts.onOutput) {
@@ -2791,7 +2873,7 @@ ${opts.diff}`;
 import { exec as exec6 } from "node:child_process";
 import fs13 from "node:fs/promises";
 import os5 from "node:os";
-import path12 from "node:path";
+import path13 from "node:path";
 import { promisify as promisify7 } from "node:util";
 var execAsync6 = promisify7(exec6);
 var MAX_BUFFER_BYTES5 = 10 * 1024 * 1024;
@@ -2984,7 +3066,7 @@ class GeminiAdapter {
     return ".gemini/commands";
   }
   getUserCommandDir() {
-    return path12.join(os5.homedir(), ".gemini", "commands");
+    return path13.join(os5.homedir(), ".gemini", "commands");
   }
   getProjectSkillDir() {
     return null;
@@ -3038,7 +3120,7 @@ ${summary}
       releaseLock = resolve;
     });
     await prev;
-    const settingsPath = path12.join(process.cwd(), ".gemini", "settings.json");
+    const settingsPath = path13.join(process.cwd(), ".gemini", "settings.json");
     let backup = null;
     let existed = false;
     try {
@@ -3051,7 +3133,7 @@ ${summary}
         ...existing,
         thinkingConfig: { ...existing.thinkingConfig, thinkingBudget: budget }
       };
-      await fs13.mkdir(path12.dirname(settingsPath), { recursive: true });
+      await fs13.mkdir(path13.dirname(settingsPath), { recursive: true });
       await fs13.writeFile(settingsPath, JSON.stringify(merged, null, 2));
     } catch (err) {
       releaseLock();
@@ -3101,9 +3183,9 @@ ${summary}
 --- DIFF ---
 ${opts.diff}`;
     const tmpDir = os5.tmpdir();
-    const tmpFile = path12.join(tmpDir, `gauntlet-gemini-${process.pid}-${Date.now()}.txt`);
+    const tmpFile = path13.join(tmpDir, `gauntlet-gemini-${process.pid}-${Date.now()}.txt`);
     await fs13.writeFile(tmpFile, fullContent);
-    const telemetryFile = path12.join(process.cwd(), `.gauntlet-gemini-telemetry-${process.pid}-${Date.now()}.log`);
+    const telemetryFile = path13.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);
@@ -3150,7 +3232,7 @@ ${opts.diff}`;
 import { exec as exec7 } from "node:child_process";
 import fs14 from "node:fs/promises";
 import os6 from "node:os";
-import path13 from "node:path";
+import path14 from "node:path";
 import { promisify as promisify8 } from "node:util";
 var execAsync7 = promisify8(exec7);
 var MAX_BUFFER_BYTES6 = 10 * 1024 * 1024;
@@ -3203,7 +3285,7 @@ class GitHubCopilotAdapter {
 --- DIFF ---
 ${opts.diff}`;
     const tmpDir = os6.tmpdir();
-    const tmpFile = path13.join(tmpDir, `gauntlet-copilot-${process.pid}-${Date.now()}.txt`);
+    const tmpFile = path14.join(tmpDir, `gauntlet-copilot-${process.pid}-${Date.now()}.txt`);
     await fs14.writeFile(tmpFile, fullContent);
     const args = [
       "--allow-tool",
@@ -3754,7 +3836,7 @@ ${JSON_SYSTEM_INSTRUCTION}`;
       }
       const subResults = outputs.map((out) => {
         const specificLog = logPaths.find((p) => {
-          const filename = path14.basename(p);
+          const filename = path15.basename(p);
           return filename.includes(`_${out.adapter}@${out.reviewIndex}.`) && filename.endsWith(".log");
         });
         let logPath = specificLog;
@@ -3776,7 +3858,7 @@ ${JSON_SYSTEM_INSTRUCTION}`;
       });
       for (const skipped of skippedSlotOutputs) {
         const specificLog = logPaths.find((p) => {
-          const filename = path14.basename(p);
+          const filename = path15.basename(p);
           return filename.includes(`_${skipped.adapter}@${skipped.reviewIndex}.`) && filename.endsWith(".log");
         });
         subResults.push({
@@ -3852,6 +3934,9 @@ ${JSON_SYSTEM_INSTRUCTION}`;
       const totalEstTokens = promptEstTokens + diffEstTokens;
       const inputSizeMsg = `[input-stats] prompt_chars=${promptChars} diff_chars=${diffChars} total_chars=${totalInputChars} prompt_est_tokens=${promptEstTokens} diff_est_tokens=${diffEstTokens} total_est_tokens=${totalEstTokens}`;
       await adapterLogger(`${inputSizeMsg}
+`);
+      await adapterLogger(`[diff]
+${diff}
 `);
       const adapterCfg = adapterConfigs?.[toolName];
       const output = await adapter.execute({
@@ -4474,7 +4559,7 @@ import chalk2 from "chalk";
 
 // src/utils/log-parser.ts
 import fs17 from "node:fs/promises";
-import path15 from "node:path";
+import path16 from "node:path";
 var log2 = getCategoryLogger("log-parser");
 function parseReviewFilename(filename) {
   const m = filename.match(/^(.+)_([^@]+)@(\d+)\.(\d+)\.(log|json)$/);
@@ -4495,7 +4580,7 @@ async function parseJsonReviewFile(jsonPath) {
   try {
     const content = await fs17.readFile(jsonPath, "utf-8");
     const data = JSON.parse(content);
-    const filename = path15.basename(jsonPath);
+    const filename = path16.basename(jsonPath);
     const parsed = parseReviewFilename(filename);
     const jobId = parsed ? parsed.jobId : filename.replace(/\.\d+\.json$/, "");
     if (data.status === "pass" || data.status === "skipped_prior_pass") {
@@ -4542,7 +4627,7 @@ function extractPrefix(filename) {
 async function parseLogFile(logPath) {
   try {
     const content = await fs17.readFile(logPath, "utf-8");
-    const filename = path15.basename(logPath);
+    const filename = path16.basename(logPath);
     const parsed = parseReviewFilename(filename);
     const jobId = parsed ? parsed.jobId : extractPrefix(filename);
     if (content.includes("--- Review Output")) {
@@ -4690,9 +4775,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(path15.join(logDir, jsonFile));
+          failure = await parseJsonReviewFile(path16.join(logDir, jsonFile));
         } else if (logFile) {
-          failure = await parseLogFile(path15.join(logDir, logFile));
+          failure = await parseLogFile(path16.join(logDir, logFile));
         }
         if (failure) {
           for (const af of failure.adapterFailures) {
@@ -4824,7 +4909,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 = path15.join(logDir, fileInfo.filename);
+      const filePath = path16.join(logDir, fileInfo.filename);
       let isPassing = false;
       if (fileInfo.ext === "json") {
         isPassing = await isJsonReviewPassing(filePath);
@@ -4882,7 +4967,7 @@ async function findPreviousFailures(logDir, gateFilter, includePassedSlots) {
         gateName: "",
         entryPoint: "",
         adapterFailures,
-        logPath: path15.join(logDir, `${jobId}.log`)
+        logPath: path16.join(logDir, `${jobId}.log`)
       });
     }
     for (const [prefix, runMap] of checkPrefixMap.entries()) {
@@ -4892,9 +4977,9 @@ async function findPreviousFailures(logDir, gateFilter, includePassedSlots) {
         continue;
       let failure = null;
       if (exts.has("json")) {
-        failure = await parseJsonReviewFile(path15.join(logDir, `${prefix}.${latestRun}.json`));
+        failure = await parseJsonReviewFile(path16.join(logDir, `${prefix}.${latestRun}.json`));
       } else if (exts.has("log")) {
-        failure = await parseLogFile(path15.join(logDir, `${prefix}.${latestRun}.log`));
+        failure = await parseLogFile(path16.join(logDir, `${prefix}.${latestRun}.log`));
       }
       if (failure) {
         for (const af of failure.adapterFailures) {
@@ -5157,7 +5242,7 @@ ${chalk2.bold("━━━━━━━━━━━━━━━━━━━━━
 // src/output/console-log.ts
 import fs19 from "node:fs";
 import fsPromises2 from "node:fs/promises";
-import path16 from "node:path";
+import path17 from "node:path";
 import { inspect } from "node:util";
 var ANSI_REGEX = /\x1b\[[0-9;]*m/g;
 function stripAnsi(text) {
@@ -5167,7 +5252,7 @@ function formatArgs(args) {
   return args.map((a) => typeof a === "string" ? a : inspect(a, { depth: 4 })).join(" ");
 }
 function openLogFileExclusive(logDir, runNum) {
-  const logPath = path16.join(logDir, `console.${runNum}.log`);
+  const logPath = path17.join(logDir, `console.${runNum}.log`);
   try {
     const fd = fs19.openSync(logPath, fs19.constants.O_WRONLY | fs19.constants.O_CREAT | fs19.constants.O_EXCL);
     return { fd, logPath };
@@ -5183,7 +5268,7 @@ function openLogFileExclusive(logDir, runNum) {
 function openLogFileFallback(logDir, startNum) {
   let runNum = startNum;
   for (let attempts = 0;attempts < 100; attempts++) {
-    const logPath = path16.join(logDir, `console.${runNum}.log`);
+    const logPath = path17.join(logDir, `console.${runNum}.log`);
     try {
       const fd = fs19.openSync(logPath, fs19.constants.O_WRONLY | fs19.constants.O_CREAT | fs19.constants.O_EXCL);
       return { fd, logPath };
@@ -5269,7 +5354,7 @@ async function startConsoleLog(logDir, runNumber) {
 
 // src/output/logger.ts
 import fs20 from "node:fs/promises";
-import path17 from "node:path";
+import path18 from "node:path";
 function formatTimestamp() {
   return new Date().toISOString();
 }
@@ -5319,7 +5404,7 @@ class Logger {
     } else {
       filename = `${safeName}.${runNum}.log`;
     }
-    return path17.join(this.logDir, filename);
+    return path18.join(this.logDir, filename);
   }
   async initFile(logPath) {
     if (this.initializedFiles.has(logPath)) {
@@ -5367,7 +5452,7 @@ class Logger {
 
 // src/commands/shared.ts
 import fs21 from "node:fs/promises";
-import path18 from "node:path";
+import path19 from "node:path";
 var LOCK_FILENAME = ".gauntlet-run.lock";
 var SESSION_REF_FILENAME2 = ".session_ref";
 async function shouldAutoClean(logDir, baseBranch) {
@@ -5409,7 +5494,7 @@ async function exists(filePath) {
 }
 async function acquireLock(logDir) {
   await fs21.mkdir(logDir, { recursive: true });
-  const lockPath = path18.resolve(logDir, LOCK_FILENAME);
+  const lockPath = path19.resolve(logDir, LOCK_FILENAME);
   try {
     await fs21.writeFile(lockPath, String(process.pid), { flag: "wx" });
   } catch (err) {
@@ -5422,7 +5507,7 @@ async function acquireLock(logDir) {
   }
 }
 async function releaseLock(logDir) {
-  const lockPath = path18.resolve(logDir, LOCK_FILENAME);
+  const lockPath = path19.resolve(logDir, LOCK_FILENAME);
   try {
     await fs21.rm(lockPath, { force: true });
   } catch {}
@@ -5461,20 +5546,20 @@ function getCurrentLogFiles(files) {
 }
 async function deleteCurrentLogs(logDir) {
   const files = await fs21.readdir(logDir);
-  await Promise.all(getCurrentLogFiles(files).map((file) => fs21.rm(path18.join(logDir, file), { recursive: true, force: true })));
+  await Promise.all(getCurrentLogFiles(files).map((file) => fs21.rm(path19.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 = path18.join(logDir, oldestDir);
+  const oldestPath = path19.join(logDir, oldestDir);
   if (await exists(oldestPath)) {
     await fs21.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 = path18.join(logDir, fromName);
-    const toPath = path18.join(logDir, toName);
+    const fromPath = path19.join(logDir, fromName);
+    const toPath = path19.join(logDir, toName);
     if (await exists(fromPath)) {
       await fs21.rename(fromPath, toPath);
     }
@@ -5491,12 +5576,12 @@ async function cleanLogs(logDir, maxPreviousLogs = 3) {
       return;
     }
     await rotatePreviousDirs(logDir, maxPreviousLogs);
-    const previousDir = path18.join(logDir, "previous");
+    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(path18.join(logDir, file), path18.join(previousDir, file))));
+    await Promise.all(getCurrentLogFiles(files).map((file) => fs21.rename(path19.join(logDir, file), path19.join(previousDir, file))));
     try {
-      await fs21.rm(path18.join(logDir, SESSION_REF_FILENAME2), { force: true });
+      await fs21.rm(path19.join(logDir, SESSION_REF_FILENAME2), { force: true });
     } catch {}
   } catch (error) {
     console.warn("Failed to clean logs in", logDir, ":", error instanceof Error ? error.message : error);
@@ -5641,13 +5726,13 @@ function registerCheckCommand(program) {
 }
 // src/commands/ci/init.ts
 import fs23 from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
 import chalk4 from "chalk";
 import YAML5 from "yaml";
 
 // src/config/ci-loader.ts
 import fs22 from "node:fs/promises";
-import path19 from "node:path";
+import path20 from "node:path";
 import YAML4 from "yaml";
 
 // src/config/ci-schema.ts
@@ -5677,7 +5762,7 @@ var ciConfigSchema = z3.object({
 var GAUNTLET_DIR2 = ".gauntlet";
 var CI_FILE = "ci.yml";
 async function loadCIConfig(rootDir = process.cwd()) {
-  const ciPath = path19.join(rootDir, GAUNTLET_DIR2, CI_FILE);
+  const ciPath = path20.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.`);
   }
@@ -5685,9 +5770,9 @@ async function loadCIConfig(rootDir = process.cwd()) {
   const raw = YAML4.parse(content);
   return ciConfigSchema.parse(raw);
 }
-async function fileExists3(path20) {
+async function fileExists3(path21) {
   try {
-    const stat = await fs22.stat(path20);
+    const stat = await fs22.stat(path21);
     return stat.isFile();
   } catch {
     return false;
@@ -5778,10 +5863,10 @@ jobs:
 
 // src/commands/ci/init.ts
 async function initCI() {
-  const workflowDir = path20.join(process.cwd(), ".github", "workflows");
-  const workflowPath = path20.join(workflowDir, "gauntlet.yml");
-  const gauntletDir = path20.join(process.cwd(), ".gauntlet");
-  const ciConfigPath = path20.join(gauntletDir, "ci.yml");
+  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");
   if (!await fileExists4(ciConfigPath)) {
     console.log(chalk4.yellow("Creating starter .gauntlet/ci.yml..."));
     await fs23.mkdir(gauntletDir, { recursive: true });
@@ -5832,9 +5917,9 @@ checks:
   await fs23.writeFile(workflowPath, templateContent);
   console.log(chalk4.green("Successfully generated GitHub Actions workflow!"));
 }
-async function fileExists4(path21) {
+async function fileExists4(path22) {
   try {
-    const stat = await fs23.stat(path21);
+    const stat = await fs23.stat(path22);
     return stat.isFile();
   } catch {
     return false;
@@ -6035,12 +6120,12 @@ function printJobsByWorkDir(jobs) {
   }
 }
 // src/commands/health.ts
-import path22 from "node:path";
+import path23 from "node:path";
 import chalk7 from "chalk";
 
 // src/config/validator.ts
 import fs24 from "node:fs/promises";
-import path21 from "node:path";
+import path22 from "node:path";
 import matter2 from "gray-matter";
 import YAML6 from "yaml";
 import { ZodError } from "zod";
@@ -6051,10 +6136,10 @@ var REVIEWS_DIR2 = "reviews";
 async function validateConfig(rootDir = process.cwd()) {
   const issues = [];
   const filesChecked = [];
-  const gauntletPath = path21.join(rootDir, GAUNTLET_DIR3);
+  const gauntletPath = path22.join(rootDir, GAUNTLET_DIR3);
   const existingCheckNames = new Set;
   const existingReviewNames = new Set;
-  const configPath = path21.join(gauntletPath, CONFIG_FILE2);
+  const configPath = path22.join(gauntletPath, CONFIG_FILE2);
   let projectConfig = null;
   const checks = {};
   const reviews = {};
@@ -6108,15 +6193,15 @@ async function validateConfig(rootDir = process.cwd()) {
       message: `Error reading file: ${err.message}`
     });
   }
-  const checksPath = path21.join(gauntletPath, CHECKS_DIR2);
+  const checksPath = path22.join(gauntletPath, CHECKS_DIR2);
   if (await dirExists2(checksPath)) {
     try {
       const checkFiles = await fs24.readdir(checksPath);
       for (const file of checkFiles) {
         if (file.endsWith(".yml") || file.endsWith(".yaml")) {
-          const filePath = path21.join(checksPath, file);
+          const filePath = path22.join(checksPath, file);
           filesChecked.push(filePath);
-          const name = path21.basename(file, path21.extname(file));
+          const name = path22.basename(file, path22.extname(file));
           try {
             const content = await fs24.readFile(filePath, "utf-8");
             const raw = YAML6.parse(content);
@@ -6170,14 +6255,14 @@ async function validateConfig(rootDir = process.cwd()) {
       });
     }
   }
-  const reviewsPath = path21.join(gauntletPath, REVIEWS_DIR2);
+  const reviewsPath = path22.join(gauntletPath, REVIEWS_DIR2);
   if (await dirExists2(reviewsPath)) {
     try {
       const reviewFiles = await fs24.readdir(reviewsPath);
       const reviewNameSources = new Map;
       for (const file of reviewFiles) {
         if (file.endsWith(".md") || file.endsWith(".yml") || file.endsWith(".yaml")) {
-          const name = path21.basename(file, path21.extname(file));
+          const name = path22.basename(file, path22.extname(file));
           const sources = reviewNameSources.get(name) || [];
           sources.push(file);
           reviewNameSources.set(name, sources);
@@ -6194,8 +6279,8 @@ async function validateConfig(rootDir = process.cwd()) {
       }
       for (const file of reviewFiles) {
         if (file.endsWith(".md")) {
-          const filePath = path21.join(reviewsPath, file);
-          const reviewName = path21.basename(file, ".md");
+          const filePath = path22.join(reviewsPath, file);
+          const reviewName = path22.basename(file, ".md");
           existingReviewNames.add(reviewName);
           filesChecked.push(filePath);
           try {
@@ -6211,7 +6296,7 @@ async function validateConfig(rootDir = process.cwd()) {
             }
             validateCliPreferenceTools(frontmatter, filePath, issues);
             const parsedFrontmatter = reviewPromptFrontmatterSchema.parse(frontmatter);
-            const name = path21.basename(file, ".md");
+            const name = path22.basename(file, ".md");
             reviews[name] = parsedFrontmatter;
             reviewSourceFiles[name] = filePath;
             validateReviewSemantics(parsedFrontmatter, filePath, issues);
@@ -6219,8 +6304,8 @@ async function validateConfig(rootDir = process.cwd()) {
             handleReviewValidationError(error, filePath, issues);
           }
         } else if (file.endsWith(".yml") || file.endsWith(".yaml")) {
-          const filePath = path21.join(reviewsPath, file);
-          const reviewName = path21.basename(file, path21.extname(file));
+          const filePath = path22.join(reviewsPath, file);
+          const reviewName = path22.basename(file, path22.extname(file));
           existingReviewNames.add(reviewName);
           filesChecked.push(filePath);
           try {
@@ -6355,7 +6440,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] || path21.join(reviewsPath, `${reviewName}.md`);
+            const reviewFile = reviewSourceFiles[reviewName] || path22.join(reviewsPath, `${reviewName}.md`);
             for (let i = 0;i < pref.length; i++) {
               const tool = pref[i];
               if (!allowedTools.has(tool)) {
@@ -6481,17 +6566,17 @@ function handleReviewValidationError(error, filePath, issues) {
     }
   }
 }
-async function fileExists5(path22) {
+async function fileExists5(path23) {
   try {
-    const stat = await fs24.stat(path22);
+    const stat = await fs24.stat(path23);
     return stat.isFile();
   } catch {
     return false;
   }
 }
-async function dirExists2(path22) {
+async function dirExists2(path23) {
   try {
-    const stat = await fs24.stat(path22);
+    const stat = await fs24.stat(path23);
     return stat.isDirectory();
   } catch {
     return false;
@@ -6507,7 +6592,7 @@ function registerHealthCommand(program) {
       console.log(chalk7.yellow("  No config files found"));
     } else {
       for (const file of validationResult.filesChecked) {
-        const relativePath = path22.relative(process.cwd(), file);
+        const relativePath = path23.relative(process.cwd(), file);
         console.log(chalk7.dim(`  ${relativePath}`));
       }
       if (validationResult.valid && validationResult.issues.length === 0) {
@@ -6515,7 +6600,7 @@ function registerHealthCommand(program) {
       } else {
         const issuesByFile = new Map;
         for (const issue of validationResult.issues) {
-          const relativeFile = path22.relative(process.cwd(), issue.file);
+          const relativeFile = path23.relative(process.cwd(), issue.file);
           if (!issuesByFile.has(relativeFile)) {
             issuesByFile.set(relativeFile, []);
           }
@@ -6636,19 +6721,21 @@ function registerHelpCommand(program) {
 // src/commands/init.ts
 import { readFileSync } from "node:fs";
 import fs25 from "node:fs/promises";
-import path23 from "node:path";
-import readline from "node:readline";
+import path24 from "node:path";
 import { fileURLToPath } from "node:url";
 import chalk9 from "chalk";
-var __dirname2 = path23.dirname(fileURLToPath(import.meta.url));
+var __dirname2 = path24.dirname(fileURLToPath(import.meta.url));
 function readSkillTemplate(filename) {
-  const templatePath = path23.join(__dirname2, "skill-templates", filename);
+  const templatePath = path24.join(__dirname2, "skill-templates", filename);
   return readFileSync(templatePath, "utf-8");
 }
-var MAX_PROMPT_ATTEMPTS = 10;
-function makeQuestion(rl) {
-  return (prompt) => new Promise((resolve) => rl.question(prompt, (a) => resolve(a?.trim() ?? "")));
-}
+var CLI_PREFERENCE_ORDER = [
+  "codex",
+  "claude",
+  "cursor",
+  "github-copilot",
+  "gemini"
+];
 var ADAPTER_CONFIG = {
   claude: { allow_tool_use: false, thinking_budget: "high" },
   codex: { allow_tool_use: false, thinking_budget: "low" },
@@ -6770,9 +6857,9 @@ var SKILL_DEFINITIONS = [
   }
 ];
 function registerInitCommand(program) {
-  program.command("init").description("Initialize .gauntlet configuration").option("-y, --yes", "Skip prompts and use defaults (all available CLIs)").action(async (options) => {
+  program.command("init").description("Initialize .gauntlet configuration").option("-y, --yes", "Skip prompts and use defaults").action(async (options) => {
     const projectRoot = process.cwd();
-    const targetDir = path23.join(projectRoot, ".gauntlet");
+    const targetDir = path24.join(projectRoot, ".gauntlet");
     if (await exists(targetDir)) {
       console.log(chalk9.yellow(".gauntlet directory already exists."));
       return;
@@ -6780,76 +6867,144 @@ function registerInitCommand(program) {
     console.log("Detecting available CLI agents...");
     const availableAdapters = await detectAvailableCLIs();
     if (availableAdapters.length === 0) {
-      console.log();
-      console.log(chalk9.red("Error: No CLI agents found. Install at least one:"));
-      console.log("  - Claude: https://docs.anthropic.com/en/docs/claude-code");
-      console.log("  - Gemini: https://github.com/google-gemini/gemini-cli");
-      console.log("  - Codex: https://github.com/openai/codex");
-      console.log();
+      printNoCLIsMessage();
       return;
     }
-    const baseBranch = await detectBaseBranch();
-    await fs25.mkdir(targetDir);
-    await fs25.mkdir(path23.join(targetDir, "checks"));
-    await fs25.mkdir(path23.join(targetDir, "reviews"));
-    const commands = SKILL_DEFINITIONS.map((skill) => ({
-      action: skill.action,
-      content: skill.content,
-      ..."references" in skill ? { references: skill.references } : {},
-      ..."skillsOnly" in skill ? { skillsOnly: skill.skillsOnly } : {}
-    }));
-    let installedNames;
-    if (options.yes) {
-      installedNames = availableAdapters.map((a) => a.name);
-      const adaptersToInstall = availableAdapters.filter((a) => a.getProjectCommandDir() !== null || a.getProjectSkillDir() !== null);
-      if (adaptersToInstall.length > 0) {
-        await installCommands({
-          level: "project",
-          agentNames: adaptersToInstall.map((a) => a.name),
-          projectRoot,
-          commands
-        });
-      }
-    } else {
-      installedNames = await promptAndInstallCommands({
-        projectRoot,
-        commands,
-        availableAdapters
-      });
+    await scaffoldProject({
+      projectRoot,
+      targetDir,
+      availableAdapters,
+      skipPrompts: options.yes ?? false
+    });
+    if (availableAdapters.some((a) => a.name === "claude")) {
+      await installStopHook(projectRoot);
+    }
+    if (availableAdapters.some((a) => a.name === "cursor")) {
+      await installCursorStopHook(projectRoot);
     }
-    const cliList = availableAdapters.map((a) => `    - ${a.name}`).join(`
+    await addToGitignore(projectRoot, "gauntlet_logs");
+    console.log();
+    console.log(chalk9.bold("Run /gauntlet-setup to configure your checks and reviews"));
+  });
+}
+function printNoCLIsMessage() {
+  console.log();
+  console.log(chalk9.red("Error: No CLI agents found. Install at least one:"));
+  console.log("  - Claude: https://docs.anthropic.com/en/docs/claude-code");
+  console.log("  - Gemini: https://github.com/google-gemini/gemini-cli");
+  console.log("  - Codex: https://github.com/openai/codex");
+  console.log();
+}
+async function scaffoldProject(options) {
+  const { projectRoot, targetDir, availableAdapters, skipPrompts } = options;
+  await fs25.mkdir(targetDir);
+  await fs25.mkdir(path24.join(targetDir, "checks"));
+  await fs25.mkdir(path24.join(targetDir, "reviews"));
+  const commands = SKILL_DEFINITIONS.map((skill) => ({
+    action: skill.action,
+    content: skill.content,
+    ..."references" in skill ? { references: skill.references } : {},
+    ..."skillsOnly" in skill ? { skillsOnly: skill.skillsOnly } : {}
+  }));
+  if (skipPrompts) {
+    await installCommands({
+      level: "project",
+      agentNames: ["claude"],
+      projectRoot,
+      commands
+    });
+  } else {
+    await promptAndInstallCommands({ projectRoot, commands });
+  }
+  await writeConfigYml(targetDir, availableAdapters);
+  await fs25.writeFile(path24.join(targetDir, "reviews", "code-quality.yml"), `builtin: code-quality
+num_reviews: 1
 `);
-    const adapterSettings = buildAdapterSettingsBlock(availableAdapters);
-    const configContent = `base_branch: ${baseBranch}
-log_dir: gauntlet_logs
-
-# Run gates in parallel when possible (default: true)
-# allow_parallel: true
-
+  console.log(chalk9.green("Created .gauntlet/reviews/code-quality.yml"));
+  await copyStatusScript(targetDir);
+}
+async function writeConfigYml(targetDir, adapters3) {
+  const baseBranch = await detectBaseBranch();
+  const sortedAdapters = [...adapters3].sort((a, b) => CLI_PREFERENCE_ORDER.indexOf(a.name) - CLI_PREFERENCE_ORDER.indexOf(b.name));
+  const cliList = sortedAdapters.map((a) => `    - ${a.name}`).join(`
+`);
+  const adapterSettings = buildAdapterSettingsBlock(adapters3);
+  const content = `# Ordered list of CLI agents to try for reviews
 cli:
   default_preference:
 ${cliList}
 ${adapterSettings}
 # entry_points configured by /gauntlet-setup
 entry_points: []
+
+# -------------------------------------------------------------------
+# All settings below are optional. Uncomment and change as needed.
+# -------------------------------------------------------------------
+
+# Git ref for detecting local changes via git diff (default: origin/main)
+# base_branch: ${baseBranch}
+
+# Directory for per-job logs (default: gauntlet_logs)
+# log_dir: gauntlet_logs
+
+# Run gates in parallel when possible (default: true)
+# allow_parallel: true
+
+# Maximum retry attempts before declaring "Retry limit exceeded" (default: 3)
+# max_retries: 3
+
+# Archived session directories to keep during log rotation (default: 3, 0 = disable)
+# max_previous_logs: 3
+
+# Priority threshold for filtering new violations during reruns (default: medium)
+# Options: critical, high, medium, low
+# rerun_new_issue_threshold: medium
+
+# Stop hook — auto-run gauntlet when the agent stops
+# Precedence: env vars > project config > global config (~/.config/agent-gauntlet/config.yml)
+# Env overrides: GAUNTLET_STOP_HOOK_ENABLED, GAUNTLET_STOP_HOOK_INTERVAL_MINUTES,
+#                GAUNTLET_AUTO_PUSH_PR, GAUNTLET_AUTO_FIX_PR
+# stop_hook:
+#   enabled: false
+#   run_interval_minutes: 5       # Minimum minutes between runs (0 = always run)
+#   auto_push_pr: false           # Check/create PR after gates pass
+#   auto_fix_pr: false            # Wait for CI checks after PR (requires auto_push_pr)
+
+# Debug log — persistent debug logging to .debug.log
+# debug_log:
+#   enabled: false
+#   max_size_mb: 10               # Max size before rotation to .debug.log.1
+
+# Structured logging via LogTape
+# logging:
+#   level: debug                  # Options: debug, info, warning, error
+#   console:
+#     enabled: true
+#     format: pretty              # Options: pretty, json
+#   file:
+#     enabled: true
+#     format: text                # Options: text, json
 `;
-    await fs25.writeFile(path23.join(targetDir, "config.yml"), configContent);
-    console.log(chalk9.green("Created .gauntlet/config.yml"));
-    const reviewYamlContent = `builtin: code-quality
-num_reviews: 1
-`;
-    await fs25.writeFile(path23.join(targetDir, "reviews", "code-quality.yml"), reviewYamlContent);
-    console.log(chalk9.green("Created .gauntlet/reviews/code-quality.yml"));
-    await copyStatusScript(targetDir);
-    if (installedNames.includes("claude")) {
-      await installStopHook(projectRoot);
-    }
-    if (installedNames.includes("cursor")) {
-      await installCursorStopHook(projectRoot);
+  await fs25.writeFile(path24.join(targetDir, "config.yml"), content);
+  console.log(chalk9.green("Created .gauntlet/config.yml"));
+}
+async function addToGitignore(projectRoot, entry) {
+  const gitignorePath = path24.join(projectRoot, ".gitignore");
+  let content = "";
+  if (await exists(gitignorePath)) {
+    content = await fs25.readFile(gitignorePath, "utf-8");
+    const lines = content.split(`
+`).map((l) => l.trim());
+    if (lines.includes(entry)) {
+      return;
     }
-    console.log();
-    console.log(chalk9.bold("Run /gauntlet-setup to configure your checks and reviews"));
-  });
+  }
+  const suffix = content.length > 0 && !content.endsWith(`
+`) ? `
+` : "";
+  await fs25.appendFile(gitignorePath, `${suffix}${entry}
+`);
+  console.log(chalk9.green(`Added ${entry} to .gitignore`));
 }
 async function detectBaseBranch() {
   try {
@@ -6878,7 +7033,7 @@ ${lines.join(`
 `;
 }
 async function detectAvailableCLIs() {
-  const allAdapters = getAllAdapters();
+  const allAdapters = [...getAllAdapters()].sort((a, b) => CLI_PREFERENCE_ORDER.indexOf(a.name) - CLI_PREFERENCE_ORDER.indexOf(b.name));
   const available = [];
   for (const adapter of allAdapters) {
     const isAvailable = await adapter.isAvailable();
@@ -6891,31 +7046,13 @@ async function detectAvailableCLIs() {
   }
   return available;
 }
-function parseSelections(selections, adapters3) {
-  const chosen = [];
-  for (const sel of selections) {
-    const num = parseInt(sel, 10);
-    if (Number.isNaN(num) || num < 1 || num > adapters3.length + 1) {
-      console.log(chalk9.yellow(`Invalid selection: ${sel}`));
-      return null;
-    }
-    if (num === adapters3.length + 1) {
-      chosen.push(...adapters3);
-    } else {
-      const adapter = adapters3[num - 1];
-      if (adapter)
-        chosen.push(adapter);
-    }
-  }
-  return [...new Set(chosen)];
-}
 async function copyStatusScript(targetDir) {
-  const statusScriptDir = path23.join(targetDir, "skills", "gauntlet", "status", "scripts");
-  const statusScriptPath = path23.join(statusScriptDir, "status.ts");
+  const statusScriptDir = path24.join(targetDir, "skills", "gauntlet", "status", "scripts");
+  const statusScriptPath = path24.join(statusScriptDir, "status.ts");
   await fs25.mkdir(statusScriptDir, { recursive: true });
   if (await exists(statusScriptPath))
     return;
-  const bundledScript = path23.join(path23.dirname(new URL(import.meta.url).pathname), "..", "scripts", "status.ts");
+  const bundledScript = path24.join(path24.dirname(new URL(import.meta.url).pathname), "..", "scripts", "status.ts");
   if (await exists(bundledScript)) {
     await fs25.copyFile(bundledScript, statusScriptPath);
     console.log(chalk9.green("Created .gauntlet/skills/gauntlet/status/scripts/status.ts"));
@@ -6923,117 +7060,36 @@ async function copyStatusScript(targetDir) {
     console.log(chalk9.yellow("Warning: bundled status script not found; /gauntlet-status may fail."));
   }
 }
-async function promptInstallLevel(questionFn) {
-  console.log("Where would you like to install the /gauntlet command?");
-  console.log("  1) Don't install commands");
-  console.log("  2) Project level (in this repo's .claude/skills, .gemini/commands, etc.)");
-  console.log("  3) User level (in ~/.claude/skills, ~/.gemini/commands, etc.)");
-  console.log();
-  let answer = await questionFn("Select option [1-3]: ");
-  let attempts = 0;
-  while (true) {
-    attempts++;
-    if (attempts > MAX_PROMPT_ATTEMPTS)
-      throw new Error("Too many invalid attempts");
-    if (answer === "1")
-      return "none";
-    if (answer === "2")
-      return "project";
-    if (answer === "3")
-      return "user";
-    console.log(chalk9.yellow("Please enter 1, 2, or 3"));
-    answer = await questionFn("Select option [1-3]: ");
-  }
-}
-async function promptAgentSelection(questionFn, installableAdapters) {
-  console.log();
-  console.log("Which CLI agents would you like to install the command for?");
-  installableAdapters.forEach((adapter, i) => {
-    console.log(`  ${i + 1}) ${adapter.name}`);
-  });
-  console.log(`  ${installableAdapters.length + 1}) All of the above`);
-  console.log();
-  const promptText = `Select options (comma-separated, e.g., 1,2 or ${installableAdapters.length + 1} for all): `;
-  let answer = await questionFn(promptText);
-  let attempts = 0;
-  while (true) {
-    attempts++;
-    if (attempts > MAX_PROMPT_ATTEMPTS)
-      throw new Error("Too many invalid attempts");
-    const selections = answer.split(",").map((s) => s.trim()).filter((s) => s);
-    if (selections.length === 0) {
-      console.log(chalk9.yellow("Please select at least one option"));
-      answer = await questionFn(promptText);
-      continue;
-    }
-    const chosen = parseSelections(selections, installableAdapters);
-    if (chosen)
-      return chosen.map((a) => a.name);
-    answer = await questionFn(promptText);
-  }
-}
 async function promptAndInstallCommands(options) {
-  const { projectRoot, commands, availableAdapters } = options;
-  if (availableAdapters.length === 0)
-    return [];
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
+  const { projectRoot, commands } = options;
+  await installCommands({
+    level: "project",
+    agentNames: ["claude"],
+    projectRoot,
+    commands
   });
-  const question = makeQuestion(rl);
-  try {
-    console.log();
-    console.log(chalk9.bold("CLI Agent Command Setup"));
-    console.log(chalk9.dim("The gauntlet command can be installed for CLI agents so you can run /gauntlet directly."));
-    console.log();
-    const installLevel = await promptInstallLevel(question);
-    if (installLevel === "none") {
-      console.log(chalk9.dim(`
-Skipping command installation.`));
-      rl.close();
-      return [];
-    }
-    const installableAdapters = installLevel === "project" ? availableAdapters.filter((a) => a.getProjectCommandDir() !== null || a.getProjectSkillDir() !== null) : availableAdapters.filter((a) => a.getUserCommandDir() !== null || a.getUserSkillDir() !== null);
-    if (installableAdapters.length === 0) {
-      console.log(chalk9.yellow(`No available agents support ${installLevel}-level commands.`));
-      rl.close();
-      return [];
-    }
-    const selectedAgents = await promptAgentSelection(question, installableAdapters);
-    rl.close();
-    await installCommands({
-      level: installLevel,
-      agentNames: selectedAgents,
-      projectRoot,
-      commands
-    });
-    return selectedAgents;
-  } catch (error) {
-    rl.close();
-    throw error;
-  }
 }
 async function installSkill(skillDir, ctx, command) {
-  const actionDir = path23.join(skillDir, `gauntlet-${command.action}`);
-  const skillPath = path23.join(actionDir, "SKILL.md");
+  const actionDir = path24.join(skillDir, `gauntlet-${command.action}`);
+  const skillPath = path24.join(actionDir, "SKILL.md");
   await fs25.mkdir(actionDir, { recursive: true });
   if (await exists(skillPath)) {
-    const relPath2 = ctx.isUserLevel ? skillPath : path23.relative(ctx.projectRoot, skillPath);
+    const relPath2 = ctx.isUserLevel ? skillPath : path24.relative(ctx.projectRoot, skillPath);
     console.log(chalk9.dim(`  claude: ${relPath2} already exists, skipping`));
     return;
   }
   await fs25.writeFile(skillPath, command.content);
-  const relPath = ctx.isUserLevel ? skillPath : path23.relative(ctx.projectRoot, skillPath);
+  const relPath = ctx.isUserLevel ? skillPath : path24.relative(ctx.projectRoot, skillPath);
   console.log(chalk9.green(`Created ${relPath}`));
   if (command.references) {
-    const refsDir = path23.join(actionDir, "references");
+    const refsDir = path24.join(actionDir, "references");
     await fs25.mkdir(refsDir, { recursive: true });
     for (const [fileName, fileContent] of Object.entries(command.references)) {
-      const refPath = path23.join(refsDir, fileName);
+      const refPath = path24.join(refsDir, fileName);
       if (await exists(refPath))
         continue;
       await fs25.writeFile(refPath, fileContent);
-      const refRelPath = ctx.isUserLevel ? refPath : path23.relative(ctx.projectRoot, refPath);
+      const refRelPath = ctx.isUserLevel ? refPath : path24.relative(ctx.projectRoot, refPath);
       console.log(chalk9.green(`Created ${refRelPath}`));
     }
   }
@@ -7041,19 +7097,19 @@ async function installSkill(skillDir, ctx, command) {
 async function installFlatCommand(adapter, commandDir, ctx, command) {
   const name = command.action === "run" ? "gauntlet" : command.action;
   const fileName = `${name}${adapter.getCommandExtension()}`;
-  const filePath = path23.join(commandDir, fileName);
+  const filePath = path24.join(commandDir, fileName);
   if (await exists(filePath)) {
-    const relPath2 = ctx.isUserLevel ? filePath : path23.relative(ctx.projectRoot, filePath);
+    const relPath2 = ctx.isUserLevel ? filePath : path24.relative(ctx.projectRoot, filePath);
     console.log(chalk9.dim(`  ${adapter.name}: ${relPath2} already exists, skipping`));
     return;
   }
   const transformedContent = adapter.transformCommand(command.content);
   await fs25.writeFile(filePath, transformedContent);
-  const relPath = ctx.isUserLevel ? filePath : path23.relative(ctx.projectRoot, filePath);
+  const relPath = ctx.isUserLevel ? filePath : path24.relative(ctx.projectRoot, filePath);
   console.log(chalk9.green(`Created ${relPath}`));
 }
 async function installSkillsForAdapter(adapter, skillDir, ctx, commands) {
-  const resolvedSkillDir = ctx.isUserLevel ? skillDir : path23.join(ctx.projectRoot, skillDir);
+  const resolvedSkillDir = ctx.isUserLevel ? skillDir : path24.join(ctx.projectRoot, skillDir);
   try {
     for (const command of commands) {
       await installSkill(resolvedSkillDir, ctx, command);
@@ -7064,7 +7120,7 @@ async function installSkillsForAdapter(adapter, skillDir, ctx, commands) {
   }
 }
 async function installFlatCommandsForAdapter(adapter, commandDir, ctx, commands) {
-  const resolvedCommandDir = ctx.isUserLevel ? commandDir : path23.join(ctx.projectRoot, commandDir);
+  const resolvedCommandDir = ctx.isUserLevel ? commandDir : path24.join(ctx.projectRoot, commandDir);
   try {
     await fs25.mkdir(resolvedCommandDir, { recursive: true });
     const flatCommands = commands.filter((c) => c.action !== "check" && c.action !== "status" && !c.skillsOnly);
@@ -7126,8 +7182,8 @@ var CURSOR_STOP_HOOK_CONFIG = {
   }
 };
 async function installStopHook(projectRoot) {
-  const claudeDir = path23.join(projectRoot, ".claude");
-  const settingsPath = path23.join(claudeDir, "settings.local.json");
+  const claudeDir = path24.join(projectRoot, ".claude");
+  const settingsPath = path24.join(claudeDir, "settings.local.json");
   await fs25.mkdir(claudeDir, { recursive: true });
   let existingSettings = {};
   if (await exists(settingsPath)) {
@@ -7158,8 +7214,8 @@ async function installStopHook(projectRoot) {
   console.log(chalk9.green("Stop hook installed - gauntlet will run automatically when agent stops"));
 }
 async function installCursorStopHook(projectRoot) {
-  const cursorDir = path23.join(projectRoot, ".cursor");
-  const hooksPath = path23.join(cursorDir, "hooks.json");
+  const cursorDir = path24.join(projectRoot, ".cursor");
+  const hooksPath = path24.join(cursorDir, "hooks.json");
   await fs25.mkdir(cursorDir, { recursive: true });
   let existingConfig = {};
   if (await exists(hooksPath)) {
@@ -7362,7 +7418,7 @@ function registerReviewCommand(program) {
 }
 // src/core/run-executor.ts
 import fs26 from "node:fs/promises";
-import path24 from "node:path";
+import path25 from "node:path";
 
 // src/core/diff-stats.ts
 import { execFile as execFile2 } from "node:child_process";
@@ -7672,7 +7728,7 @@ function isProcessAlive(pid) {
 }
 async function tryAcquireLock(logDir) {
   await fs26.mkdir(logDir, { recursive: true });
-  const lockPath = path24.resolve(logDir, LOCK_FILENAME2);
+  const lockPath = path25.resolve(logDir, LOCK_FILENAME2);
   try {
     await fs26.writeFile(lockPath, String(process.pid), { flag: "wx" });
     return true;
@@ -7721,7 +7777,7 @@ async function findLatestConsoleLog(logDir) {
         }
       }
     }
-    return latestFile ? path24.join(logDir, latestFile) : null;
+    return latestFile ? path25.join(logDir, latestFile) : null;
   } catch {
     return null;
   }
@@ -7750,6 +7806,7 @@ var statusMessages = {
   error: "Unexpected error occurred.",
   no_config: "No .gauntlet/config.yml found.",
   stop_hook_active: "Stop hook already active.",
+  loop_detected: "Loop detected — rapid blocks overridden.",
   interval_not_elapsed: "Run interval not elapsed.",
   invalid_input: "Invalid input.",
   stop_hook_disabled: "Stop hook is disabled via configuration.",
@@ -8301,4 +8358,4 @@ if (process.argv.length < 3) {
 }
 program.parse(process.argv);
 
-//# debugId=5D4AF6110EC21D0564756E2164756E21
+//# debugId=D6CA917DC551041A64756E2164756E21