agent-gauntlet 1.2.1 → 1.3.0

package/dist/index.js

@@ -299,7 +299,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "agent-gauntlet",
-  version: "1.2.1",
+  version: "1.3.0",
   description: "A CLI tool for testing AI coding agents",
   license: "MIT",
   author: "Paul Caplan",
@@ -321,6 +321,9 @@ var package_default = {
   files: [
     "dist",
     "skills",
+    ".claude-plugin",
+    ".cursor-plugin",
+    "hooks",
     "README.md",
     "LICENSE"
   ],
@@ -1233,62 +1236,61 @@ ${stderr}`);
         jobId,
         status: "pass",
         duration: Date.now() - startTime,
-        message: "Command exited with code 0"
+        message: "Command exited with code 0",
+        command,
+        workingDirectory
       };
       await logger(`Result: ${result.status} - ${result.message}
 `);
       return result;
     } catch (error) {
-      const err = error;
-      if (err.stdout)
-        await logger(err.stdout);
-      if (err.stderr)
-        await logger(`
+      return this.handleExecutionError(error, jobId, command, workingDirectory, config, startTime, logger);
+    }
+  }
+  async handleExecutionError(error, jobId, command, workingDirectory, config, startTime, logger) {
+    const err = error;
+    if (err.stdout)
+      await logger(err.stdout);
+    if (err.stderr)
+      await logger(`
 STDERR:
 ${err.stderr}`);
-      await logger(`
+    await logger(`
 Command failed: ${err.message}`);
-      if (err.signal === "SIGTERM" && config.timeout) {
-        const result2 = {
-          jobId,
-          status: "fail",
-          duration: Date.now() - startTime,
-          message: `Timed out after ${config.timeout}s`,
-          fixInstructions: config.fixInstructionsContent,
-          fixWithSkill: config.fixWithSkill
-        };
-        await logger(`Result: ${result2.status} - ${result2.message}
+    const result = this.buildErrorResult(err, jobId, command, workingDirectory, config, startTime);
+    await logger(`Result: ${result.status} - ${result.message}
 `);
-        await this.logFixInfo(config, logger);
-        return result2;
-      }
-      if (typeof err.code === "number") {
-        const result2 = {
-          jobId,
-          status: "fail",
-          duration: Date.now() - startTime,
-          message: `Exited with code ${err.code}`,
-          fixInstructions: config.fixInstructionsContent,
-          fixWithSkill: config.fixWithSkill
-        };
-        await logger(`Result: ${result2.status} - ${result2.message}
-`);
-        await this.logFixInfo(config, logger);
-        return result2;
-      }
-      const result = {
-        jobId,
-        status: "error",
-        duration: Date.now() - startTime,
-        message: err.message || "Unknown error",
-        fixInstructions: config.fixInstructionsContent,
-        fixWithSkill: config.fixWithSkill
+    await this.logFixInfo(config, logger);
+    return result;
+  }
+  buildErrorResult(err, jobId, command, workingDirectory, config, startTime) {
+    const base = {
+      jobId,
+      duration: Date.now() - startTime,
+      command,
+      workingDirectory,
+      fixInstructions: config.fixInstructionsContent,
+      fixWithSkill: config.fixWithSkill
+    };
+    if (err.signal === "SIGTERM" && config.timeout) {
+      return {
+        ...base,
+        status: "fail",
+        message: `Timed out after ${config.timeout}s`
+      };
+    }
+    if (typeof err.code === "number") {
+      return {
+        ...base,
+        status: "fail",
+        message: `Exited with code ${err.code}`
       };
-      await logger(`Result: ${result.status} - ${result.message}
-`);
-      await this.logFixInfo(config, logger);
-      return result;
     }
+    return {
+      ...base,
+      status: "error",
+      message: err.message || "Unknown error"
+    };
   }
   async logFixInfo(config, logger) {
     if (config.fixInstructionsContent) {
@@ -2694,28 +2696,83 @@ async function handleStopHookAction(ctx) {
   await executeGauntlet(ctx, projectCwd, logDir, diagnostics, parsed);
 }
 
-// src/cli-adapters/thinking-budget.ts
-var CLAUDE_THINKING_TOKENS = {
-  off: 0,
-  low: 8000,
-  medium: 16000,
-  high: 31999
-};
-var CODEX_REASONING_EFFORT = {
-  off: "minimal",
-  low: "low",
-  medium: "medium",
-  high: "high"
-};
-var GEMINI_THINKING_BUDGET = {
-  off: 0,
-  low: 4096,
-  medium: 8192,
-  high: 24576
-};
+// src/plugin/claude-cli.ts
+import { execFileSync } from "node:child_process";
+function runClaudeCommand(args) {
+  try {
+    const stdout = execFileSync("claude", args, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 60000
+    });
+    return { success: true, stdout };
+  } catch (error) {
+    const err = error;
+    let stderr = err.message;
+    if (typeof err.stderr === "string") {
+      stderr = err.stderr;
+    } else if (err.stderr instanceof Buffer) {
+      stderr = err.stderr.toString("utf-8");
+    }
+    return { success: false, stderr: stderr.trim() };
+  }
+}
+function runClaudePluginCommand(args) {
+  const result = runClaudeCommand(args);
+  return {
+    success: result.success,
+    stderr: result.stderr
+  };
+}
+async function addMarketplace() {
+  return runClaudePluginCommand([
+    "plugin",
+    "marketplace",
+    "add",
+    "pcaplan/agent-gauntlet"
+  ]);
+}
+async function installPlugin(scope) {
+  return runClaudePluginCommand([
+    "plugin",
+    "install",
+    "agent-gauntlet",
+    "--scope",
+    scope
+  ]);
+}
+async function listPlugins() {
+  const result = runClaudeCommand(["plugin", "list", "--json"]);
+  if (!result.success) {
+    throw new Error(result.stderr ?? "Failed to list Claude plugins");
+  }
+  try {
+    const parsed = JSON.parse(result.stdout ?? "");
+    if (Array.isArray(parsed)) {
+      return parsed;
+    }
+    return parsed?.plugins ?? [];
+  } catch {
+    throw new Error("Failed to parse `claude plugin list --json` output");
+  }
+}
+async function updateMarketplace() {
+  return runClaudePluginCommand([
+    "plugin",
+    "marketplace",
+    "update",
+    "agent-gauntlet"
+  ]);
+}
+async function updatePlugin() {
+  return runClaudePluginCommand([
+    "plugin",
+    "update",
+    "agent-gauntlet@pcaplan/agent-gauntlet"
+  ]);
+}
 
-// src/cli-adapters/claude.ts
-var execAsync3 = promisify3(exec3);
+// src/cli-adapters/claude-otel.ts
 function countBraceChange(line) {
   const stripped = line.replace(/\\./g, "").replace(/"[^"]*"/g, "").replace(/'[^']*'/g, "");
   let depth = 0;
@@ -2914,6 +2971,29 @@ function buildOtelEnv() {
   }
   return env;
 }
+
+// src/cli-adapters/thinking-budget.ts
+var CLAUDE_THINKING_TOKENS = {
+  off: 0,
+  low: 8000,
+  medium: 16000,
+  high: 31999
+};
+var CODEX_REASONING_EFFORT = {
+  off: "minimal",
+  low: "low",
+  medium: "medium",
+  high: "high"
+};
+var GEMINI_THINKING_BUDGET = {
+  off: 0,
+  low: 4096,
+  medium: 8192,
+  high: 24576
+};
+
+// src/cli-adapters/claude.ts
+var execAsync3 = promisify3(exec3);
 var POST_PROCESS_BUFFER_MS = 30000;
 
 class ClaudeAdapter {
@@ -2961,6 +3041,44 @@ class ClaudeAdapter {
   supportsHooks() {
     return true;
   }
+  async detectPlugin(projectRoot) {
+    try {
+      const entries = await listPlugins();
+      const pluginEntries = entries.filter((entry) => {
+        const e = entry;
+        const name = e.name ?? e.id;
+        return name === "agent-gauntlet" || typeof name === "string" && name.startsWith("agent-gauntlet@");
+      });
+      const resolved = path11.resolve(projectRoot);
+      if (pluginEntries.some((entry) => {
+        const e = entry;
+        return e.scope === "project" && typeof e.projectPath === "string" && path11.resolve(e.projectPath) === resolved;
+      })) {
+        return "project";
+      }
+      if (pluginEntries.some((entry) => entry.scope === "user")) {
+        return "user";
+      }
+    } catch {}
+    return null;
+  }
+  async installPlugin(scope, _projectRoot) {
+    const addResult = await addMarketplace();
+    if (!addResult.success) {
+      return { success: false, error: addResult.stderr };
+    }
+    const installResult = await installPlugin(scope);
+    if (!installResult.success) {
+      return { success: false, error: installResult.stderr };
+    }
+    return { success: true };
+  }
+  getManualInstallInstructions(scope) {
+    return [
+      "claude plugin marketplace add pcaplan/agent-gauntlet",
+      `claude plugin install agent-gauntlet --scope ${scope}`
+    ];
+  }
   async execute(opts) {
     const totalTimeout = (opts.timeoutMs ?? 300000) + POST_PROCESS_BUFFER_MS;
     let timer;
@@ -3152,7 +3270,7 @@ class CodexAdapter {
     return path12.join(os3.homedir(), ".codex", "prompts");
   }
   getProjectSkillDir() {
-    return null;
+    return ".agents/skills";
   }
   getUserSkillDir() {
     return null;
@@ -3230,9 +3348,11 @@ ${opts.diff}`;
 
 // src/cli-adapters/cursor.ts
 import { exec as exec5 } from "node:child_process";
+import { statSync } from "node:fs";
 import fs14 from "node:fs/promises";
 import os4 from "node:os";
 import path13 from "node:path";
+import { fileURLToPath } from "node:url";
 import { promisify as promisify5 } from "node:util";
 
 // src/cli-adapters/model-resolution.ts
@@ -3311,10 +3431,10 @@ class CursorAdapter {
     return null;
   }
   getProjectSkillDir() {
-    return null;
+    return ".cursor/skills";
   }
   getUserSkillDir() {
-    return null;
+    return path13.join(os4.homedir(), ".cursor", "skills");
   }
   getCommandExtension() {
     return ".md";
@@ -3397,6 +3517,79 @@ ${opts.diff}`;
       await cleanup();
     }
   }
+  async detectPlugin(projectRoot) {
+    const projectPluginPath = path13.join(projectRoot, ".cursor", "plugins", "agent-gauntlet", ".cursor-plugin", "plugin.json");
+    try {
+      await fs14.access(projectPluginPath);
+      return "project";
+    } catch {}
+    const userPluginPath = path13.join(os4.homedir(), ".cursor", "plugins", "agent-gauntlet", ".cursor-plugin", "plugin.json");
+    try {
+      await fs14.access(userPluginPath);
+      return "user";
+    } catch {}
+    return null;
+  }
+  async installPlugin(scope, projectRoot) {
+    try {
+      const baseDir = scope === "user" ? path13.join(os4.homedir(), ".cursor", "plugins", "agent-gauntlet") : path13.join(projectRoot ?? ".", ".cursor", "plugins", "agent-gauntlet");
+      const packageRoot = this.findPackageRoot();
+      await this.copyPluginAssets(packageRoot, baseDir);
+      return { success: true };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async updatePlugin(scope, projectRoot) {
+    return this.installPlugin(scope, projectRoot);
+  }
+  getManualInstallInstructions(scope) {
+    const targetDir = scope === "user" ? "~/.cursor/plugins/agent-gauntlet/" : ".cursor/plugins/agent-gauntlet/";
+    return [
+      `Copy plugin files to ${targetDir}`,
+      "Or install via /add-plugin in Cursor or at the Cursor marketplace"
+    ];
+  }
+  findPackageRoot() {
+    const moduleDir = path13.dirname(fileURLToPath(import.meta.url));
+    const bundled = path13.join(moduleDir, "..");
+    const dev = path13.join(moduleDir, "..", "..");
+    try {
+      statSync(path13.join(bundled, ".cursor-plugin", "plugin.json"));
+      return bundled;
+    } catch {
+      return dev;
+    }
+  }
+  async copyPluginAssets(packageRoot, targetDir) {
+    await fs14.mkdir(targetDir, { recursive: true });
+    const pluginSrc = path13.join(packageRoot, ".cursor-plugin");
+    const pluginDest = path13.join(targetDir, ".cursor-plugin");
+    await this.copyDirRecursive(pluginSrc, pluginDest);
+    const skillsSrc = path13.join(packageRoot, "skills");
+    const skillsDest = path13.join(targetDir, "skills");
+    await this.copyDirRecursive(skillsSrc, skillsDest);
+    const hooksSrc = path13.join(packageRoot, "hooks", "cursor-hooks.json");
+    const hooksDest = path13.join(targetDir, "hooks");
+    await fs14.mkdir(hooksDest, { recursive: true });
+    await fs14.copyFile(hooksSrc, path13.join(hooksDest, "hooks.json"));
+  }
+  async copyDirRecursive(src, dest) {
+    await fs14.mkdir(dest, { recursive: true });
+    const entries = await fs14.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = path13.join(src, entry.name);
+      const destPath = path13.join(dest, entry.name);
+      if (entry.isDirectory()) {
+        await this.copyDirRecursive(srcPath, destPath);
+      } else {
+        await fs14.copyFile(srcPath, destPath);
+      }
+    }
+  }
 }
 
 // src/cli-adapters/gemini.ts
@@ -7465,7 +7658,7 @@ function registerDetectCommand(program) {
       const changes = await changeDetector.getChangedFiles();
       if (changes.length === 0) {
         console.log(chalk6.green("No changes detected."));
-        return;
+        process.exit(2);
       }
       console.log(chalk6.dim(`Found ${changes.length} changed files:`));
       for (const file of changes) {
@@ -7476,7 +7669,7 @@ function registerDetectCommand(program) {
       const jobs = jobGen.generateJobs(entryPoints);
       if (jobs.length === 0) {
         console.log(chalk6.yellow("No applicable gates for these changes."));
-        return;
+        process.exit(2);
       }
       console.log(chalk6.bold(`Would run ${jobs.length} gate(s):
 `));
@@ -8201,12 +8394,12 @@ function registerHelpCommand(program) {
   });
 }
 // src/commands/init.ts
-import { execFileSync } from "node:child_process";
-import { statSync } from "node:fs";
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { statSync as statSync3 } from "node:fs";
 import fs32 from "node:fs/promises";
-import path30 from "node:path";
-import { fileURLToPath } from "node:url";
-import chalk11 from "chalk";
+import path31 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import chalk12 from "chalk";
 
 // src/commands/init-checksums.ts
 import { createHash } from "node:crypto";
@@ -8222,25 +8415,6 @@ async function computeSkillChecksum(skillDir) {
   }
   return hash.digest("hex");
 }
-function computeHookChecksum(entries) {
-  const gauntletEntries = entries.filter((entry) => isGauntletHookEntry(entry));
-  const hash = createHash("sha256");
-  hash.update(JSON.stringify(gauntletEntries));
-  return hash.digest("hex");
-}
-function computeExpectedHookChecksum(hookEntries) {
-  return computeHookChecksum(hookEntries);
-}
-function isGauntletHookEntry(entry) {
-  if (typeof entry.command === "string" && entry.command.startsWith("agent-gauntlet")) {
-    return true;
-  }
-  const nested = entry.hooks;
-  if (Array.isArray(nested)) {
-    return nested.some((h) => typeof h.command === "string" && h.command.startsWith("agent-gauntlet"));
-  }
-  return false;
-}
 async function collectFiles(dir, baseDir) {
   const base = baseDir ?? dir;
   const results = [];
@@ -8257,19 +8431,44 @@ async function collectFiles(dir, baseDir) {
   return results;
 }
 
-// src/commands/init-hooks.ts
-import fs31 from "node:fs/promises";
+// src/commands/init-plugin.ts
+import os8 from "node:os";
 import path29 from "node:path";
-import chalk10 from "chalk";
+import chalk9 from "chalk";
+function getCodexSkillsBaseDir(scope) {
+  if (scope === "project") {
+    return path29.join(".agents", "skills");
+  }
+  const homeDir = process.env.HOME?.trim() || os8.homedir();
+  return path29.join(homeDir, ".agents", "skills");
+}
+async function installAdapterPlugin(adapter, projectRoot, installScope) {
+  if (!adapter.installPlugin)
+    return;
+  const result = await adapter.installPlugin(installScope, projectRoot);
+  if (!result.success) {
+    console.warn(chalk9.yellow(`${adapter.name} plugin installation failed. Continuing init.`));
+    if (result.error) {
+      console.warn(chalk9.yellow(result.error.trim()));
+    }
+    const instructions = adapter.getManualInstallInstructions?.(installScope);
+    if (instructions) {
+      console.warn("Run these steps manually:");
+      for (const step of instructions) {
+        console.warn(`  ${step}`);
+      }
+    }
+  }
+}
 
 // src/commands/init-prompts.ts
-import { checkbox, confirm, number } from "@inquirer/prompts";
-import chalk9 from "chalk";
+import { checkbox, confirm, number, select } from "@inquirer/prompts";
+import chalk10 from "chalk";
 async function promptDevCLIs(detectedNames, skipPrompts) {
   if (skipPrompts)
     return detectedNames;
   console.log();
-  console.log(chalk9.bold("Select your development CLI(s). These are the main tools you work in."));
+  console.log(chalk10.bold("Select your development CLI(s). These are the main tools you work in."));
   const selected = await checkbox({
     message: "Development CLIs:",
     choices: detectedNames.map((name) => ({ name, value: name })),
@@ -8281,7 +8480,7 @@ async function promptReviewCLIs(detectedNames, skipPrompts) {
   if (skipPrompts)
     return detectedNames;
   console.log();
-  console.log(chalk9.bold("Select your reviewer CLI(s). These are the CLIs that will be used for AI code reviews."));
+  console.log(chalk10.bold("Select your reviewer CLI(s). These are the CLIs that will be used for AI code reviews."));
   const selected = await checkbox({
     message: "Review CLIs:",
     choices: detectedNames.map((name) => ({ name, value: name })),
@@ -8289,6 +8488,18 @@ async function promptReviewCLIs(detectedNames, skipPrompts) {
   });
   return selected;
 }
+async function promptInstallScope(skipPrompts) {
+  if (skipPrompts)
+    return "project";
+  console.log();
+  return select({
+    message: "Install scope for Claude plugin and Codex skills:",
+    choices: [
+      { name: "Local (project)", value: "project" },
+      { name: "Global (user)", value: "user" }
+    ]
+  });
+}
 async function promptNumReviews(reviewCliCount, skipPrompts) {
   if (reviewCliCount === 1)
     return 1;
@@ -8304,212 +8515,200 @@ async function promptNumReviews(reviewCliCount, skipPrompts) {
 }
 async function promptFileOverwrite(name, skipPrompts) {
   if (skipPrompts)
-    return true;
-  return confirm({
+    return "yes";
+  return select({
     message: `Skill \`${name}\` has changed, update it?`,
-    default: true
-  });
-}
-async function promptHookOverwrite(hookFile, skipPrompts) {
-  if (skipPrompts)
-    return true;
-  return confirm({
-    message: `Hook configuration in ${hookFile} has changed, update it?`,
-    default: true
+    choices: [
+      { name: "Yes", value: "yes" },
+      { name: "No", value: "no" },
+      { name: "Yes to all remaining", value: "all" }
+    ]
   });
 }
 
-// src/commands/init-hooks.ts
-function hookHasCommand(entries, cmd) {
-  return entries.some((hook) => {
-    if (hook.command === cmd)
-      return true;
-    const nested = hook.hooks;
-    return Array.isArray(nested) && nested.some((h) => h.command === cmd);
-  });
+// src/commands/plugin-update.ts
+import { realpathSync, statSync as statSync2 } from "node:fs";
+import fs31 from "node:fs/promises";
+import os9 from "node:os";
+import path30 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import chalk11 from "chalk";
+var __dirname2 = path30.dirname(fileURLToPath2(import.meta.url));
+var SKILLS_SOURCE_DIR = (() => {
+  const bundled = path30.join(__dirname2, "..", "skills");
+  const dev = path30.join(__dirname2, "..", "..", "skills");
+  try {
+    statSync2(bundled);
+    return bundled;
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT" || code === "ENOTDIR")
+      return dev;
+    throw err;
+  }
+})();
+async function getSkillDirNames() {
+  const entries = await fs31.readdir(SKILLS_SOURCE_DIR, { withFileTypes: true });
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
 }
-async function mergeHookConfig(opts) {
-  const {
-    filePath,
-    hookKey,
-    hookEntry,
-    deduplicateCmd,
-    wrapInHooksArray,
-    baseConfig
-  } = opts;
-  await fs31.mkdir(path29.dirname(filePath), { recursive: true });
-  let existing = {};
-  if (await exists(filePath)) {
-    try {
-      existing = JSON.parse(await fs31.readFile(filePath, "utf-8"));
-    } catch {
-      existing = {};
+async function copyDirRecursive(opts) {
+  await fs31.mkdir(opts.dest, { recursive: true });
+  const entries = await fs31.readdir(opts.src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path30.join(opts.src, entry.name);
+    const destPath = path30.join(opts.dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirRecursive({ src: srcPath, dest: destPath });
+    } else {
+      await fs31.copyFile(srcPath, destPath);
     }
   }
-  const existingHooks = existing.hooks || {};
-  const existingEntries = Array.isArray(existingHooks[hookKey]) ? existingHooks[hookKey] : [];
-  if (hookHasCommand(existingEntries, deduplicateCmd)) {
-    return false;
-  }
-  const entryToAdd = wrapInHooksArray ? { hooks: [hookEntry] } : hookEntry;
-  const newEntries = [...existingEntries, entryToAdd];
-  const merged = {
-    ...baseConfig ?? {},
-    ...existing,
-    hooks: { ...existingHooks, [hookKey]: newEntries }
-  };
-  await fs31.writeFile(filePath, `${JSON.stringify(merged, null, 2)}
-`);
-  return true;
 }
-var START_HOOK_ENTRY = {
-  matcher: "startup|resume|clear|compact",
-  hooks: [
-    { type: "command", command: "agent-gauntlet start-hook", async: false }
-  ]
-};
-var CURSOR_START_HOOK_ENTRY = {
-  command: "agent-gauntlet start-hook --adapter cursor"
-};
-var STOP_HOOK_ENTRY = {
-  type: "command",
-  command: "agent-gauntlet stop-hook",
-  timeout: 300
-};
-var CURSOR_STOP_HOOK_ENTRY = {
-  command: "agent-gauntlet stop-hook",
-  loop_limit: 10
-};
-async function installHookWithLog(config, installedMsg, existsMsg) {
-  const added = await mergeHookConfig(config);
-  console.log(added ? chalk10.green(installedMsg) : chalk10.dim(existsMsg));
-}
-function buildHookSpec(target) {
-  const { projectRoot, variant, kind } = target;
-  const isCursor = variant === "cursor";
-  const isStop = kind === "stop";
-  const hookConfigs = {
-    "claude-stop": {
-      dir: ".claude",
-      file: "settings.local.json",
-      hookKey: "Stop",
-      entry: STOP_HOOK_ENTRY,
-      cmd: "agent-gauntlet stop-hook",
-      wrap: true
-    },
-    "cursor-stop": {
-      dir: ".cursor",
-      file: "hooks.json",
-      hookKey: "stop",
-      entry: CURSOR_STOP_HOOK_ENTRY,
-      cmd: "agent-gauntlet stop-hook",
-      wrap: false
-    },
-    "claude-start": {
-      dir: ".claude",
-      file: "settings.local.json",
-      hookKey: "SessionStart",
-      entry: START_HOOK_ENTRY,
-      cmd: "agent-gauntlet start-hook",
-      wrap: false
-    },
-    "cursor-start": {
-      dir: ".cursor",
-      file: "hooks.json",
-      hookKey: "sessionStart",
-      entry: CURSOR_START_HOOK_ENTRY,
-      cmd: "agent-gauntlet start-hook --adapter cursor",
-      wrap: false
-    }
-  };
-  const key = `${variant}-${kind}`;
-  const cfg = hookConfigs[key];
-  const prefix = isCursor ? "Cursor " : "";
-  let kindLabel;
-  if (isCursor)
-    kindLabel = kind;
-  else if (isStop)
-    kindLabel = "Stop";
-  else
-    kindLabel = "Start";
-  const purpose = isStop ? "gauntlet will run automatically when agent stops" : "agent will be primed with gauntlet instructions at session start";
-  return {
-    config: {
-      filePath: path29.join(projectRoot, cfg.dir, cfg.file),
-      hookKey: cfg.hookKey,
-      hookEntry: cfg.entry,
-      deduplicateCmd: cfg.cmd,
-      wrapInHooksArray: cfg.wrap,
-      ...isCursor ? { baseConfig: { version: 1 } } : {}
-    },
-    installedMsg: `${prefix}${kindLabel} hook installed - ${purpose}`,
-    existsMsg: `${prefix}${kindLabel} hook already installed`
-  };
+function isInProjectScope(cwd, projectPath) {
+  const absoluteCwd = path30.resolve(cwd);
+  const absoluteProjectPath = path30.resolve(projectPath);
+  const normalizedCwd = normalizePathForMatch(absoluteCwd);
+  const normalizedProjectPath = normalizePathForMatch(absoluteProjectPath);
+  return normalizedCwd === normalizedProjectPath || normalizedCwd.startsWith(`${normalizedProjectPath}${path30.sep}`);
 }
-async function installHookWithChecksums(target, skipPrompts) {
-  const spec = buildHookSpec(target);
-  let existingConfig = {};
-  if (await exists(spec.config.filePath)) {
-    try {
-      existingConfig = JSON.parse(await fs31.readFile(spec.config.filePath, "utf-8"));
-    } catch {
-      existingConfig = {};
-    }
+function normalizePathForMatch(inputPath) {
+  try {
+    return realpathSync.native(inputPath);
+  } catch {
+    return inputPath;
   }
-  const existingHooks = existingConfig.hooks || {};
-  const existingEntries = Array.isArray(existingHooks[spec.config.hookKey]) ? existingHooks[spec.config.hookKey] : [];
-  const gauntletEntries = existingEntries.filter((e) => isGauntletHookEntry(e));
-  if (gauntletEntries.length === 0) {
-    await installHookWithLog(spec.config, spec.installedMsg, spec.existsMsg);
-    return;
+}
+function detectInstalledScope(entries, cwd) {
+  const pluginEntries = entries.filter((entry) => {
+    const name = entry.name ?? entry.id;
+    return name === "agent-gauntlet" || typeof name === "string" && name.startsWith("agent-gauntlet@");
+  });
+  const projectEntries = pluginEntries.filter((entry) => entry.scope === "project" && typeof entry.projectPath === "string" && isInProjectScope(cwd, entry.projectPath));
+  if (projectEntries.length > 0) {
+    return "project";
   }
-  const expectedEntry = spec.config.wrapInHooksArray ? { hooks: [spec.config.hookEntry] } : spec.config.hookEntry;
-  const expectedChecksum = computeExpectedHookChecksum([
-    expectedEntry
-  ]);
-  const actualChecksum = computeHookChecksum(existingEntries);
-  if (expectedChecksum === actualChecksum) {
-    console.log(chalk10.dim(spec.existsMsg));
-    return;
+  const hasUserInstall = pluginEntries.some((entry) => entry.scope === "user");
+  if (hasUserInstall) {
+    return "user";
   }
-  const shouldOverwrite = await promptHookOverwrite(spec.config.filePath, skipPrompts);
-  if (!shouldOverwrite) {
-    console.log(chalk10.dim(spec.existsMsg));
+  return null;
+}
+function printManualUpdateInstructions() {
+  console.error("Run these commands manually:");
+  console.error("  claude plugin marketplace update agent-gauntlet");
+  console.error("  claude plugin update agent-gauntlet@pcaplan/agent-gauntlet");
+}
+async function refreshCodexSkills(cwd) {
+  const localBase = path30.join(cwd, ".agents", "skills");
+  const localMarker = path30.join(localBase, "gauntlet-run");
+  const homeDir = process.env.HOME?.trim() || os9.homedir();
+  const globalBase = path30.join(homeDir, ".agents", "skills");
+  const globalMarker = path30.join(globalBase, "gauntlet-run");
+  let targetBase = null;
+  if (await exists(localMarker)) {
+    targetBase = localBase;
+  } else if (await exists(globalMarker)) {
+    targetBase = globalBase;
+  }
+  if (!targetBase) {
     return;
   }
-  const nonGauntletEntries = existingEntries.filter((e) => !isGauntletHookEntry(e));
-  const entryToAdd = spec.config.wrapInHooksArray ? { hooks: [spec.config.hookEntry] } : spec.config.hookEntry;
-  const newEntries = [...nonGauntletEntries, entryToAdd];
-  const merged = {
-    ...spec.config.baseConfig ?? {},
-    ...existingConfig,
-    hooks: { ...existingHooks, [spec.config.hookKey]: newEntries }
-  };
-  await fs31.mkdir(path29.dirname(spec.config.filePath), { recursive: true });
-  await fs31.writeFile(spec.config.filePath, `${JSON.stringify(merged, null, 2)}
-`);
-  console.log(chalk10.green(spec.installedMsg));
-}
-async function installHooksForAdapters(projectRoot, devAdapters, skipPrompts) {
-  for (const adapter of devAdapters) {
-    if (!adapter.supportsHooks())
+  for (const dirName of await getSkillDirNames()) {
+    const sourceDir = path30.join(SKILLS_SOURCE_DIR, dirName);
+    const targetDir = path30.join(targetBase, dirName);
+    if (!await exists(targetDir)) {
+      await copyDirRecursive({ src: sourceDir, dest: targetDir });
       continue;
-    if (adapter.name !== "claude" && adapter.name !== "cursor")
+    }
+    const sourceChecksum = await computeSkillChecksum(sourceDir);
+    const targetChecksum = await computeSkillChecksum(targetDir);
+    if (sourceChecksum === targetChecksum) {
       continue;
-    for (const kind of ["stop", "start"]) {
-      const target = { projectRoot, variant: adapter.name, kind };
-      await installHookWithChecksums(target, skipPrompts);
+    }
+    await fs31.rm(targetDir, { recursive: true, force: true });
+    await copyDirRecursive({ src: sourceDir, dest: targetDir });
+  }
+}
+function isCliUnavailableError(err) {
+  if (err != null && typeof err === "object") {
+    const code = err.code;
+    if (code === "ENOENT") {
+      return true;
     }
   }
+  const msg = err instanceof Error ? err.message.toLowerCase() : String(err).toLowerCase();
+  return msg.includes("command not found") || msg.includes("not installed");
+}
+async function detectClaudeScope(cwd) {
+  try {
+    const parsedPlugins = await listPlugins();
+    return detectInstalledScope(parsedPlugins, cwd);
+  } catch (error) {
+    if (isCliUnavailableError(error)) {
+      return null;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to detect Claude plugin installation: ${message}`);
+  }
+}
+async function updateClaudePlugin(scope) {
+  console.log(chalk11.cyan(`Updating agent-gauntlet Claude plugin (${scope} scope)...`));
+  const marketplaceResult = await updateMarketplace();
+  if (!marketplaceResult.success) {
+    console.error(chalk11.red("Plugin update failed."));
+    if (marketplaceResult.stderr) {
+      console.error(chalk11.red(marketplaceResult.stderr.trim()));
+    }
+    printManualUpdateInstructions();
+    throw new Error(marketplaceResult.stderr ?? "Failed to update plugin marketplace entry");
+  }
+  const pluginResult = await updatePlugin();
+  if (!pluginResult.success) {
+    console.error(chalk11.red("Plugin update failed."));
+    if (pluginResult.stderr) {
+      console.error(chalk11.red(pluginResult.stderr.trim()));
+    }
+    printManualUpdateInstructions();
+    throw new Error(pluginResult.stderr ?? "Failed to update plugin");
+  }
+}
+async function updateCursorPlugin(adapter, scope, cwd) {
+  console.log(chalk11.cyan(`Updating agent-gauntlet Cursor plugin (${scope} scope)...`));
+  const cursorResult = await adapter.updatePlugin(scope, cwd);
+  if (cursorResult.success) {
+    console.log(chalk11.green("Cursor plugin updated successfully."));
+    console.log(chalk11.yellow("Restart any open Cursor sessions to use the updated plugin."));
+  } else {
+    console.error(chalk11.yellow(`Cursor plugin update failed: ${cursorResult.error ?? "unknown error"}`));
+  }
+}
+async function runPluginUpdate(options) {
+  options?.skipPrompts;
+  const cwd = process.cwd();
+  const claudeScope = await detectClaudeScope(cwd);
+  const cursorAdapter = new CursorAdapter;
+  const cursorScope = await cursorAdapter.detectPlugin(cwd);
+  if (!(claudeScope || cursorScope)) {
+    throw new Error("No agent-gauntlet plugin is installed for this project. Please run `agent-gauntlet init` first.");
+  }
+  if (claudeScope) {
+    await updateClaudePlugin(claudeScope);
+  }
+  if (cursorScope) {
+    await updateCursorPlugin(cursorAdapter, cursorScope, cwd);
+  }
+  await refreshCodexSkills(cwd);
+  console.log(chalk11.green("Plugin update completed successfully."));
+  console.log(chalk11.yellow("Restart any open agent sessions to use the updated plugin."));
 }
 
 // src/commands/init.ts
-var __dirname2 = path30.dirname(fileURLToPath(import.meta.url));
-var SKILLS_SOURCE_DIR = (() => {
-  const bundled = path30.join(__dirname2, "..", "skills");
-  const dev = path30.join(__dirname2, "..", "..", "skills");
+var __dirname3 = path31.dirname(fileURLToPath3(import.meta.url));
+var SKILLS_SOURCE_DIR2 = (() => {
+  const bundled = path31.join(__dirname3, "..", "skills");
+  const dev = path31.join(__dirname3, "..", "..", "skills");
   try {
-    statSync(bundled);
+    statSync3(bundled);
     return bundled;
   } catch (err) {
     const code = err.code;
@@ -8518,8 +8717,8 @@ var SKILLS_SOURCE_DIR = (() => {
     throw err;
   }
 })();
-async function getSkillDirNames() {
-  const entries = await fs32.readdir(SKILLS_SOURCE_DIR, { withFileTypes: true });
+async function getSkillDirNames2() {
+  const entries = await fs32.readdir(SKILLS_SOURCE_DIR2, { withFileTypes: true });
   return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
 }
 var CLI_PREFERENCE_ORDER = [
@@ -8546,9 +8745,20 @@ function registerInitCommand(program) {
     await runInit(options);
   });
 }
+async function handleRerun(projectRoot, availableAdapters, skipPrompts) {
+  try {
+    await runPluginUpdate({ skipPrompts });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!message.includes("Claude plugin is not installed"))
+      throw error;
+    console.log(chalk12.yellow("Plugin not installed yet, running fresh install..."));
+    await installExternalFiles(projectRoot, availableAdapters, skipPrompts);
+  }
+}
 async function runInit(options) {
   const projectRoot = process.cwd();
-  const targetDir = path30.join(projectRoot, ".gauntlet");
+  const targetDir = path31.join(projectRoot, ".gauntlet");
   const skipPrompts = options.yes ?? false;
   console.log("Detecting available CLI agents...");
   const availableAdapters = await detectAvailableCLIs();
@@ -8558,33 +8768,33 @@ async function runInit(options) {
   }
   const detectedNames = availableAdapters.map((a) => a.name);
   const gauntletExists = await exists(targetDir);
-  let hookAdapters;
+  let devAdapters;
   let instructionCLINames;
   if (gauntletExists) {
-    console.log(chalk11.dim(".gauntlet/ already exists, skipping scaffolding"));
-    hookAdapters = availableAdapters;
+    console.log(chalk12.dim(".gauntlet/ already exists, skipping scaffolding"));
     instructionCLINames = detectedNames;
+    await handleRerun(projectRoot, availableAdapters, skipPrompts);
   } else {
     const devCLINames = await promptDevCLIs(detectedNames, skipPrompts);
-    hookAdapters = availableAdapters.filter((a) => devCLINames.includes(a.name));
-    for (const adapter of hookAdapters) {
+    devAdapters = availableAdapters.filter((a) => devCLINames.includes(a.name));
+    for (const adapter of devAdapters) {
       if (!adapter.supportsHooks()) {
-        console.log(chalk11.yellow(`  ${adapter.name} doesn't support hooks yet, skipping hook installation`));
+        console.log(chalk12.yellow(`  ${adapter.name} doesn't support hooks yet, skipping hook installation`));
       }
     }
     const reviewCLINames = await promptReviewCLIs(detectedNames, skipPrompts);
     const numReviews = await promptNumReviews(reviewCLINames.length, skipPrompts);
-    console.log(chalk11.cyan("Agent Gauntlet's built-in code quality reviewer will be installed."));
+    console.log(chalk12.cyan("Agent Gauntlet's built-in code quality reviewer will be installed."));
     await scaffoldGauntletDir(projectRoot, targetDir, reviewCLINames, numReviews);
     instructionCLINames = devCLINames;
+    await installExternalFiles(projectRoot, devAdapters, skipPrompts);
   }
-  await installExternalFiles(projectRoot, hookAdapters, skipPrompts);
   await addToGitignore(projectRoot, "gauntlet_logs");
   await printPostInitInstructions(instructionCLINames);
 }
 function printNoCLIsMessage() {
   console.log();
-  console.log(chalk11.red("Error: No CLI agents found. Install at least one:"));
+  console.log(chalk12.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");
@@ -8592,71 +8802,127 @@ function printNoCLIsMessage() {
 }
 async function scaffoldGauntletDir(_projectRoot, targetDir, reviewCLINames, numReviews) {
   if (await exists(targetDir)) {
-    console.log(chalk11.dim(".gauntlet/ already exists, skipping scaffolding"));
+    console.log(chalk12.dim(".gauntlet/ already exists, skipping scaffolding"));
     return;
   }
   await fs32.mkdir(targetDir);
-  await fs32.mkdir(path30.join(targetDir, "checks"));
-  await fs32.mkdir(path30.join(targetDir, "reviews"));
+  await fs32.mkdir(path31.join(targetDir, "checks"));
+  await fs32.mkdir(path31.join(targetDir, "reviews"));
   await writeConfigYml(targetDir, reviewCLINames);
-  await fs32.writeFile(path30.join(targetDir, "reviews", "code-quality.yml"), `builtin: code-quality
+  await fs32.writeFile(path31.join(targetDir, "reviews", "code-quality.yml"), `builtin: code-quality
 num_reviews: ${numReviews}
 `);
-  console.log(chalk11.green("Created .gauntlet/reviews/code-quality.yml"));
+  console.log(chalk12.green("Created .gauntlet/reviews/code-quality.yml"));
 }
-async function copyDirRecursive(opts) {
+async function copyDirRecursive2(opts) {
   await fs32.mkdir(opts.dest, { recursive: true });
   const entries = await fs32.readdir(opts.src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path30.join(opts.src, entry.name);
-    const destPath = path30.join(opts.dest, entry.name);
+    const srcPath = path31.join(opts.src, entry.name);
+    const destPath = path31.join(opts.dest, entry.name);
     if (entry.isDirectory()) {
-      await copyDirRecursive({ src: srcPath, dest: destPath });
+      await copyDirRecursive2({ src: srcPath, dest: destPath });
     } else {
       await fs32.copyFile(srcPath, destPath);
     }
   }
 }
-async function installSkillsWithChecksums(projectRoot, skipPrompts) {
-  const skillsDir = path30.join(projectRoot, ".claude", "skills");
-  for (const dirName of await getSkillDirNames()) {
-    const sourceDir = path30.join(SKILLS_SOURCE_DIR, dirName);
-    const targetDir = path30.join(skillsDir, dirName);
-    const relativeDir = `${path30.relative(projectRoot, targetDir)}/`;
+async function installSkillsWithChecksums(projectRoot, targetBaseDir, skipPrompts, updateAllState) {
+  const skillsDir = path31.isAbsolute(targetBaseDir) ? targetBaseDir : path31.join(projectRoot, targetBaseDir);
+  for (const dirName of await getSkillDirNames2()) {
+    const sourceDir = path31.join(SKILLS_SOURCE_DIR2, dirName);
+    const targetDir = path31.join(skillsDir, dirName);
+    const relativeDir = `${path31.relative(projectRoot, targetDir)}/`;
     if (!await exists(targetDir)) {
-      await copyDirRecursive({ src: sourceDir, dest: targetDir });
-      console.log(chalk11.green(`Created ${relativeDir}`));
+      await copyDirRecursive2({ src: sourceDir, dest: targetDir });
+      console.log(chalk12.green(`Created ${relativeDir}`));
       continue;
     }
     const sourceChecksum = await computeSkillChecksum(sourceDir);
     const targetChecksum = await computeSkillChecksum(targetDir);
     if (sourceChecksum === targetChecksum)
       continue;
-    const shouldOverwrite = await promptFileOverwrite(dirName, skipPrompts);
-    if (!shouldOverwrite)
+    let choice;
+    if (skipPrompts || updateAllState.updateAll) {
+      choice = "yes";
+    } else {
+      choice = await promptFileOverwrite(dirName, skipPrompts);
+      if (choice === "all") {
+        updateAllState.updateAll = true;
+      }
+    }
+    if (choice === "no")
       continue;
     await fs32.rm(targetDir, { recursive: true, force: true });
-    await copyDirRecursive({ src: sourceDir, dest: targetDir });
-    console.log(chalk11.green(`Updated ${relativeDir}`));
+    await copyDirRecursive2({ src: sourceDir, dest: targetDir });
+    console.log(chalk12.green(`Updated ${relativeDir}`));
+  }
+}
+async function detectAdaptersNeedingInstall(devAdapters, projectRoot) {
+  const result = [];
+  for (const adapter of devAdapters) {
+    if (!adapter.installPlugin)
+      continue;
+    if (adapter.detectPlugin) {
+      const existingScope = await adapter.detectPlugin(projectRoot);
+      if (existingScope) {
+        console.log(chalk12.dim(`${adapter.name} plugin already installed at ${existingScope} scope, skipping install`));
+        continue;
+      }
+    }
+    result.push(adapter);
+  }
+  return result;
+}
+async function installOtherAdapterSkills(projectRoot, devAdapters, skipPrompts, updateAllState) {
+  const seen = new Set;
+  for (const adapter of devAdapters) {
+    if (adapter.name === "claude" || adapter.name === "codex")
+      continue;
+    const dir = adapter.getProjectSkillDir();
+    if (dir && !seen.has(dir)) {
+      seen.add(dir);
+      await installSkillsWithChecksums(projectRoot, dir, skipPrompts, updateAllState);
+    }
   }
 }
 async function installExternalFiles(projectRoot, devAdapters, skipPrompts) {
-  await installSkillsWithChecksums(projectRoot, skipPrompts);
-  await installHooksForAdapters(projectRoot, devAdapters, skipPrompts);
+  const updateAllState = { updateAll: false };
+  const devAdapterNames = new Set(devAdapters.map((adapter) => adapter.name));
+  const adaptersNeedingInstall = await detectAdaptersNeedingInstall(devAdapters, projectRoot);
+  const needsScope = adaptersNeedingInstall.length > 0 || devAdapterNames.has("codex");
+  const installScope = needsScope ? await promptInstallScope(skipPrompts) : "project";
+  for (const adapter of adaptersNeedingInstall) {
+    await installAdapterPlugin(adapter, projectRoot, installScope);
+  }
+  if (devAdapterNames.has("codex")) {
+    const codexBaseDir = getCodexSkillsBaseDir(installScope);
+    await installSkillsWithChecksums(projectRoot, codexBaseDir, skipPrompts, updateAllState);
+  }
+  await installOtherAdapterSkills(projectRoot, devAdapters, skipPrompts, updateAllState);
 }
 async function printPostInitInstructions(devCLINames) {
   const hasNative = devCLINames.some((name) => NATIVE_CLIS.has(name));
-  const nonNativeNames = devCLINames.filter((name) => !NATIVE_CLIS.has(name));
-  const hasNonNative = nonNativeNames.length > 0;
+  const hasCodex = devCLINames.includes("codex");
+  const otherNonNativeNames = devCLINames.filter((name) => !NATIVE_CLIS.has(name) && name !== "codex");
+  const hasOtherNonNative = otherNonNativeNames.length > 0;
   console.log();
   if (hasNative) {
-    console.log(chalk11.bold("To complete setup, run /gauntlet-setup in your CLI. This will guide you through configuring the static checks (unit tests, linters, etc.) that Agent Gauntlet will run."));
+    console.log(chalk12.bold("To complete setup, run /gauntlet-setup in your CLI. This will guide you through configuring the static checks (unit tests, linters, etc.) that Agent Gauntlet will run."));
   }
-  if (hasNonNative) {
-    console.log(chalk11.bold("To complete setup, reference the setup skill in your CLI: @.claude/skills/gauntlet-setup/SKILL.md. This will guide you through configuring the static checks (unit tests, linters, etc.) that Agent Gauntlet will run."));
+  if (hasCodex) {
+    console.log(chalk12.bold("To complete setup in Codex, reference the setup skill: .agents/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 Codex skills:");
+    for (const dirName of await getSkillDirNames2()) {
+      console.log(`  .agents/skills/${dirName}/SKILL.md`);
+    }
+  }
+  if (hasOtherNonNative) {
+    console.log(chalk12.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 dirName of await getSkillDirNames()) {
+    for (const dirName of await getSkillDirNames2()) {
       console.log(`  @.claude/skills/${dirName}/SKILL.md`);
     }
   }
@@ -8719,11 +8985,11 @@ entry_points: []
 #     enabled: true
 #     format: text                # Options: text, json
 `;
-  await fs32.writeFile(path30.join(targetDir, "config.yml"), content);
-  console.log(chalk11.green("Created .gauntlet/config.yml"));
+  await fs32.writeFile(path31.join(targetDir, "config.yml"), content);
+  console.log(chalk12.green("Created .gauntlet/config.yml"));
 }
 async function addToGitignore(projectRoot, entry) {
-  const gitignorePath = path30.join(projectRoot, ".gitignore");
+  const gitignorePath = path31.join(projectRoot, ".gitignore");
   let content = "";
   if (await exists(gitignorePath)) {
     content = await fs32.readFile(gitignorePath, "utf-8");
@@ -8737,11 +9003,11 @@ async function addToGitignore(projectRoot, entry) {
 ` : "";
   await fs32.appendFile(gitignorePath, `${suffix}${entry}
 `);
-  console.log(chalk11.green(`Added ${entry} to .gitignore`));
+  console.log(chalk12.green(`Added ${entry} to .gitignore`));
 }
 function gitSilent(args, opts) {
   try {
-    return execFileSync("git", args, {
+    return execFileSync2("git", args, {
       encoding: "utf-8",
       timeout: opts?.timeout,
       stdio: ["pipe", "pipe", "ignore"]
@@ -8789,30 +9055,30 @@ async function detectAvailableCLIs() {
   for (const adapter of allAdapters) {
     const isAvailable = await adapter.isAvailable();
     if (isAvailable) {
-      console.log(chalk11.green(`  ✓ ${adapter.name}`));
+      console.log(chalk12.green(`  ✓ ${adapter.name}`));
       available.push(adapter);
     } else {
-      console.log(chalk11.dim(`  ✗ ${adapter.name} (not installed)`));
+      console.log(chalk12.dim(`  ✗ ${adapter.name} (not installed)`));
     }
   }
   return available;
 }
 // src/commands/list.ts
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 function registerListCommand(program) {
   program.command("list").description("List configured gates").action(async () => {
     try {
       const config = await loadConfig();
-      console.log(chalk12.bold("Check Gates:"));
+      console.log(chalk13.bold("Check Gates:"));
       for (const c of Object.values(config.checks)) {
         console.log(` - ${c.name}`);
       }
-      console.log(chalk12.bold(`
+      console.log(chalk13.bold(`
 Review Gates:`));
       for (const r of Object.values(config.reviews)) {
         console.log(` - ${r.name} (Tools: ${r.cli_preference?.join(", ")})`);
       }
-      console.log(chalk12.bold(`
+      console.log(chalk13.bold(`
 Entry Points:`));
       for (const ep of config.project.entry_points) {
         console.log(` - ${ep.path}`);
@@ -8823,7 +9089,7 @@ Entry Points:`));
       }
     } catch (error) {
       const err = error;
-      console.error(chalk12.red("Error:"), err.message);
+      console.error(chalk13.red("Error:"), err.message);
     }
   });
 }
@@ -8836,7 +9102,7 @@ function registerReviewCommand(program) {
 }
 // src/scripts/review-audit.ts
 import fs33 from "node:fs";
-import path31 from "node:path";
+import path32 from "node:path";
 import readline from "node:readline";
 function parseKeyValue2(text) {
   const result = {};
@@ -8863,7 +9129,7 @@ var parseDuration = (d) => {
 };
 function getLogDir3(cwd) {
   try {
-    const cfg = path31.join(cwd, ".gauntlet", "config.yml");
+    const cfg = path32.join(cwd, ".gauntlet", "config.yml");
     const m = fs33.readFileSync(cfg, "utf-8").match(/^log_dir:\s*(.+)$/m);
     if (m?.[1])
       return m[1].trim().replace(/^["']|["']$/g, "");
@@ -9170,7 +9436,7 @@ async function main2(date, since) {
     process.exit(1);
   }
   const logDir = getLogDir3(cwd);
-  const debugLogPath = path31.join(cwd, logDir, ".debug.log");
+  const debugLogPath = path32.join(cwd, logDir, ".debug.log");
   if (!fs33.existsSync(debugLogPath)) {
     console.log(`No debug log found. (looked in ${logDir}/.debug.log)`);
     process.exit(0);
@@ -9195,9 +9461,149 @@ function registerReviewAuditCommand(program) {
     await main2(opts.date, opts.since);
   });
 }
-// src/core/run-executor-lock.ts
+// src/core/run-executor.ts
+import fs37 from "node:fs/promises";
+import path36 from "node:path";
+
+// src/output/report.ts
 import fs34 from "node:fs/promises";
-import path32 from "node:path";
+import path33 from "node:path";
+function parseReviewJsonFilename(filename) {
+  const m = filename.match(/^(.+)_([^@]+)@(\d+)\.\d+\.json$/);
+  if (!(m?.[1] && m[2] && m[3]))
+    return null;
+  return {
+    jobId: m[1],
+    adapter: m[2],
+    reviewIndex: parseInt(m[3], 10)
+  };
+}
+async function collectViolationsFromFile(jsonPath, filename, startId) {
+  const content = await fs34.readFile(jsonPath, "utf-8");
+  const data = JSON.parse(content);
+  if (!(data.violations && Array.isArray(data.violations)))
+    return [];
+  const parsed = parseReviewJsonFilename(filename);
+  if (!parsed)
+    return [];
+  const violations = [];
+  let nextId = startId;
+  for (let i = 0;i < data.violations.length; i++) {
+    const v = data.violations[i];
+    if (!v)
+      continue;
+    const status = v.status || "new";
+    if (status !== "new")
+      continue;
+    violations.push({
+      id: nextId++,
+      gateLabel: parsed.jobId,
+      adapterSuffix: `${data.adapter}@${parsed.reviewIndex}`,
+      file: v.file,
+      line: v.line,
+      issue: v.issue,
+      fix: v.fix,
+      priority: v.priority,
+      jsonPath,
+      violationIndex: i
+    });
+  }
+  return violations;
+}
+async function enumerateNewViolations(logDir) {
+  let files;
+  try {
+    files = await fs34.readdir(logDir);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT")
+      return [];
+    throw new Error(`Failed to read log directory ${logDir}: ${err}`);
+  }
+  const reviewFiles = files.filter((f) => f.endsWith(".json") && parseReviewJsonFilename(f) !== null).sort();
+  const allViolations = [];
+  for (const file of reviewFiles) {
+    try {
+      const fileViolations = await collectViolationsFromFile(path33.join(logDir, file), file, allViolations.length + 1);
+      allViolations.push(...fileViolations);
+    } catch (err) {
+      throw new Error(`Failed to read review JSON ${file}: ${err}`);
+    }
+  }
+  return allViolations;
+}
+function statusLineText(status) {
+  switch (status) {
+    case "passed":
+      return "Status: Passed";
+    case "passed_with_warnings":
+      return "Status: Passed with warnings";
+    case "failed":
+      return "Status: Failed";
+    case "retry_limit_exceeded":
+      return "Status: Retry limit exceeded";
+    default:
+      return `Status: ${status}`;
+  }
+}
+function formatCheckFailure(result) {
+  const lines = [];
+  lines.push(`### ${result.jobId}`);
+  if (result.command)
+    lines.push(`Command: ${result.command}`);
+  if (result.workingDirectory)
+    lines.push(`Directory: ${result.workingDirectory}`);
+  if (result.fixInstructions)
+    lines.push(`Fix instructions: ${result.fixInstructions}`);
+  if (result.fixWithSkill)
+    lines.push(`Fix skill: ${result.fixWithSkill}`);
+  if (result.logPath)
+    lines.push(`Log: ${result.logPath}`);
+  lines.push("");
+  return lines;
+}
+function formatReviewViolation(v) {
+  const lines = [];
+  const priorityStr = v.priority ? ` [${v.priority}]` : "";
+  lines.push(`#${v.id}${priorityStr} ${v.gateLabel} (${v.adapterSuffix})`);
+  lines.push(`  ${v.file}:${v.line} - ${v.issue}`);
+  if (v.fix)
+    lines.push(`  Fix: ${v.fix}`);
+  lines.push(`  JSON: ${v.jsonPath}`);
+  lines.push("");
+  return lines;
+}
+async function generateReport(status, gateResults, logDir) {
+  const lines = [statusLineText(status)];
+  if (!gateResults || gateResults.length === 0) {
+    return lines.join(`
+`);
+  }
+  const checkFailures = gateResults.filter((r) => (r.status === "fail" || r.status === "error") && r.jobId.startsWith("check:"));
+  if (checkFailures.length > 0) {
+    lines.push("", "## CHECK FAILURES", "");
+    for (const result of checkFailures) {
+      lines.push(...formatCheckFailure(result));
+    }
+  }
+  const reviewViolations = await enumerateNewViolations(logDir);
+  if (reviewViolations.length > 0) {
+    lines.push("## REVIEW VIOLATIONS", "");
+    for (const v of reviewViolations) {
+      lines.push(...formatReviewViolation(v));
+    }
+  }
+  return lines.join(`
+`);
+}
+
+// src/core/run-executor-helpers.ts
+import fs36 from "node:fs/promises";
+import path35 from "node:path";
+
+// src/core/run-executor-lock.ts
+import fs35 from "node:fs/promises";
+import path34 from "node:path";
 var LOCK_FILENAME2 = ".gauntlet-run.lock";
 var STALE_LOCK_MS = 10 * 60 * 1000;
 function isProcessAlive(pid) {
@@ -9213,9 +9619,9 @@ function isProcessAlive(pid) {
 }
 async function isLockStale(lockPath) {
   try {
-    const lockContent = await fs34.readFile(lockPath, "utf-8");
+    const lockContent = await fs35.readFile(lockPath, "utf-8");
     const lockPid = Number.parseInt(lockContent.trim(), 10);
-    const lockStat = await fs34.stat(lockPath);
+    const lockStat = await fs35.stat(lockPath);
     const lockAgeMs = Date.now() - lockStat.mtimeMs;
     const pidValid = !Number.isNaN(lockPid);
     if (pidValid && !isProcessAlive(lockPid)) {
@@ -9230,10 +9636,10 @@ async function isLockStale(lockPath) {
   }
 }
 async function tryAcquireLock(logDir) {
-  await fs34.mkdir(logDir, { recursive: true });
-  const lockPath = path32.resolve(logDir, LOCK_FILENAME2);
+  await fs35.mkdir(logDir, { recursive: true });
+  const lockPath = path34.resolve(logDir, LOCK_FILENAME2);
   try {
-    await fs34.writeFile(lockPath, String(process.pid), { flag: "wx" });
+    await fs35.writeFile(lockPath, String(process.pid), { flag: "wx" });
     return true;
   } catch (err) {
     const isExist = typeof err === "object" && err !== null && "code" in err && err.code === "EEXIST";
@@ -9244,9 +9650,9 @@ async function tryAcquireLock(logDir) {
     if (!stale) {
       return false;
     }
-    await fs34.rm(lockPath, { force: true });
+    await fs35.rm(lockPath, { force: true });
     try {
-      await fs34.writeFile(lockPath, String(process.pid), { flag: "wx" });
+      await fs35.writeFile(lockPath, String(process.pid), { flag: "wx" });
       return true;
     } catch {
       return false;
@@ -9255,7 +9661,7 @@ async function tryAcquireLock(logDir) {
 }
 async function findLatestConsoleLog(logDir) {
   try {
-    const files = await fs34.readdir(logDir);
+    const files = await fs35.readdir(logDir);
     let maxNum = -1;
     let latestFile = null;
     for (const file of files) {
@@ -9271,7 +9677,7 @@ async function findLatestConsoleLog(logDir) {
         }
       }
     }
-    return latestFile ? path32.join(logDir, latestFile) : null;
+    return latestFile ? path34.join(logDir, latestFile) : null;
   } catch {
     return null;
   }
@@ -9494,6 +9900,16 @@ function determineStatus(outcome) {
 async function buildRunResult(ctx, outcome, jobs) {
   const consoleLogPath = await findLatestConsoleLog(ctx.config.project.log_dir);
   const status = determineStatus(outcome);
+  let reportText;
+  if (ctx.options.report) {
+    reportText = await generateReport(status, outcome.gateResults, ctx.config.project.log_dir);
+    const reportPath = path35.join(ctx.config.project.log_dir, "report.txt");
+    try {
+      await fs36.writeFile(reportPath, reportText, "utf-8");
+    } catch (err) {
+      console.debug(`Failed to write report file ${reportPath}: ${err}`);
+    }
+  }
   if (status === "passed" || status === "retry_limit_exceeded") {
     const reason = status === "passed" ? "all_passed" : "retry_limit_exceeded";
     const debugLogger = getDebugLogger();
@@ -9506,6 +9922,7 @@ async function buildRunResult(ctx, outcome, jobs) {
     gatesRun: jobs.length,
     gatesFailed: outcome.allPassed ? 0 : jobs.length,
     consoleLogPath: consoleLogPath ?? undefined,
+    reportText,
     gateResults: outcome.gateResults
   };
 }
@@ -9578,6 +9995,15 @@ async function runWithLock(ctx, isRerun, logsExist) {
   const { failuresMap, passedSlotsMap, changeOptions } = await processRerunMode2(ctx, isRerun, logsExist);
   const prepared = await detectAndPrepareChanges(ctx, isRerun, failuresMap, changeOptions);
   if ("earlyResult" in prepared) {
+    if (ctx.options.report) {
+      const reportText = await generateReport(prepared.earlyResult.status, prepared.earlyResult.gateResults, ctx.config.project.log_dir);
+      prepared.earlyResult.reportText = reportText;
+      try {
+        const reportPath = path36.join(ctx.config.project.log_dir, "report.txt");
+        await fs37.mkdir(ctx.config.project.log_dir, { recursive: true });
+        await fs37.writeFile(reportPath, reportText, "utf-8");
+      } catch {}
+    }
     return finalizeAndReturn(ctx.loggerInitializedHere, prepared.earlyResult, consoleLogHandle);
   }
   const result = await executeAndReport(ctx, logger, isRerun, failuresMap, passedSlotsMap, changeOptions, prepared.jobs);
@@ -9629,20 +10055,27 @@ async function executeRun(options = {}) {
 
 // src/commands/run.ts
 function registerRunCommand(program) {
-  program.command("run").description("Run gates for detected changes").option("-b, --base-branch <branch>", "Override base branch for change detection").option("-g, --gate <name>", "Run specific gate only").option("-c, --commit <sha>", "Use diff for a specific commit").option("-u, --uncommitted", "Use diff for current uncommitted changes (staged and unstaged)").option("-e, --enable-review <name>", "Activate a disabled review for this run (repeatable)", (value, prev = []) => [...prev, value], []).action(async (options) => {
+  program.command("run").description("Run gates for detected changes").option("-b, --base-branch <branch>", "Override base branch for change detection").option("-g, --gate <name>", "Run specific gate only").option("-c, --commit <sha>", "Use diff for a specific commit").option("-u, --uncommitted", "Use diff for current uncommitted changes (staged and unstaged)").option("-e, --enable-review <name>", "Activate a disabled review for this run (repeatable)", (value, prev = []) => [...prev, value], []).option("--report", "Write a structured failure report to stdout").action(async (options) => {
+    const reportEnabled = options.report ?? false;
     const result = await executeRun({
       baseBranch: options.baseBranch,
       gate: options.gate,
       commit: options.commit,
       uncommitted: options.uncommitted,
-      enableReviews: new Set(options.enableReview ?? [])
+      enableReviews: new Set(options.enableReview ?? []),
+      report: reportEnabled
     });
+    if (reportEnabled) {
+      const text = result.reportText ?? statusLineText(result.status);
+      process.stdout.write(`${text}
+`);
+    }
     const code = isSuccessStatus(result.status) ? 0 : 1;
     process.exit(code);
   });
 }
 // src/commands/skip.ts
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 function registerSkipCommand(program) {
   program.command("skip").description("Advance execution state baseline without running gates").action(async () => {
     let config;
@@ -9661,20 +10094,20 @@ function registerSkipCommand(program) {
       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.`));
+      console.log(chalk14.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);
+      console.error(chalk14.red("Error:"), err.message);
       process.exit(1);
     }
   });
 }
 // src/commands/start-hook.ts
-import fs35 from "node:fs/promises";
-import path33 from "node:path";
+import fs38 from "node:fs/promises";
+import path37 from "node:path";
 import YAML8 from "yaml";
 var START_HOOK_MESSAGE = `<IMPORTANT>
 This project uses Agent Gauntlet for automated quality verification.
@@ -9722,9 +10155,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 = path33.join(process.cwd(), ".gauntlet", "config.yml");
+    const configPath = path37.join(process.cwd(), ".gauntlet", "config.yml");
     try {
-      const content = await fs35.readFile(configPath, "utf-8");
+      const content = await fs38.readFile(configPath, "utf-8");
       if (!isValidConfig(content)) {
         return;
       }
@@ -9734,7 +10167,7 @@ function registerStartHookCommand(program) {
     const adapter = options.adapter;
     try {
       const cwd = process.cwd();
-      const logDir = path33.join(cwd, await getLogDir2(cwd));
+      const logDir = path37.join(cwd, await getLogDir2(cwd));
       const globalConfig = await loadGlobalConfig();
       const projectDebugLogConfig = await getDebugLogConfig(cwd);
       const debugLogConfig = mergeDebugLogConfig(projectDebugLogConfig, globalConfig.debug_log);
@@ -9751,17 +10184,119 @@ function registerStatusCommand(program) {
     main();
   });
 }
+// src/commands/update.ts
+function registerUpdateCommand(program) {
+  program.command("update").description("Update the agent-gauntlet Claude plugin and refresh skills").action(async () => {
+    await runPluginUpdate();
+  });
+}
+// src/commands/update-review.ts
+import fs39 from "node:fs/promises";
+async function ensureLogDir(logDir) {
+  try {
+    await fs39.stat(logDir);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") {
+      console.error(`Error: Log directory does not exist: ${logDir}`);
+      process.exit(1);
+    }
+    throw new Error(`Failed to access log directory ${logDir}: ${String(error)}`);
+  }
+}
+function printViolation(v) {
+  const priorityStr = v.priority ? ` [${v.priority}]` : "";
+  console.log(`#${v.id}${priorityStr} ${v.gateLabel} (${v.adapterSuffix})`);
+  console.log(`  ${v.file}:${v.line} - ${v.issue}`);
+  if (v.fix) {
+    console.log(`  Fix: ${v.fix}`);
+  }
+  console.log(`  JSON: ${v.jsonPath}`);
+  console.log("");
+}
+function registerUpdateReviewCommand(program) {
+  const cmd = program.command("update-review").description("Manage review violations");
+  cmd.command("list").description("List pending review violations with numeric IDs").action(async () => {
+    try {
+      const config = await loadConfig();
+      const logDir = config.project.log_dir;
+      await ensureLogDir(logDir);
+      const violations = await enumerateNewViolations(logDir);
+      if (violations.length === 0) {
+        console.log("No pending violations.");
+        process.exit(0);
+      }
+      for (const v of violations) {
+        printViolation(v);
+      }
+      process.exit(0);
+    } catch (error) {
+      const err = error;
+      console.error(`Error: ${err.message || "Unknown error"}`);
+      process.exit(1);
+    }
+  });
+  cmd.command("fix <id> <reason>").description("Mark a violation as fixed").action(async (idStr, reason) => {
+    await updateViolation(idStr, reason, "fixed");
+  });
+  cmd.command("skip <id> <reason>").description("Mark a violation as skipped").action(async (idStr, reason) => {
+    await updateViolation(idStr, reason, "skipped");
+  });
+}
+async function updateViolation(idStr, reason, newStatus) {
+  try {
+    if (!reason) {
+      console.error(`Error: Missing reason. Usage: agent-gauntlet update-review ${newStatus} <id> "<reason>"`);
+      process.exit(1);
+    }
+    const id = parseInt(idStr, 10);
+    if (Number.isNaN(id) || id < 1) {
+      console.error(`Error: Invalid ID: ${idStr}`);
+      process.exit(1);
+    }
+    const config = await loadConfig();
+    const logDir = config.project.log_dir;
+    const violations = await enumerateNewViolations(logDir);
+    const target = violations.find((v) => v.id === id);
+    if (!target) {
+      console.error(`Error: Violation #${id} not found. Use 'update-review list' to see available violations.`);
+      process.exit(1);
+    }
+    const content = await fs39.readFile(target.jsonPath, "utf-8");
+    const data = JSON.parse(content);
+    const violation = data.violations[target.violationIndex];
+    if (!violation) {
+      console.error(`Error: Violation at index ${target.violationIndex} not found in ${target.jsonPath}`);
+      process.exit(1);
+    }
+    const currentStatus = violation.status || "new";
+    if (currentStatus !== "new") {
+      console.error(`Error: Violation #${id} is already ${currentStatus} and cannot be updated.`);
+      process.exit(1);
+    }
+    violation.status = newStatus;
+    violation.result = reason;
+    await fs39.writeFile(target.jsonPath, JSON.stringify(data, null, 2), "utf-8");
+    const action = newStatus === "fixed" ? "Fixed" : "Skipped";
+    console.log(`${action} violation #${id}: ${target.file}:${target.line} - ${target.issue}`);
+    process.exit(0);
+  } catch (error) {
+    const err = error;
+    console.error(`Error: ${err.message || "Unknown error"}`);
+    process.exit(1);
+  }
+}
 // src/commands/validate.ts
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 function registerValidateCommand(program) {
   program.command("validate").description("Validate .gauntlet/ config files against schemas").action(async () => {
     try {
       await loadConfig();
-      console.log(chalk14.green("All config files are valid."));
+      console.log(chalk15.green("All config files are valid."));
       process.exitCode = 0;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      console.error(chalk14.red("Validation failed:"), message);
+      console.error(chalk15.red("Validation failed:"), message);
       process.exitCode = 1;
     }
   });
@@ -9779,6 +10314,8 @@ registerDetectCommand(program);
 registerListCommand(program);
 registerHealthCommand(program);
 registerInitCommand(program);
+registerUpdateCommand(program);
+registerUpdateReviewCommand(program);
 registerValidateCommand(program);
 registerSkipCommand(program);
 registerStartHookCommand(program);
@@ -9790,4 +10327,4 @@ if (process.argv.length < 3) {
 }
 program.parse(process.argv);
 
-//# debugId=BA297B6C5F2D9C1264756E2164756E21
+//# debugId=9B95D114BC2749E764756E2164756E21