agent-gauntlet 0.1.8 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-gauntlet",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "A CLI tool for testing AI coding agents",
   "license": "Apache-2.0",
   "author": "Paul Caplan",

package/src/commands/check.ts

@@ -7,6 +7,7 @@ import { JobGenerator } from '../core/job.js';
 import { Runner } from '../core/runner.js';
 import { Logger } from '../output/logger.js';
 import { ConsoleReporter } from '../output/console.js';
+import { rotateLogs } from './shared.js';
 
 export function registerCheckCommand(program: Command): void {
   program
@@ -18,6 +19,10 @@ export function registerCheckCommand(program: Command): void {
     .action(async (options) => {
       try {
         const config = await loadConfig();
+
+        // Rotate logs before starting
+        await rotateLogs(config.project.log_dir);
+
         const changeDetector = new ChangeDetector(config.project.base_branch, {
           commit: options.commit,
           uncommitted: options.uncommitted

package/src/commands/help.ts

@@ -11,6 +11,7 @@ export function registerHelpCommand(program: Command): void {
       console.log('of your repo that changed, based on a configurable set of entry points.\n');
       console.log(chalk.bold('Commands:\n'));
       console.log('  run      Run gates for detected changes');
+      console.log('  rerun    Rerun gates with previous failure context');
       console.log('  check    Run only applicable checks');
       console.log('  review   Run only applicable reviews');
       console.log('  detect   Show what gates would run (without executing them)');

package/src/commands/init.test.ts

@@ -1,11 +1,41 @@
-import { describe, it, expect, beforeEach, afterEach, beforeAll, afterAll } from 'bun:test';
+import { describe, it, expect, beforeEach, afterEach, beforeAll, afterAll, mock } from 'bun:test';
 import { Command } from 'commander';
-import { registerInitCommand } from './init.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
 const TEST_DIR = path.join(process.cwd(), 'test-init-' + Date.now());
 
+// Mock adapters
+const mockAdapters = [
+  {
+    name: 'mock-cli-1',
+    isAvailable: async () => true,
+    getProjectCommandDir: () => '.mock1',
+    getUserCommandDir: () => null,
+    getCommandExtension: () => '.sh',
+    canUseSymlink: () => false,
+    transformCommand: (content: string) => content,
+  },
+  {
+    name: 'mock-cli-2',
+    isAvailable: async () => false, // Not available
+    getProjectCommandDir: () => '.mock2',
+    getUserCommandDir: () => null,
+    getCommandExtension: () => '.sh',
+    canUseSymlink: () => false,
+    transformCommand: (content: string) => content,
+  }
+];
+
+mock.module('../cli-adapters/index.js', () => ({
+  getAllAdapters: () => mockAdapters,
+  getProjectCommandAdapters: () => mockAdapters,
+  getUserCommandAdapters: () => [],
+}));
+
+// Import after mocking
+const { registerInitCommand } = await import('./init.js');
+
 describe('Init Command', () => {
   let program: Command;
   const originalConsoleLog = console.log;
@@ -45,50 +75,33 @@ describe('Init Command', () => {
   });
 
   it('should create .gauntlet directory structure with --yes flag', async () => {
-    const initCmd = program.commands.find(cmd => cmd.name() === 'init');
+    // We expect it to use the available mock-cli-1
+    await program.parseAsync(['node', 'test', 'init', '--yes']);
+      
+    // Check that files were created
+    const gauntletDir = path.join(TEST_DIR, '.gauntlet');
+    const configFile = path.join(gauntletDir, 'config.yml');
+    const reviewsDir = path.join(gauntletDir, 'reviews');
+    const checksDir = path.join(gauntletDir, 'checks');
+    const runGauntletFile = path.join(gauntletDir, 'run_gauntlet.md');
     
-    // Use a timeout to prevent hanging if prompts occur
-    let timeoutId: ReturnType<typeof setTimeout> | undefined;
-    const testPromise = initCmd?.parseAsync(['init', '--yes']);
-    const timeoutPromise = new Promise((_, reject) => {
-      timeoutId = setTimeout(() => reject(new Error('Test timed out - init command may be prompting')), 3000);
-    });
+    expect(await fs.stat(gauntletDir)).toBeDefined();
+    expect(await fs.stat(configFile)).toBeDefined();
+    expect(await fs.stat(reviewsDir)).toBeDefined();
+    expect(await fs.stat(checksDir)).toBeDefined();
+    expect(await fs.stat(runGauntletFile)).toBeDefined();
     
-    try {
-      await Promise.race([testPromise, timeoutPromise]);
-      
-      // Check that files were created
-      const gauntletDir = path.join(TEST_DIR, '.gauntlet');
-      const configFile = path.join(gauntletDir, 'config.yml');
-      const reviewsDir = path.join(gauntletDir, 'reviews');
-      const checksDir = path.join(gauntletDir, 'checks');
-      const runGauntletFile = path.join(gauntletDir, 'run_gauntlet.md');
-      
-      expect(await fs.stat(gauntletDir)).toBeDefined();
-      expect(await fs.stat(configFile)).toBeDefined();
-      expect(await fs.stat(reviewsDir)).toBeDefined();
-      expect(await fs.stat(checksDir)).toBeDefined();
-      expect(await fs.stat(runGauntletFile)).toBeDefined();
-      
-      // Verify config content
-      const configContent = await fs.readFile(configFile, 'utf-8');
-      expect(configContent).toContain('base_branch');
-      expect(configContent).toContain('log_dir');
-      
-      // Verify review file content
-      const reviewFile = path.join(reviewsDir, 'code-quality.md');
-      const reviewContent = await fs.readFile(reviewFile, 'utf-8');
-      expect(reviewContent).toContain('cli_preference');
-    } catch (error: any) {
-      // If it times out, skip this test for now - the command installation part may need more complex mocking
-      if (error.message.includes('timed out')) {
-        console.log('Skipping test due to interactive prompt - command installation requires manual testing');
-        return;
-      }
-      throw error;
-    } finally {
-      if (timeoutId) clearTimeout(timeoutId);
-    }
+    // Verify config content
+    const configContent = await fs.readFile(configFile, 'utf-8');
+    expect(configContent).toContain('base_branch');
+    expect(configContent).toContain('log_dir');
+    expect(configContent).toContain('mock-cli-1'); // Should be present
+    expect(configContent).not.toContain('mock-cli-2'); // Should not be present (unavailable)
+    
+    // Verify review file content
+    const reviewFile = path.join(reviewsDir, 'code-quality.md');
+    const reviewContent = await fs.readFile(reviewFile, 'utf-8');
+    expect(reviewContent).toContain('mock-cli-1');
   });
 
   it('should not create directory if .gauntlet already exists', async () => {
@@ -96,8 +109,7 @@ describe('Init Command', () => {
     const gauntletDir = path.join(TEST_DIR, '.gauntlet');
     await fs.mkdir(gauntletDir, { recursive: true });
     
-    const initCmd = program.commands.find(cmd => cmd.name() === 'init');
-    await initCmd?.parseAsync(['init', '--yes']);
+    await program.parseAsync(['node', 'test', 'init', '--yes']);
     
     const output = logs.join('\n');
     expect(output).toContain('.gauntlet directory already exists');

package/src/commands/init.ts

@@ -4,7 +4,9 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import readline from 'node:readline';
 import { exists } from './shared.js';
-import { getAllAdapters, getProjectCommandAdapters, getUserCommandAdapters } from '../cli-adapters/index.js';
+import { getAllAdapters, getProjectCommandAdapters, getUserCommandAdapters, type CLIAdapter } from '../cli-adapters/index.js';
+
+const MAX_PROMPT_ATTEMPTS = 10;
 
 const GAUNTLET_COMMAND_CONTENT = `---
 description: Run the full verification gauntlet
@@ -23,6 +25,7 @@ Execute the autonomous verification suite.
    - All gates pass
    - You disagree with remaining failures (ask the human how to proceed)
    - Still failing after 3 rerun attempts
+8. Once all gates pass, do NOT commit or push your changes—await the human's review and explicit instruction to commit.
 `;
 
 type InstallLevel = 'none' | 'project' | 'user';
@@ -31,11 +34,18 @@ interface InitOptions {
   yes?: boolean;
 }
 
+interface InitConfig {
+  sourceDir: string;
+  lintCmd: string | null; // null means not selected, empty string means selected but blank (TODO)
+  testCmd: string | null; // null means not selected, empty string means selected but blank (TODO)
+  selectedAdapters: CLIAdapter[];
+}
+
 export function registerInitCommand(program: Command): void {
   program
     .command('init')
     .description('Initialize .gauntlet configuration')
-    .option('-y, --yes', 'Skip prompts and use defaults (project-level commands for all agents)')
+    .option('-y, --yes', 'Skip prompts and use defaults (all available CLIs, source: ., no extra checks)')
     .action(async (options: InitOptions) => {
       const projectRoot = process.cwd();
       const targetDir = path.join(projectRoot, '.gauntlet');
@@ -45,39 +55,90 @@ export function registerInitCommand(program: Command): void {
         return;
       }
 
+      // 1. CLI Detection
+      console.log('Detecting available CLI agents...');
+      const availableAdapters = await detectAvailableCLIs();
+
+      if (availableAdapters.length === 0) {
+        console.log();
+        console.log(chalk.red('Error: No CLI agents found. Install at least one:'));
+        console.log('  - Claude: https://docs.anthropic.com/en/docs/claude-code');
+        console.log('  - Gemini: https://github.com/google-gemini/gemini-cli');
+        console.log('  - Codex: https://github.com/openai/codex');
+        console.log();
+        return;
+      }
+
+      let config: InitConfig;
+
+      if (options.yes) {
+        config = {
+          sourceDir: '.',
+          lintCmd: null,
+          testCmd: null,
+          selectedAdapters: availableAdapters,
+        };
+      } else {
+        config = await promptForConfig(availableAdapters);
+      }
+
       // Create base config structure
       await fs.mkdir(targetDir);
       await fs.mkdir(path.join(targetDir, 'checks'));
       await fs.mkdir(path.join(targetDir, 'reviews'));
       
-      // Write sample config
-      const sampleConfig = `base_branch: origin/main
-log_dir: .gauntlet_logs
-cli:
-  default_preference:
-    - gemini
-    - codex
-    - claude
-  check_usage_limit: false
-entry_points:
-  - path: "."
-    reviews:
-      - code-quality
-`;
-      await fs.writeFile(path.join(targetDir, 'config.yml'), sampleConfig);
+      // 4. Commented Config Templates
+      // Generate config.yml
+      const configContent = generateConfigYml(config);
+      await fs.writeFile(path.join(targetDir, 'config.yml'), configContent);
       console.log(chalk.green('Created .gauntlet/config.yml'));
 
-      // Write sample review
-      const sampleReview = `--- 
-cli_preference:
-  - gemini
-  - codex
+      // Generate check files if selected
+      if (config.lintCmd !== null) {
+        const lintContent = `name: lint
+command: ${config.lintCmd || '# command: TODO - add your lint command (e.g., npm run lint)'}
+# parallel: false
+# run_in_ci: true
+# run_locally: true
+# timeout: 300
+`;
+        await fs.writeFile(path.join(targetDir, 'checks', 'lint.yml'), lintContent);
+        console.log(chalk.green('Created .gauntlet/checks/lint.yml'));
+      }
+
+      if (config.testCmd !== null) {
+        const testContent = `name: unit-tests
+command: ${config.testCmd || '# command: TODO - add your test command (e.g., npm test)'}
+# parallel: false
+# run_in_ci: true
+# run_locally: true
+# timeout: 300
+`;
+        await fs.writeFile(path.join(targetDir, 'checks', 'unit-tests.yml'), testContent);
+        console.log(chalk.green('Created .gauntlet/checks/unit-tests.yml'));
+      }
+
+      // 5. Improved Default Code Review Prompt
+      const reviewContent = `---
+num_reviews: 1
+# parallel: true
+# timeout: 300
+# cli_preference:
+#   - ${config.selectedAdapters[0]?.name || 'claude'}
 ---
 
 # Code Review
-Review this code.
+
+Review the diff for quality issues:
+
+- **Bugs**: Logic errors, null handling, edge cases, race conditions
+- **Security**: Input validation, secrets exposure, injection risks
+- **Maintainability**: Unclear code, missing error handling, duplication
+- **Performance**: Unnecessary work, N+1 queries, missing optimizations
+
+For each issue: cite file:line, explain the problem, suggest a fix.
 `;
-      await fs.writeFile(path.join(targetDir, 'reviews', 'code-quality.md'), sampleReview);
+      await fs.writeFile(path.join(targetDir, 'reviews', 'code-quality.md'), reviewContent);
       console.log(chalk.green('Created .gauntlet/reviews/code-quality.md'));
 
       // Write the canonical gauntlet command file
@@ -87,52 +148,181 @@ Review this code.
 
       // Handle command installation
       if (options.yes) {
-        // Default: install at project level for all agents
-        const adapters = getProjectCommandAdapters();
-        await installCommands('project', adapters.map(a => a.name), projectRoot, canonicalCommandPath);
+        // Default: install at project level for all selected agents (if they support it)
+        const adaptersToInstall = config.selectedAdapters.filter(a => a.getProjectCommandDir() !== null);
+        if (adaptersToInstall.length > 0) {
+            await installCommands('project', adaptersToInstall.map(a => a.name), projectRoot, canonicalCommandPath);
+        }
       } else {
-        // Interactive prompts
-        await promptAndInstallCommands(projectRoot, canonicalCommandPath);
+        // Interactive prompts - passing available adapters to avoid re-checking or offering unavailable ones
+        await promptAndInstallCommands(projectRoot, canonicalCommandPath, availableAdapters);
       }
     });
 }
 
-async function promptAndInstallCommands(projectRoot: string, canonicalCommandPath: string): Promise<void> {
-  // Read all lines from stdin first if not a TTY (piped input)
-  const isTTY = process.stdin.isTTY;
-  let inputLines: string[] = [];
-  let lineIndex = 0;
-
-  if (!isTTY) {
-    // Read all input at once for piped input
-    const chunks: Buffer[] = [];
-    for await (const chunk of process.stdin) {
-      chunks.push(chunk);
+async function detectAvailableCLIs(): Promise<CLIAdapter[]> {
+  const allAdapters = getAllAdapters();
+  const available: CLIAdapter[] = [];
+
+  for (const adapter of allAdapters) {
+    const isAvailable = await adapter.isAvailable();
+    if (isAvailable) {
+      console.log(chalk.green(`  ✓ ${adapter.name}`));
+      available.push(adapter);
+    } else {
+      console.log(chalk.dim(`  ✗ ${adapter.name} (not installed)`));
     }
-    const input = Buffer.concat(chunks).toString('utf-8');
-    inputLines = input.split('\n').map(l => l.trim());
   }
+  return available;
+}
 
-  const rl = isTTY ? readline.createInterface({
+async function promptForConfig(availableAdapters: CLIAdapter[]): Promise<InitConfig> {
+  const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout
-  }) : null;
-
-  const question = async (prompt: string): Promise<string> => {
-    if (isTTY && rl) {
-      return new Promise((resolve) => {
-        rl.question(prompt, (answer) => {
-          resolve(answer?.trim() ?? '');
-        });
+  });
+
+  const question = (prompt: string): Promise<string> => {
+    return new Promise((resolve) => {
+      rl.question(prompt, (answer) => {
+        resolve(answer?.trim() ?? '');
       });
-    } else {
-      // Non-interactive: read from pre-buffered lines
-      process.stdout.write(prompt);
-      const answer = inputLines[lineIndex] ?? '';
-      lineIndex++;
-      console.log(answer); // Echo the answer
-      return answer;
+    });
+  };
+
+  try {
+    // CLI Selection
+    console.log();
+    console.log('Which CLIs would you like to use?');
+    availableAdapters.forEach((adapter, i) => {
+      console.log(`  ${i + 1}) ${adapter.name}`);
+    });
+    console.log(`  ${availableAdapters.length + 1}) All`);
+
+    let selectedAdapters: CLIAdapter[] = [];
+    let attempts = 0;
+    while (true) {
+      attempts++;
+      if (attempts > MAX_PROMPT_ATTEMPTS) throw new Error('Too many invalid attempts');
+      const answer = await question(`(comma-separated, e.g., 1,2): `);
+      const selections = answer.split(',').map(s => s.trim()).filter(s => s);
+      
+      if (selections.length === 0) {
+        // Default to all if empty? Or force selection? Plan says "Which CLIs...". 
+        // Let's assume user must pick or we default to all if they just hit enter?
+        // Actually, usually enter means default. Let's make All the default if just Enter.
+        selectedAdapters = availableAdapters;
+        break;
+      }
+
+      let valid = true;
+      const chosen: CLIAdapter[] = [];
+
+      for (const sel of selections) {
+        const num = parseInt(sel, 10);
+        if (isNaN(num) || num < 1 || num > availableAdapters.length + 1) {
+          console.log(chalk.yellow(`Invalid selection: ${sel}`));
+          valid = false;
+          break;
+        }
+        if (num === availableAdapters.length + 1) {
+          chosen.push(...availableAdapters);
+        } else {
+          chosen.push(availableAdapters[num - 1]);
+        }
+      }
+
+      if (valid) {
+        selectedAdapters = [...new Set(chosen)];
+        break;
+      }
+    }
+
+    // Source Directory
+    console.log();
+    const sourceDirInput = await question('Enter your source directory (e.g., src, lib, .) [default: .]: ');
+    const sourceDir = sourceDirInput || '.';
+
+    // Lint Check
+    console.log();
+    const addLint = await question('Would you like to add a linting check? [y/N]: ');
+    let lintCmd: string | null = null;
+    if (addLint.toLowerCase().startsWith('y')) {
+      lintCmd = await question('Enter lint command (blank to fill later): ');
+    }
+
+    // Unit Test Check
+    console.log();
+    const addTest = await question('Would you like to add a unit test check? [y/N]: ');
+    let testCmd: string | null = null;
+    if (addTest.toLowerCase().startsWith('y')) {
+      testCmd = await question('Enter test command (blank to fill later): ');
     }
+
+    rl.close();
+    return {
+      sourceDir,
+      lintCmd,
+      testCmd,
+      selectedAdapters
+    };
+
+  } catch (error) {
+    rl.close();
+    throw error;
+  }
+}
+
+function generateConfigYml(config: InitConfig): string {
+  const cliList = config.selectedAdapters.map(a => `    - ${a.name}`).join('\n');
+  
+  let entryPoints = '';
+  
+  // If we have checks, we need a source directory entry point
+  if (config.lintCmd !== null || config.testCmd !== null) {
+    entryPoints += `  - path: "${config.sourceDir}"
+    checks:\n`;
+    if (config.lintCmd !== null) entryPoints += `      - lint\n`;
+    if (config.testCmd !== null) entryPoints += `      - unit-tests\n`;
+  }
+
+  // Always include root entry point for reviews
+  entryPoints += `  - path: "."
+    reviews:
+      - code-quality`;
+
+  return `base_branch: origin/main
+log_dir: .gauntlet_logs
+
+# Run gates in parallel when possible (default: true)
+# allow_parallel: true
+
+cli:
+  default_preference:
+${cliList}
+  # Check CLI usage quota before running (if unavailable, uses next in list)
+  # check_usage_limit: false
+
+entry_points:
+${entryPoints}
+`;
+}
+
+async function promptAndInstallCommands(projectRoot: string, canonicalCommandPath: string, availableAdapters: CLIAdapter[]): Promise<void> {
+  // Only proceed if we have available adapters
+  if (availableAdapters.length === 0) return;
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const question = (prompt: string): Promise<string> => {
+    return new Promise((resolve) => {
+      rl.question(prompt, (answer) => {
+        resolve(answer?.trim() ?? '');
+      });
+    });
   };
 
   try {
@@ -150,14 +340,12 @@ async function promptAndInstallCommands(projectRoot: string, canonicalCommandPat
 
     let installLevel: InstallLevel = 'none';
     let answer = await question('Select option [1-3]: ');
-    
-    // Handle EOF or empty input for non-TTY
-    if (!isTTY && answer === '' && lineIndex > inputLines.length) {
-      console.log(chalk.dim('\nNo input received, skipping command installation.'));
-      return;
-    }
+    let installLevelAttempts = 0;
 
     while (true) {
+      installLevelAttempts++;
+      if (installLevelAttempts > MAX_PROMPT_ATTEMPTS) throw new Error('Too many invalid attempts');
+
       if (answer === '1') {
         installLevel = 'none';
         break;
@@ -169,47 +357,48 @@ async function promptAndInstallCommands(projectRoot: string, canonicalCommandPat
         break;
       } else {
         console.log(chalk.yellow('Please enter 1, 2, or 3'));
-        if (!isTTY && lineIndex >= inputLines.length) {
-          console.log(chalk.dim('\nNo more input, skipping command installation.'));
-          return;
-        }
         answer = await question('Select option [1-3]: ');
       }
     }
 
     if (installLevel === 'none') {
       console.log(chalk.dim('\nSkipping command installation.'));
-      rl?.close();
+      rl.close();
       return;
     }
 
-    // Question 2: Which agents
-    const allAdapters = getAllAdapters();
-    const availableAdapters = installLevel === 'project' 
-      ? allAdapters.filter(a => a.getProjectCommandDir() !== null)
-      : allAdapters.filter(a => a.getUserCommandDir() !== null);
+    // Filter available adapters based on install level support
+    const installableAdapters = installLevel === 'project'
+      ? availableAdapters.filter(a => a.getProjectCommandDir() !== null)
+      : availableAdapters.filter(a => a.getUserCommandDir() !== null);
+
+    if (installableAdapters.length === 0) {
+      console.log(chalk.yellow(`No available agents support ${installLevel}-level commands.`));
+      rl.close();
+      return;
+    }
 
     console.log();
     console.log('Which CLI agents would you like to install the command for?');
-    availableAdapters.forEach((adapter, i) => {
+    installableAdapters.forEach((adapter, i) => {
       console.log(`  ${i + 1}) ${adapter.name}`);
     });
-    console.log(`  ${availableAdapters.length + 1}) All of the above`);
+    console.log(`  ${installableAdapters.length + 1}) All of the above`);
     console.log();
 
     let selectedAgents: string[] = [];
-    answer = await question(`Select options (comma-separated, e.g., 1,2 or ${availableAdapters.length + 1} for all): `);
+    answer = await question(`Select options (comma-separated, e.g., 1,2 or ${installableAdapters.length + 1} for all): `);
+    let agentSelectionAttempts = 0;
     
     while (true) {
+      agentSelectionAttempts++;
+      if (agentSelectionAttempts > MAX_PROMPT_ATTEMPTS) throw new Error('Too many invalid attempts');
+
       const selections = answer.split(',').map(s => s.trim()).filter(s => s);
       
       if (selections.length === 0) {
-        if (!isTTY && lineIndex >= inputLines.length) {
-          console.log(chalk.dim('\nNo more input, skipping command installation.'));
-          return;
-        }
         console.log(chalk.yellow('Please select at least one option'));
-        answer = await question(`Select options (comma-separated, e.g., 1,2 or ${availableAdapters.length + 1} for all): `);
+        answer = await question(`Select options (comma-separated, e.g., 1,2 or ${installableAdapters.length + 1} for all): `);
         continue;
       }
 
@@ -218,16 +407,15 @@ async function promptAndInstallCommands(projectRoot: string, canonicalCommandPat
       
       for (const sel of selections) {
         const num = parseInt(sel, 10);
-        if (isNaN(num) || num < 1 || num > availableAdapters.length + 1) {
+        if (isNaN(num) || num < 1 || num > installableAdapters.length + 1) {
           console.log(chalk.yellow(`Invalid selection: ${sel}`));
           valid = false;
           break;
         }
-        if (num === availableAdapters.length + 1) {
-          // All agents
-          agents.push(...availableAdapters.map(a => a.name));
+        if (num === installableAdapters.length + 1) {
+          agents.push(...installableAdapters.map(a => a.name));
         } else {
-          agents.push(availableAdapters[num - 1].name);
+          agents.push(installableAdapters[num - 1].name);
         }
       }
 
@@ -235,21 +423,16 @@ async function promptAndInstallCommands(projectRoot: string, canonicalCommandPat
         selectedAgents = [...new Set(agents)]; // Dedupe
         break;
       }
-      
-      if (!isTTY && lineIndex >= inputLines.length) {
-        console.log(chalk.dim('\nNo more input, skipping command installation.'));
-        return;
-      }
-      answer = await question(`Select options (comma-separated, e.g., 1,2 or ${availableAdapters.length + 1} for all): `);
+      answer = await question(`Select options (comma-separated, e.g., 1,2 or ${installableAdapters.length + 1} for all): `);
     }
 
-    rl?.close();
+    rl.close();
 
     // Install commands
     await installCommands(installLevel, selectedAgents, projectRoot, canonicalCommandPath);
 
   } catch (error: any) {
-    rl?.close();
+    rl.close();
     throw error;
   }
 }
@@ -286,11 +469,7 @@ async function installCommands(
     }
 
     if (!commandDir) {
-      if (level === 'project') {
-        console.log(chalk.yellow(`  ${adapter.name}: No project-level command support, skipping`));
-      } else {
-        console.log(chalk.yellow(`  ${adapter.name}: No user-level command support, skipping`));
-      }
+      // This shouldn't happen if we filtered correctly, but good safety check
       continue;
     }
 

package/src/commands/rerun.ts

@@ -7,7 +7,8 @@ import { JobGenerator } from '../core/job.js';
 import { Runner } from '../core/runner.js';
 import { Logger } from '../output/logger.js';
 import { ConsoleReporter } from '../output/console.js';
-import { findPreviousFailures, GateFailures, PreviousViolation } from '../utils/log-parser.js';
+import { findPreviousFailures, type GateFailures, type PreviousViolation } from '../utils/log-parser.js';
+import { rotateLogs } from './shared.js';
 
 export function registerRerunCommand(program: Command): void {
   program
@@ -51,6 +52,9 @@ export function registerRerunCommand(program: Command): void {
           console.log(chalk.dim('No previous failures found. Running as normal...'));
         }
 
+        // Rotate logs before starting the new run
+        await rotateLogs(config.project.log_dir);
+
         // Detect changes (default to uncommitted unless --commit is specified)
         // Note: Rerun defaults to uncommitted changes for faster iteration loops,
         // unlike 'run' which defaults to base_branch comparison.

package/src/commands/review.ts

@@ -7,6 +7,7 @@ import { JobGenerator } from '../core/job.js';
 import { Runner } from '../core/runner.js';
 import { Logger } from '../output/logger.js';
 import { ConsoleReporter } from '../output/console.js';
+import { rotateLogs } from './shared.js';
 
 export function registerReviewCommand(program: Command): void {
   program
@@ -18,6 +19,10 @@ export function registerReviewCommand(program: Command): void {
     .action(async (options) => {
       try {
         const config = await loadConfig();
+
+        // Rotate logs before starting
+        await rotateLogs(config.project.log_dir);
+
         const changeDetector = new ChangeDetector(config.project.base_branch, {
           commit: options.commit,
           uncommitted: options.uncommitted

package/src/commands/run.ts

@@ -7,6 +7,7 @@ import { JobGenerator } from '../core/job.js';
 import { Runner } from '../core/runner.js';
 import { Logger } from '../output/logger.js';
 import { ConsoleReporter } from '../output/console.js';
+import { rotateLogs } from './shared.js';
 
 export function registerRunCommand(program: Command): void {
   program
@@ -18,6 +19,10 @@ export function registerRunCommand(program: Command): void {
     .action(async (options) => {
       try {
         const config = await loadConfig();
+        
+        // Rotate logs before starting
+        await rotateLogs(config.project.log_dir);
+
         const changeDetector = new ChangeDetector(config.project.base_branch, {
           commit: options.commit,
           uncommitted: options.uncommitted

package/src/commands/shared.ts

@@ -1,4 +1,5 @@
 import fs from 'node:fs/promises';
+import path from 'node:path';
 
 export async function exists(path: string): Promise<boolean> {
   try {
@@ -8,3 +9,36 @@ export async function exists(path: string): Promise<boolean> {
     return false;
   }
 }
+
+export async function rotateLogs(logDir: string): Promise<void> {
+  const previousDir = path.join(logDir, 'previous');
+
+  try {
+    // 1. Ensure logDir exists (if not, nothing to rotate, but we should create it for future use if needed, 
+    //    though usually the logger creates it. If it doesn't exist, we can just return).
+    if (!(await exists(logDir))) {
+        return;
+    }
+
+    // 2. Clear .gauntlet_logs/previous if it exists
+    if (await exists(previousDir)) {
+      const previousFiles = await fs.readdir(previousDir);
+      await Promise.all(
+        previousFiles.map(file => fs.rm(path.join(previousDir, file), { recursive: true, force: true }))
+      );
+    } else {
+      await fs.mkdir(previousDir, { recursive: true });
+    }
+
+    // 3. Move all existing files in .gauntlet_logs/ to .gauntlet_logs/previous
+    const files = await fs.readdir(logDir);
+    await Promise.all(
+      files
+        .filter(file => file !== 'previous')
+        .map(file => fs.rename(path.join(logDir, file), path.join(previousDir, file)))
+    );
+  } catch (error) {
+    // Log warning but don't crash the run as log rotation failure isn't critical
+    console.warn(`Failed to rotate logs in ${logDir}:`, error instanceof Error ? error.message : error);
+  }
+}

package/src/core/runner.ts

@@ -66,18 +66,19 @@ export class Runner {
     if (this.shouldStop) return;
 
     this.reporter.onJobStart(job);
-    const logPath = this.logger.getLogPath(job.id);
-    const jobLogger = await this.logger.createJobLogger(job.id);
     
     let result: GateResult;
 
     if (job.type === 'check') {
+      const logPath = this.logger.getLogPath(job.id);
+      const jobLogger = await this.logger.createJobLogger(job.id);
       result = await this.checkExecutor.execute(
         job.id,
         job.gateConfig as any,
         job.workingDirectory,
         jobLogger
       );
+      result.logPath = logPath;
     } else {
       // Use sanitized Job ID for lookup because that's what log-parser uses (based on filenames)
       const safeJobId = sanitizeJobId(job.id);
@@ -95,7 +96,6 @@ export class Runner {
       );
     }
 
-    result.logPath = logPath;
     this.results.push(result);
     this.reporter.onJobComplete(job, result);
 
@@ -159,15 +159,24 @@ export class Runner {
   }
 
   private async recordPreflightFailure(job: Job, message: string): Promise<GateResult> {
-    const logPath = this.logger.getLogPath(job.id);
-    const jobLogger = await this.logger.createJobLogger(job.id);
-    await jobLogger(`[${new Date().toISOString()}] Health check failed\n${message}\n`);
+    if (job.type === 'check') {
+      const logPath = this.logger.getLogPath(job.id);
+      const jobLogger = await this.logger.createJobLogger(job.id);
+      await jobLogger(`[${new Date().toISOString()}] Health check failed\n${message}\n`);
+      return {
+        jobId: job.id,
+        status: 'error',
+        duration: 0,
+        message,
+        logPath
+      };
+    }
+
     return {
       jobId: job.id,
       status: 'error',
       duration: 0,
-      message,
-      logPath
+      message
     };
   }
 

package/src/gates/result.ts

@@ -6,4 +6,5 @@ export interface GateResult {
   duration: number; // ms
   message?: string; // summary message
   logPath?: string; // path to full log
+  logPaths?: string[]; // paths to multiple logs (e.g. per-agent logs)
 }

package/src/gates/review.test.ts

@@ -0,0 +1,152 @@
+import { describe, it, expect, beforeEach, afterEach, mock } from 'bun:test';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { ReviewGateExecutor } from './review.js';
+import { Logger } from '../output/logger.js';
+import * as cliAdapters from '../cli-adapters/index.js';
+import type { CLIAdapter } from '../cli-adapters/index.js';
+
+const TEST_DIR = path.join(process.cwd(), 'test-review-logs-' + Date.now());
+const LOG_DIR = path.join(TEST_DIR, 'logs');
+
+describe('ReviewGateExecutor Logging', () => {
+  let logger: Logger;
+  let executor: ReviewGateExecutor;
+
+  beforeEach(async () => {
+    await fs.mkdir(TEST_DIR, { recursive: true });
+    await fs.mkdir(LOG_DIR, { recursive: true });
+    logger = new Logger(LOG_DIR);
+    executor = new ReviewGateExecutor();
+
+    // Mock getAdapter
+    mock.module('../cli-adapters/index.js', () => ({
+      getAdapter: (name: string) => ({
+        name,
+        isAvailable: async () => true,
+        checkHealth: async () => ({ status: 'healthy' }),
+        // execute returns the raw string output from the LLM, which is then parsed by the executor.
+        // The real adapter returns a string. In this test, we return a JSON string to simulate
+        // the LLM returning structured data. This IS intentional and matches the expected contract
+        // where execute() -> Promise<string>.
+        execute: async () => {
+          await new Promise(r => setTimeout(r, 1)); // Simulate async work
+          return JSON.stringify({ status: 'pass', message: 'OK' });
+        },
+        getProjectCommandDir: () => null,
+        getUserCommandDir: () => null,
+        getCommandExtension: () => 'md',
+        canUseSymlink: () => false,
+        transformCommand: (c: string) => c
+      } as unknown as CLIAdapter)
+    }));
+
+    // Mock git commands via util.promisify(exec)
+    mock.module('node:util', () => ({
+      promisify: (fn: Function) => {
+        // Only mock exec, let others pass (though in this test env we likely only use exec)
+        if (fn.name === 'exec') {
+          return async (cmd: string) => {
+            if (/^git diff/.test(cmd)) return 'diff content';
+            if (/^git ls-files/.test(cmd)) return 'file.ts';
+            return { stdout: '', stderr: '' };
+          };
+        }
+        // Fallback for other functions if needed
+        return async () => {}; 
+      }
+    }));
+  });
+
+  afterEach(async () => {
+    await fs.rm(TEST_DIR, { recursive: true, force: true });
+    mock.restore();
+  });
+
+  it('should only create adapter-specific logs and no generic log', async () => {
+    const jobId = 'review:src:code-quality';
+    const config = {
+      name: 'code-quality',
+      cli_preference: ['codex', 'claude'],
+      num_reviews: 2
+    };
+
+    const loggerFactory = logger.createLoggerFactory(jobId);
+    
+    // We need to mock getDiff since it uses execAsync which we mocked
+    // Actually ReviewGateExecutor is a class, we can mock its private method if needed
+    // or just let it run if the mock promisify works.
+    
+    const result = await executor.execute(
+      jobId,
+      config as any,
+      'src/',
+      loggerFactory,
+      'main'
+    );
+
+    expect(result.status).toBe('pass');
+    expect(result.logPaths).toBeDefined();
+    expect(result.logPaths).toHaveLength(2);
+    expect(result.logPaths?.[0]).toContain('review_src_code-quality_codex.log');
+    expect(result.logPaths?.[1]).toContain('review_src_code-quality_claude.log');
+
+    const files = await fs.readdir(LOG_DIR);
+    expect(files).toContain('review_src_code-quality_codex.log');
+    expect(files).toContain('review_src_code-quality_claude.log');
+    expect(files).not.toContain('review_src_code-quality.log');
+
+    // Verify multiplexed content
+    const codexLog = await fs.readFile(path.join(LOG_DIR, 'review_src_code-quality_codex.log'), 'utf-8');
+    expect(codexLog).toContain('Starting review: code-quality');
+    expect(codexLog).toContain('Review result (codex): pass');
+
+    const claudeLog = await fs.readFile(path.join(LOG_DIR, 'review_src_code-quality_claude.log'), 'utf-8');
+    expect(claudeLog).toContain('Starting review: code-quality');
+    expect(claudeLog).toContain('Review result (claude): pass');
+  });
+
+  it('should be handled correctly by ConsoleReporter', async () => {
+    const jobId = 'review:src:code-quality';
+    const codexPath = path.join(LOG_DIR, 'review_src_code-quality_codex.log');
+    const claudePath = path.join(LOG_DIR, 'review_src_code-quality_claude.log');
+
+    await fs.writeFile(codexPath, `
+[2026-01-14T10:00:00.000Z] Starting review: code-quality
+--- Parsed Result (codex) ---
+Status: FAIL
+Violations:
+1. src/index.ts:10 - Security risk
+   Fix: Use a safer method
+`);
+
+    await fs.writeFile(claudePath, `
+[2026-01-14T10:00:00.000Z] Starting review: code-quality
+--- Parsed Result (claude) ---
+Status: FAIL
+Violations:
+1. src/main.ts:20 - Style issue
+   Fix: Rename variable
+`);
+
+    const result = {
+      jobId,
+      status: 'fail' as const,
+      duration: 1000,
+      message: 'Found violations',
+      logPaths: [codexPath, claudePath]
+    };
+
+    const { ConsoleReporter } = await import('../output/console.js');
+    const reporter = new ConsoleReporter();
+    
+    // We can access extractFailureDetails directly as it is public
+    const details = await reporter.extractFailureDetails(result);
+    
+    // Check for presence of key information rather than exact counts
+    expect(details.some((d: string) => d.includes('src/index.ts') && d.includes('10') && d.includes('Security risk'))).toBe(true);
+    expect(details.some((d: string) => d.includes('Use a safer method'))).toBe(true);
+    expect(details.some((d: string) => d.includes('src/main.ts') && d.includes('20') && d.includes('Style issue'))).toBe(true);
+    expect(details.some((d: string) => d.includes('Rename variable'))).toBe(true);
+  });
+});

package/src/gates/review.ts

@@ -10,6 +10,7 @@ import { type PreviousViolation } from '../utils/log-parser.js';
 const execAsync = promisify(exec);
 
 const MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+const MAX_LOG_BUFFER_SIZE = 10000;
 
 const JSON_SYSTEM_INSTRUCTION = `
 You are in a read-only mode. You may read files in the repository to gather context.
@@ -69,14 +70,64 @@ export class ReviewGateExecutor {
     jobId: string,
     config: ReviewConfig,
     entryPointPath: string,
-    loggerFactory: (adapterName?: string) => Promise<(output: string) => Promise<void>>,
+    loggerFactory: (adapterName?: string) => Promise<{ logger: (output: string) => Promise<void>; logPath: string }>,
     baseBranch: string,
     previousFailures?: Map<string, PreviousViolation[]>,
     changeOptions?: { commit?: string; uncommitted?: boolean },
     checkUsageLimit: boolean = false
   ): Promise<GateResult> {
     const startTime = Date.now();
-    const mainLogger = await loggerFactory();
+    const logBuffer: string[] = [];
+    let logSequence = 0; // Monotonic counter for dedup
+    const activeLoggers: Array<(output: string, index: number) => Promise<void>> = [];
+    const logPaths: string[] = [];
+    const logPathsSet = new Set<string>(); // O(1) lookup
+
+    const mainLogger = async (output: string) => {
+      const seq = logSequence++;
+      // Atomic length check and push
+      // We check length directly on the array property to ensure we use the current value.
+      // Even if we exceed the limit slightly due to concurrency (impossible in single-threaded JS),
+      // it's a soft limit.
+      if (logBuffer.length < MAX_LOG_BUFFER_SIZE) {
+        logBuffer.push(output);
+      }
+      // Use allSettled to prevent failures from stopping the main logger
+      await Promise.allSettled(activeLoggers.map(l => l(output, seq)));
+    };
+
+    const getAdapterLogger = async (adapterName: string) => {
+      const { logger, logPath } = await loggerFactory(adapterName);
+      if (!logPathsSet.has(logPath)) {
+        logPathsSet.add(logPath);
+        logPaths.push(logPath);
+      }
+
+      // Robust synchronization using index tracking.
+      // We add the logger to activeLoggers FIRST to catch all future messages.
+      // We also flush the buffer.
+      // We use 'seenIndices' to prevent duplicates if a message arrives via both paths
+      // (e.g. added to buffer and sent to activeLoggers simultaneously).
+      // This acts as the atomic counter mechanism requested to safely handle race conditions.
+      // Even if mainLogger pushes to buffer and calls activeLoggers during the snapshot flush,
+      // seenIndices will prevent double logging.
+      const seenIndices = new Set<number>();
+      
+      const safeLogger = async (msg: string, index: number) => {
+        if (seenIndices.has(index)) return;
+        seenIndices.add(index);
+        await logger(msg);
+      };
+
+      activeLoggers.push(safeLogger);
+      
+      // Flush existing buffer
+      const snapshot = [...logBuffer];
+      // We pass the loop index 'i' which corresponds to the buffer index
+      await Promise.all(snapshot.map((msg, i) => safeLogger(msg, i)));
+      
+      return logger;
+    };
 
     try {
       await mainLogger(`Starting review: ${config.name}\n`);
@@ -91,7 +142,8 @@ export class ReviewGateExecutor {
           jobId,
           status: 'pass',
           duration: Date.now() - startTime,
-          message: 'No changes to review'
+          message: 'No changes to review',
+          logPaths
         };
       }
 
@@ -138,7 +190,8 @@ export class ReviewGateExecutor {
             jobId,
             status: 'error',
             duration: Date.now() - startTime,
-            message: msg
+            message: msg,
+            logPaths
           };
         }
 
@@ -148,7 +201,7 @@ export class ReviewGateExecutor {
 
         const results = await Promise.all(
           selectedAdapters.map((toolName) =>
-            this.runSingleReview(toolName, config, diff, loggerFactory, mainLogger, previousFailures, true, checkUsageLimit)
+            this.runSingleReview(toolName, config, diff, getAdapterLogger, mainLogger, previousFailures, true, checkUsageLimit)
           )
         );
 
@@ -162,7 +215,7 @@ export class ReviewGateExecutor {
         // Sequential Execution Logic
         for (const toolName of preferences) {
           if (usedAdapters.size >= required) break;
-          const res = await this.runSingleReview(toolName, config, diff, loggerFactory, mainLogger, previousFailures, false, checkUsageLimit);
+          const res = await this.runSingleReview(toolName, config, diff, getAdapterLogger, mainLogger, previousFailures, false, checkUsageLimit);
           if (res) {
             outputs.push({ adapter: res.adapter, ...res.evaluation });
             usedAdapters.add(res.adapter);
@@ -177,7 +230,8 @@ export class ReviewGateExecutor {
           jobId,
           status: 'error',
           duration: Date.now() - startTime,
-          message: msg
+          message: msg,
+          logPaths
         };
       }
 
@@ -201,7 +255,8 @@ export class ReviewGateExecutor {
         jobId,
         status,
         duration: Date.now() - startTime,
-        message
+        message,
+        logPaths
       };
     } catch (error: any) {
       await mainLogger(`Critical Error: ${error.message}\n`);
@@ -210,7 +265,8 @@ export class ReviewGateExecutor {
         jobId,
         status: 'error',
         duration: Date.now() - startTime,
-        message: error.message
+        message: error.message,
+        logPaths
       };
     }
   }
@@ -219,7 +275,7 @@ export class ReviewGateExecutor {
     toolName: string,
     config: ReviewConfig,
     diff: string,
-    loggerFactory: (adapterName?: string) => Promise<(output: string) => Promise<void>>,
+    getAdapterLogger: (adapterName: string) => Promise<(output: string) => Promise<void>>,
     mainLogger: (output: string) => Promise<void>,
     previousFailures?: Map<string, PreviousViolation[]>,
     skipHealthCheck: boolean = false,
@@ -238,7 +294,7 @@ export class ReviewGateExecutor {
     }
 
     // Create per-adapter logger
-    const adapterLogger = await loggerFactory(adapter.name);
+    const adapterLogger = await getAdapterLogger(adapter.name);
 
     try {
       const startMsg = `[START] review:.:${config.name} (${adapter.name})`;

package/src/output/console.ts

@@ -43,17 +43,26 @@ export class ConsoleReporter {
     }
   }
 
-  private async extractFailureDetails(result: GateResult): Promise<string[]> {
-    if (!result.logPath) {
+  /** @internal Public for testing */
+  async extractFailureDetails(result: GateResult): Promise<string[]> {
+    const logPaths = result.logPaths || (result.logPath ? [result.logPath] : []);
+    
+    if (logPaths.length === 0) {
       return [result.message ?? 'Unknown error'];
     }
 
-    try {
-      const logContent = await fs.readFile(result.logPath, 'utf-8');
-      return this.parseLogContent(logContent, result.jobId);
-    } catch (error) {
-      return [result.message ?? 'Unknown error', `(Could not read log file: ${result.logPath})`];
+    const allDetails: string[] = [];
+    for (const logPath of logPaths) {
+      try {
+        const logContent = await fs.readFile(logPath, 'utf-8');
+        const details = this.parseLogContent(logContent, result.jobId);
+        allDetails.push(...details);
+      } catch (error: any) {
+        allDetails.push(`(Could not read log file: ${logPath})`);
+      }
     }
+
+    return allDetails.length > 0 ? allDetails : [result.message ?? 'Unknown error'];
   }
 
   private parseLogContent(logContent: string, jobId: string): string[] {
@@ -63,8 +72,13 @@ export class ConsoleReporter {
     // Check if this is a review log
     if (jobId.startsWith('review:')) {
       // Look for parsed violations section (formatted output)
-      const violationsStart = logContent.indexOf('--- Parsed Result ---');
-      if (violationsStart !== -1) {
+      // Use regex to be flexible about adapter name in parentheses
+      // Matches: "--- Parsed Result ---" or "--- Parsed Result (adapter) ---"
+      const parsedResultRegex = /---\s*Parsed Result(?:\s+\(([^)]+)\))?\s*---/;
+      const match = logContent.match(parsedResultRegex);
+      
+      if (match && match.index !== undefined) {
+        const violationsStart = match.index;
         const violationsSection = logContent.substring(violationsStart);
         const sectionLines = violationsSection.split('\n');
         
@@ -192,7 +206,9 @@ export class ConsoleReporter {
       details.forEach(detail => console.log(detail));
     }
     
-    if (result.logPath) {
+    if (result.logPaths && result.logPaths.length > 0) {
+      result.logPaths.forEach(p => console.log(chalk.dim(`  Log: ${p}`)));
+    } else if (result.logPath) {
       console.log(chalk.dim(`  Log: ${result.logPath}`));
     }
     

package/src/output/logger.ts

@@ -48,12 +48,12 @@ export class Logger {
     };
   }
 
-  createLoggerFactory(jobId: string): (adapterName?: string) => Promise<(text: string) => Promise<void>> {
+  createLoggerFactory(jobId: string): (adapterName?: string) => Promise<{ logger: (text: string) => Promise<void>; logPath: string }> {
     return async (adapterName?: string) => {
       const logPath = this.getLogPath(jobId, adapterName);
       await this.initFile(logPath);
 
-      return async (text: string) => {
+      const logger = async (text: string) => {
         const timestamp = formatTimestamp();
         const lines = text.split('\n');
         if (lines.length > 0) {
@@ -61,6 +61,8 @@ export class Logger {
         }
         await fs.appendFile(logPath, lines.join('\n') + (text.endsWith('\n') ? '' : '\n'));
       };
+
+      return { logger, logPath };
     };
   }
 }

package/src/utils/log-parser.ts

@@ -71,10 +71,10 @@ export async function parseLogFile(logPath: string): Promise<GateFailures | null
         const violations: PreviousViolation[] = [];
 
         // 1. Look for "--- Parsed Result ---"
-        const parsedResultMatch = sectionContent.match(/--- Parsed Result ---([\s\S]*?)(?:$|---)/);
+        const parsedResultMatch = sectionContent.match(/---\s*Parsed Result(?:\s+\(([^)]+)\))?\s*---([\s\S]*?)(?:$|---)/);
         
         if (parsedResultMatch) {
-            const parsedContent = parsedResultMatch[1];
+            const parsedContent = parsedResultMatch[2];
             
             // Check status
             if (parsedContent.includes('Status: PASS')) {