agent-gauntlet 0.15.4 → 1.0.0

package/dist/index.js

@@ -299,7 +299,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "agent-gauntlet",
-  version: "0.15.4",
+  version: "1.0.0",
   description: "A CLI tool for testing AI coding agents",
   license: "MIT",
   author: "Paul Caplan",
@@ -349,8 +349,7 @@ var package_default = {
     detect: "bun src/index.ts detect",
     list: "bun src/index.ts list",
     health: "bun src/index.ts health",
-    validate: "bun src/index.ts validate",
-    "wait-ci": "bun src/index.ts wait-ci"
+    validate: "bun src/index.ts validate"
   },
   devDependencies: {
     "@biomejs/biome": "^2.4.3",
@@ -391,23 +390,17 @@ var debugLogConfigSchema = z.object({
 var globalConfigSchema = z.object({
   stop_hook: z.object({
     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)
+    run_interval_minutes: z.number().default(5)
   }).default({
     enabled: false,
-    run_interval_minutes: 5,
-    auto_push_pr: false,
-    auto_fix_pr: false
+    run_interval_minutes: 5
   }),
   debug_log: debugLogConfigSchema.default({ enabled: false, max_size_mb: 10 })
 });
 var DEFAULT_GLOBAL_CONFIG = {
   stop_hook: {
     enabled: false,
-    run_interval_minutes: 5,
-    auto_push_pr: false,
-    auto_fix_pr: false
+    run_interval_minutes: 5
   },
   debug_log: {
     enabled: false,
@@ -625,9 +618,7 @@ var loggingConfigSchema = z2.object({
 });
 var stopHookConfigSchema = z2.object({
   enabled: z2.boolean().optional(),
-  run_interval_minutes: z2.number().int().min(0).optional(),
-  auto_push_pr: z2.boolean().optional(),
-  auto_fix_pr: z2.boolean().optional()
+  run_interval_minutes: z2.number().int().min(0).optional()
 });
 var gauntletConfigSchema = z2.object({
   base_branch: z2.string().min(1).default("origin/main"),
@@ -1371,7 +1362,7 @@ import { exec as exec3 } from "node:child_process";
 import fs12 from "node:fs/promises";
 import os2 from "node:os";
 import path11 from "node:path";
-import { promisify as promisify4 } from "node:util";
+import { promisify as promisify3 } from "node:util";
 
 // src/commands/stop-hook.ts
 import fsSync from "node:fs";
@@ -1469,17 +1460,13 @@ class CursorStopHookAdapter {
 }
 
 // src/hooks/stop-hook-handler.ts
-import { execFile } from "node:child_process";
 import fs10 from "node:fs/promises";
 import path9 from "node:path";
-import { promisify as promisify3 } from "node:util";
 import YAML3 from "yaml";
 
 // src/config/stop-hook-config.ts
 var GAUNTLET_STOP_HOOK_ENABLED = "GAUNTLET_STOP_HOOK_ENABLED";
 var GAUNTLET_STOP_HOOK_INTERVAL_MINUTES = "GAUNTLET_STOP_HOOK_INTERVAL_MINUTES";
-var GAUNTLET_AUTO_PUSH_PR = "GAUNTLET_AUTO_PUSH_PR";
-var GAUNTLET_AUTO_FIX_PR = "GAUNTLET_AUTO_FIX_PR";
 function parseBooleanEnv(envVar) {
   if (envVar === undefined)
     return;
@@ -1503,9 +1490,7 @@ function parseIntegerEnv(envVar) {
 function parseStopHookEnvVars() {
   return {
     enabled: parseBooleanEnv(process.env[GAUNTLET_STOP_HOOK_ENABLED]),
-    run_interval_minutes: parseIntegerEnv(process.env[GAUNTLET_STOP_HOOK_INTERVAL_MINUTES]),
-    auto_push_pr: parseBooleanEnv(process.env[GAUNTLET_AUTO_PUSH_PR]),
-    auto_fix_pr: parseBooleanEnv(process.env[GAUNTLET_AUTO_FIX_PR])
+    run_interval_minutes: parseIntegerEnv(process.env[GAUNTLET_STOP_HOOK_INTERVAL_MINUTES])
   };
 }
 function resolveField(envValue, projectValue, globalValue) {
@@ -1520,13 +1505,7 @@ function resolveStopHookConfig(projectConfig, globalConfig) {
   const globalStop = globalConfig.stop_hook;
   const enabled = resolveField(envVars.enabled, projectConfig?.enabled, globalStop.enabled);
   const run_interval_minutes = resolveField(envVars.run_interval_minutes, projectConfig?.run_interval_minutes, globalStop.run_interval_minutes);
-  const auto_push_pr = resolveField(envVars.auto_push_pr, projectConfig?.auto_push_pr, globalStop.auto_push_pr);
-  let auto_fix_pr = resolveField(envVars.auto_fix_pr, projectConfig?.auto_fix_pr, globalStop.auto_fix_pr);
-  if (auto_fix_pr && !auto_push_pr) {
-    console.error("[gauntlet] Warning: auto_fix_pr=true requires auto_push_pr=true. Treating auto_fix_pr as false.");
-    auto_fix_pr = false;
-  }
-  return { enabled, run_interval_minutes, auto_push_pr, auto_fix_pr };
+  return { enabled, run_interval_minutes };
 }
 
 // src/output/app-logger.ts
@@ -2214,12 +2193,6 @@ async function hasChangesVsBaseBranch(cwd, baseBranch) {
     return true;
   }
 }
-async function getLastRunStatus(logDir) {
-  const state = await readExecutionState(logDir);
-  if (!state)
-    return null;
-  return null;
-}
 async function readBlockTimestamps(logDir) {
   try {
     const filePath = path8.join(logDir, BLOCK_TIMESTAMPS_FILE);
@@ -2254,14 +2227,9 @@ async function resetBlockTimestamps(logDir) {
 }
 
 // src/hooks/stop-hook-handler.ts
-var execFileAsync = promisify3(execFile);
 var DEFAULT_LOG_DIR = "gauntlet_logs";
 var SKILL_INSTRUCTIONS = {
-  validation_required: "Changes detected, you must use the `gauntlet-run` skill to validate them now.",
-  pr_push_required: "Gauntlet passed. You must use the `gauntlet-push-pr` skill to create or update your pull request.",
-  pr_push_required_with_warnings: "Gauntlet passed with warnings (some issues were skipped). You must use the `gauntlet-push-pr` skill to create or update your pull request. Include a summary of skipped issues in the PR description.",
-  ci_pending: "PR is up to date but CI checks are still running. You must use the `gauntlet-fix-pr` skill to poll CI status until checks complete, then fix any failures.",
-  ci_failed: "PR is up to date but CI checks have failed. You must use the `gauntlet-fix-pr` skill to check which CI checks failed, fix the issues, and push."
+  validation_required: "Changes detected, you must use the `gauntlet-run` skill to validate them now."
 };
 async function readProjectConfig(projectCwd) {
   try {
@@ -2283,10 +2251,6 @@ var STATUS_MESSAGES = {
   retry_limit_exceeded: "⚠ Gauntlet terminated — retry limit exceeded. Run `agent-gauntlet clean` to archive and continue.",
   lock_conflict: "⏭ Gauntlet skipped — another gauntlet run is already in progress.",
   failed: "✗ Gauntlet failed — issues must be fixed before stopping.",
-  pr_push_required: "✓ Gauntlet passed — PR needs to be created or updated before stopping.",
-  ci_pending: "⏳ CI checks still running — waiting for completion.",
-  ci_failed: "✗ CI failed or review changes requested — fix issues and push.",
-  ci_passed: "✓ CI passed — all checks completed and no blocking reviews.",
   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.",
@@ -2323,71 +2287,6 @@ async function getResolvedStopHookConfig(projectCwd) {
     return null;
   }
 }
-async function checkPRStatus(cwd) {
-  try {
-    try {
-      await execFileAsync("gh", ["--version"], { cwd });
-    } catch {
-      return {
-        prExists: false,
-        upToDate: false,
-        error: "gh CLI not installed"
-      };
-    }
-    let prInfo;
-    try {
-      const { stdout } = await execFileAsync("gh", ["pr", "view", "--json", "number,state,headRefOid"], { cwd });
-      prInfo = JSON.parse(stdout.trim());
-    } catch (e) {
-      const errMsg = e.message ?? "unknown";
-      if (errMsg.includes("no pull requests found") || errMsg.includes("Could not resolve")) {
-        return { prExists: false, upToDate: false };
-      }
-      return {
-        prExists: false,
-        upToDate: false,
-        error: `gh pr view failed: ${errMsg}`
-      };
-    }
-    if (prInfo.state !== "OPEN") {
-      return { prExists: false, upToDate: false };
-    }
-    const { stdout: localHead } = await execFileAsync("git", ["rev-parse", "HEAD"], { cwd });
-    const localSha = localHead.trim();
-    const upToDate = prInfo.headRefOid === localSha;
-    return {
-      prExists: true,
-      upToDate,
-      prNumber: prInfo.number
-    };
-  } catch (error) {
-    const errMsg = error.message ?? "unknown";
-    return {
-      prExists: false,
-      upToDate: false,
-      error: `PR status check failed: ${errMsg}`
-    };
-  }
-}
-async function checkCIStatus(cwd) {
-  try {
-    const { stdout } = await execFileAsync("gh", ["pr", "checks", "--json", "name,state"], { cwd });
-    const checks = JSON.parse(stdout.trim());
-    if (checks.length === 0) {
-      return { status: "passed" };
-    }
-    const hasFailed = checks.some((c) => c.state === "FAILURE" || c.state === "ERROR");
-    if (hasFailed)
-      return { status: "failed" };
-    const hasPending = checks.some((c) => c.state === "PENDING" || c.state === "EXPECTED");
-    if (hasPending)
-      return { status: "pending" };
-    return { status: "passed" };
-  } catch (e) {
-    const errMsg = e.message ?? "unknown";
-    return { status: "error", error: errMsg };
-  }
-}
 
 class StopHookHandler {
   debugLogger;
@@ -2425,9 +2324,6 @@ class StopHookHandler {
     const changesResult = await this.checkForChanges(hctx);
     if (changesResult)
       return changesResult;
-    const prCiResult = await this.checkPRAndCI(hctx, config);
-    if (prCiResult)
-      return prCiResult;
     hctx.log.info("All checks passed — allowing stop");
     return this.allow("passed");
   }
@@ -2463,44 +2359,6 @@ class StopHookHandler {
     }
     return null;
   }
-  async checkPRAndCI(hctx, config) {
-    if (!config?.auto_push_pr)
-      return null;
-    const prStatus = await checkPRStatus(hctx.cwd);
-    if (prStatus.error) {
-      hctx.log.warn(`PR status check failed: ${prStatus.error} — allowing stop`);
-      return null;
-    }
-    if (!(prStatus.prExists && prStatus.upToDate)) {
-      hctx.log.info("PR missing or outdated — blocking with pr_push_required");
-      return this.blockForPR(hctx);
-    }
-    if (!config?.auto_fix_pr)
-      return null;
-    return this.checkCI(hctx);
-  }
-  async blockForPR(hctx) {
-    const lastStatus = await getLastRunStatus(hctx.logDir);
-    const instruction = lastStatus === "passed_with_warnings" ? SKILL_INSTRUCTIONS.pr_push_required_with_warnings : SKILL_INSTRUCTIONS.pr_push_required;
-    return this.block("pr_push_required", instruction);
-  }
-  async checkCI(hctx) {
-    const ciResult = await checkCIStatus(hctx.cwd);
-    if (ciResult.status === "error") {
-      hctx.log.warn(`CI status check failed: ${ciResult.error} — allowing stop`);
-      return null;
-    }
-    if (ciResult.status === "pending") {
-      hctx.log.info("CI pending — blocking");
-      return this.block("ci_pending", SKILL_INSTRUCTIONS.ci_pending);
-    }
-    if (ciResult.status === "failed") {
-      hctx.log.info("CI failed — blocking");
-      return this.block("ci_failed", SKILL_INSTRUCTIONS.ci_failed);
-    }
-    hctx.log.info("CI passed — allowing stop");
-    return this.allow("ci_passed");
-  }
   async block(status, reason) {
     await this.debugLogger?.logStopHook("block", status);
     return {
@@ -2523,7 +2381,7 @@ class StopHookHandler {
 
 // src/types/gauntlet-status.ts
 function isSuccessStatus(status) {
-  return status === "passed" || status === "passed_with_warnings" || status === "no_applicable_gates" || status === "no_changes" || status === "ci_passed";
+  return status === "passed" || status === "passed_with_warnings" || status === "no_applicable_gates" || status === "no_changes";
 }
 
 // src/commands/stop-hook.ts
@@ -2839,7 +2697,7 @@ var GEMINI_THINKING_BUDGET = {
 };
 
 // src/cli-adapters/claude.ts
-var execAsync3 = promisify4(exec3);
+var execAsync3 = promisify3(exec3);
 function countBraceChange(line) {
   const stripped = line.replace(/\\./g, "").replace(/"[^"]*"/g, "").replace(/'[^']*'/g, "");
   let depth = 0;
@@ -3154,8 +3012,8 @@ import { exec as exec4 } from "node:child_process";
 import fs13 from "node:fs/promises";
 import os3 from "node:os";
 import path12 from "node:path";
-import { promisify as promisify5 } from "node:util";
-var execAsync4 = promisify5(exec4);
+import { promisify as promisify4 } from "node:util";
+var execAsync4 = promisify4(exec4);
 function parseJsonlLine(line) {
   try {
     const obj = JSON.parse(line);
@@ -3356,7 +3214,7 @@ import { exec as exec5 } from "node:child_process";
 import fs14 from "node:fs/promises";
 import os4 from "node:os";
 import path13 from "node:path";
-import { promisify as promisify6 } from "node:util";
+import { promisify as promisify5 } from "node:util";
 
 // src/cli-adapters/model-resolution.ts
 var TIER_SUFFIXES = ["-low", "-high", "-xhigh", "-fast"];
@@ -3395,7 +3253,7 @@ function resolveModelFromList(allModels, opts) {
 }
 
 // src/cli-adapters/cursor.ts
-var execAsync5 = promisify6(exec5);
+var execAsync5 = promisify5(exec5);
 var log = getCategoryLogger("cursor");
 function parseModelList(output) {
   return output.split(`
@@ -3526,8 +3384,8 @@ import { exec as exec6 } from "node:child_process";
 import fs15 from "node:fs/promises";
 import os5 from "node:os";
 import path14 from "node:path";
-import { promisify as promisify7 } from "node:util";
-var execAsync6 = promisify7(exec6);
+import { promisify as promisify6 } from "node:util";
+var execAsync6 = promisify6(exec6);
 var TOKEN_TYPE_MAP = {
   input: "inputTokens",
   output: "outputTokens",
@@ -3887,8 +3745,8 @@ import { exec as exec7 } from "node:child_process";
 import fs16 from "node:fs/promises";
 import os6 from "node:os";
 import path15 from "node:path";
-import { promisify as promisify8 } from "node:util";
-var execAsync7 = promisify8(exec7);
+import { promisify as promisify7 } from "node:util";
+var execAsync7 = promisify7(exec7);
 var log2 = getCategoryLogger("github-copilot");
 function parseCopilotModels(helpOutput) {
   const match = helpOutput.match(/choices:\s*(.+?)\)/);
@@ -4210,9 +4068,9 @@ async function handleCriticalError(error, jobId, startTime, logPaths, mainLogger
 
 // src/gates/review-diff.ts
 import { exec as exec8 } from "node:child_process";
-import { promisify as promisify9 } from "node:util";
+import { promisify as promisify8 } from "node:util";
 var log4 = getCategoryLogger("gate", "review");
-var execAsync8 = promisify9(exec8);
+var execAsync8 = promisify8(exec8);
 function parseLines(stdout) {
   return stdout.split(`
 `).map((line) => line.trim()).filter((line) => line.length > 0);
@@ -6156,7 +6014,6 @@ ${chalk2.bold(SEPARATOR)}`);
     }
     const { overallStatus, statusColor } = computeOverallStatus(results, statusOverride);
     console.error(statusColor(`Status: ${overallStatus}`));
-    console.log(`Status: ${overallStatus}`);
     console.error(chalk2.bold(`${SEPARATOR}
 `));
   }
@@ -8170,20 +8027,10 @@ var SKILLS_SOURCE_DIR = (() => {
     throw err;
   }
 })();
-var SKILL_ACTIONS = [
-  "run",
-  "check",
-  "push-pr",
-  "fix-pr",
-  "status",
-  "help",
-  "setup"
-];
+var SKILL_ACTIONS = ["run", "check", "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"
@@ -8366,13 +8213,10 @@ entry_points: []
 
 # 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
+# Env overrides: GAUNTLET_STOP_HOOK_ENABLED, GAUNTLET_STOP_HOOK_INTERVAL_MINUTES
 # 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:
@@ -8502,12 +8346,12 @@ function registerReviewCommand(program) {
   program.command("review").description("Run only applicable reviews for detected changes").option("-b, --base-branch <branch>", "Override base branch for change detection").option("-g, --gate <name>", "Run specific review gate only").option("-c, --commit <sha>", "Use diff for a specific commit").option("-u, --uncommitted", "Use diff for current uncommitted changes (staged and unstaged)").action((options) => executeGateCommand("review", options));
 }
 // src/core/diff-stats.ts
-import { execFile as execFile2 } from "node:child_process";
-import { promisify as promisify10 } from "node:util";
-var execFileAsyncOriginal = promisify10(execFile2);
-var execFileAsync2 = execFileAsyncOriginal;
+import { execFile } from "node:child_process";
+import { promisify as promisify9 } from "node:util";
+var execFileAsyncOriginal = promisify9(execFile);
+var execFileAsync = execFileAsyncOriginal;
 async function gitExec(args) {
-  const { stdout } = await execFileAsync2("git", args);
+  const { stdout } = await execFileAsync("git", args);
   return stdout;
 }
 async function computeDiffStats(baseBranch, options = {}) {
@@ -8891,10 +8735,6 @@ var statusMessages = {
   interval_not_elapsed: "Run interval not elapsed.",
   invalid_input: "Invalid input.",
   stop_hook_disabled: "",
-  pr_push_required: "Gates passed -- PR needs to be created/updated.",
-  ci_pending: "CI checks still running.",
-  ci_failed: "CI checks failed or review changes requested.",
-  ci_passed: "CI checks passed, no blocking reviews.",
   validation_required: "Changes need validation or previous run has unresolved failures."
 };
 function getStatusMessage2(status) {
@@ -9238,7 +9078,39 @@ function registerRunCommand(program) {
       commit: options.commit,
       uncommitted: options.uncommitted
     });
-    process.exit(isSuccessStatus(result.status) ? 0 : 1);
+    const code = isSuccessStatus(result.status) ? 0 : 1;
+    process.exit(code);
+  });
+}
+// src/commands/skip.ts
+import chalk13 from "chalk";
+function registerSkipCommand(program) {
+  program.command("skip").description("Advance execution state baseline without running gates").action(async () => {
+    let config;
+    let lockAcquired = false;
+    try {
+      config = await loadConfig();
+      const globalConfig = await loadGlobalConfig();
+      const debugLogConfig = mergeDebugLogConfig(config.project.debug_log, globalConfig.debug_log);
+      initDebugLogger(config.project.log_dir, debugLogConfig);
+      await acquireLock(config.project.log_dir);
+      lockAcquired = true;
+      const debugLogger = getDebugLogger();
+      await debugLogger?.logCommand("skip", []);
+      await cleanLogs(config.project.log_dir, config.project.max_previous_logs);
+      await writeExecutionState(config.project.log_dir);
+      const commit = await getCurrentCommit();
+      const shortSha = commit.slice(0, 7);
+      await releaseLock(config.project.log_dir);
+      console.log(chalk13.green(`Baseline advanced to ${shortSha}. Next run will diff from here.`));
+    } catch (error) {
+      if (config && lockAcquired) {
+        await releaseLock(config.project.log_dir);
+      }
+      const err = error;
+      console.error(chalk13.red("Error:"), err.message);
+      process.exit(1);
+    }
   });
 }
 // src/commands/start-hook.ts
@@ -9321,285 +9193,20 @@ function registerStatusCommand(program) {
   });
 }
 // src/commands/validate.ts
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 function registerValidateCommand(program) {
   program.command("validate").description("Validate .gauntlet/ config files against schemas").action(async () => {
     try {
       await loadConfig();
-      console.log(chalk13.green("All config files are valid."));
+      console.log(chalk14.green("All config files are valid."));
       process.exitCode = 0;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      console.error(chalk13.red("Validation failed:"), message);
+      console.error(chalk14.red("Validation failed:"), message);
       process.exitCode = 1;
     }
   });
 }
-// src/commands/wait-ci.ts
-import { spawn as spawn3 } from "node:child_process";
-async function isGhAvailable() {
-  return new Promise((resolve) => {
-    const proc = spawn3("gh", ["--version"], { stdio: "pipe" });
-    proc.on("close", (code) => resolve(code === 0));
-    proc.on("error", () => resolve(false));
-  });
-}
-async function runGh(args, cwd) {
-  return new Promise((resolve) => {
-    const proc = spawn3("gh", args, { stdio: "pipe", cwd });
-    let stdout = "";
-    let stderr = "";
-    proc.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    proc.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-    proc.on("close", (code) => {
-      resolve({ code: code ?? 1, stdout, stderr });
-    });
-    proc.on("error", (err) => {
-      resolve({ code: 1, stdout: "", stderr: err.message });
-    });
-  });
-}
-async function getPRInfo(cwd) {
-  const result = await runGh(["pr", "view", "--json", "number,url,headRefName"], cwd);
-  if (result.code !== 0) {
-    return null;
-  }
-  try {
-    return JSON.parse(result.stdout.trim());
-  } catch {
-    return null;
-  }
-}
-async function getChecks(cwd) {
-  const result = await runGh(["pr", "checks", "--json", "name,state,link"], cwd);
-  const output = result.stdout.trim();
-  if (!output) {
-    return result.code === 0 ? [] : null;
-  }
-  try {
-    return JSON.parse(output) || [];
-  } catch {
-    return result.code === 0 ? [] : null;
-  }
-}
-async function getReviews(prNumber, cwd) {
-  const repoResult = await runGh(["repo", "view", "--json", "owner,name"], cwd);
-  if (repoResult.code !== 0) {
-    return null;
-  }
-  let owner;
-  let repo;
-  try {
-    const repoInfo = JSON.parse(repoResult.stdout.trim());
-    owner = repoInfo.owner.login;
-    repo = repoInfo.name;
-  } catch {
-    return null;
-  }
-  const result = await runGh([
-    "api",
-    "--paginate",
-    `repos/${owner}/${repo}/pulls/${prNumber}/reviews?per_page=100`
-  ], cwd);
-  if (result.code !== 0) {
-    return null;
-  }
-  try {
-    const rawReviews = JSON.parse(result.stdout.trim()) || [];
-    return rawReviews.filter((r) => r.user?.login).map((r) => ({
-      author: { login: r.user.login },
-      state: r.state,
-      body: r.body || ""
-    }));
-  } catch {
-    return null;
-  }
-}
-function getLatestReviewsByAuthor(reviews) {
-  const latestByAuthor = new Map;
-  for (const review of reviews) {
-    latestByAuthor.set(review.author.login, review);
-  }
-  return Array.from(latestByAuthor.values());
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function extractRunId(link) {
-  const match = link.match(/\/actions\/runs\/(\d+)/);
-  return match?.[1] ?? null;
-}
-async function getFailedRunLogs(runId, cwd) {
-  const result = await runGh(["run", "view", runId, "--log-failed"], cwd);
-  if (result.code !== 0 || !result.stdout.trim()) {
-    return null;
-  }
-  const lines = result.stdout.trim().split(`
-`);
-  const maxLines = 100;
-  if (lines.length > maxLines) {
-    return `... (${lines.length - maxLines} lines truncated)
-${lines.slice(-maxLines).join(`
-`)}`;
-  }
-  return result.stdout.trim();
-}
-function groupChecksByRunId(failedChecks) {
-  const runIdToChecks = new Map;
-  for (const check of failedChecks) {
-    const runId = extractRunId(check.link);
-    const key = runId ?? "";
-    const existing = runIdToChecks.get(key) ?? [];
-    existing.push(check);
-    runIdToChecks.set(key, existing);
-  }
-  return runIdToChecks;
-}
-async function enrichFailedChecksWithLogs(failedChecks, cwd) {
-  const runIdToChecks = groupChecksByRunId(failedChecks);
-  const entries = Array.from(runIdToChecks.entries());
-  const logResults = await Promise.all(entries.map(([runId]) => runId ? getFailedRunLogs(runId, cwd) : Promise.resolve(null)));
-  const results = [];
-  for (let i = 0;i < entries.length; i++) {
-    const [, checks] = entries[i];
-    const logs = logResults[i];
-    for (const check of checks) {
-      results.push({ ...check, log_output: logs ?? undefined });
-    }
-  }
-  return results;
-}
-function createResult(opts) {
-  const elapsed = Math.round((Date.now() - opts.startTime) / 1000);
-  return {
-    ci_status: opts.status,
-    pr_number: opts.prInfo?.number,
-    pr_url: opts.prInfo?.url,
-    failed_checks: opts.failedChecks?.map((c) => ({
-      name: c.name,
-      conclusion: c.state.toLowerCase(),
-      details_url: c.link,
-      log_output: c.log_output
-    })) || [],
-    review_comments: opts.reviewComments || [],
-    elapsed_seconds: elapsed,
-    error_message: opts.errorMessage
-  };
-}
-async function pollCIStatus(cwd, prNumber, isFirstPoll) {
-  const checks = await getChecks(cwd);
-  const reviews = await getReviews(prNumber, cwd);
-  if (checks === null || reviews === null) {
-    return { error: "Failed to fetch CI status or reviews from GitHub" };
-  }
-  if (checks.length === 0) {
-    return isFirstPoll ? { noChecksYet: true } : { noChecksConfigured: true };
-  }
-  const latestReviews = getLatestReviewsByAuthor(reviews);
-  const failedChecks = checks.filter((c) => c.state === "FAILURE");
-  const blockingReviews = latestReviews.filter((r) => r.state === "CHANGES_REQUESTED");
-  const reviewComments = blockingReviews.map((r) => ({
-    author: r.author.login,
-    body: r.body || ""
-  }));
-  const pendingChecks = checks.filter((c) => c.state === "PENDING" || c.state === "QUEUED" || c.state === "IN_PROGRESS");
-  const shouldFail = failedChecks.length > 0 || blockingReviews.length > 0;
-  const shouldPass = pendingChecks.length === 0;
-  return { shouldFail, shouldPass, failedChecks, reviewComments };
-}
-async function waitForCI(timeoutSeconds, pollIntervalSeconds, cwd) {
-  const startTime = Date.now();
-  let isFirstPoll = true;
-  if (!await isGhAvailable()) {
-    return createResult({
-      status: "error",
-      startTime,
-      errorMessage: "gh CLI is not installed or not authenticated"
-    });
-  }
-  const prInfo = await getPRInfo(cwd);
-  if (!prInfo) {
-    return createResult({
-      status: "error",
-      startTime,
-      errorMessage: "No PR found for current branch"
-    });
-  }
-  const timeoutMs = timeoutSeconds * 1000;
-  while (Date.now() - startTime < timeoutMs) {
-    const pollOutcome = await pollCIStatus(cwd, prInfo.number, isFirstPoll);
-    isFirstPoll = false;
-    if (pollOutcome.error) {
-      return createResult({
-        status: "error",
-        startTime,
-        prInfo,
-        errorMessage: pollOutcome.error
-      });
-    }
-    if (pollOutcome.noChecksYet) {
-      await sleep(pollIntervalSeconds * 1000);
-      continue;
-    }
-    if (pollOutcome.noChecksConfigured) {
-      return createResult({ status: "passed", startTime, prInfo });
-    }
-    if (pollOutcome.shouldFail && pollOutcome.failedChecks) {
-      const enrichedChecks = await enrichFailedChecksWithLogs(pollOutcome.failedChecks, cwd);
-      return createResult({
-        status: "failed",
-        startTime,
-        prInfo,
-        failedChecks: enrichedChecks,
-        reviewComments: pollOutcome.reviewComments
-      });
-    }
-    if (pollOutcome.shouldPass) {
-      return createResult({ status: "passed", startTime, prInfo });
-    }
-    await sleep(pollIntervalSeconds * 1000);
-  }
-  return createResult({ status: "pending", startTime, prInfo });
-}
-function registerWaitCICommand(program) {
-  program.command("wait-ci").description("Wait for CI checks to complete and check for blocking reviews").option("--timeout <seconds>", "Maximum time to wait for CI (default: 270)", "270").option("--poll-interval <seconds>", "Time between CI status checks (default: 15)", "15").action(async (options) => {
-    const timeout = Number.parseInt(options.timeout, 10);
-    const pollInterval = Number.parseInt(options.pollInterval, 10);
-    if (Number.isNaN(timeout) || timeout <= 0) {
-      console.log(JSON.stringify({
-        ci_status: "error",
-        failed_checks: [],
-        review_comments: [],
-        elapsed_seconds: 0,
-        error_message: "Invalid timeout value"
-      }));
-      process.exit(1);
-    }
-    if (Number.isNaN(pollInterval) || pollInterval <= 0) {
-      console.log(JSON.stringify({
-        ci_status: "error",
-        failed_checks: [],
-        review_comments: [],
-        elapsed_seconds: 0,
-        error_message: "Invalid poll-interval value"
-      }));
-      process.exit(1);
-    }
-    const result = await waitForCI(timeout, pollInterval);
-    console.log(JSON.stringify(result));
-    if (result.ci_status === "passed") {
-      process.exit(0);
-    } else if (result.ci_status === "pending") {
-      process.exit(2);
-    } else {
-      process.exit(1);
-    }
-  });
-}
 // src/index.ts
 var program = new Command;
 program.name("agent-gauntlet").description("AI-assisted quality gates").version(package_default.version);
@@ -9613,14 +9220,14 @@ registerListCommand(program);
 registerHealthCommand(program);
 registerInitCommand(program);
 registerValidateCommand(program);
+registerSkipCommand(program);
 registerStartHookCommand(program);
 registerStatusCommand(program);
 registerStopHookCommand(program);
-registerWaitCICommand(program);
 registerHelpCommand(program);
 if (process.argv.length < 3) {
   process.argv.push("help");
 }
 program.parse(process.argv);
 
-//# debugId=5FCEF2943643F3B864756E2164756E21
+//# debugId=E93D541AB16DB2CC64756E2164756E21