rafcode 2.1.1 → 2.2.0

package/src/utils/token-tracker.ts

@@ -0,0 +1,135 @@
+import { UsageData, PricingConfig } from '../types/config.js';
+import { resolveModelPricingCategory, getPricingConfig } from './config.js';
+
+/** Cost breakdown for a single task or accumulated total. */
+export interface CostBreakdown {
+  inputCost: number;
+  outputCost: number;
+  cacheReadCost: number;
+  cacheCreateCost: number;
+  totalCost: number;
+}
+
+/** Per-task usage snapshot stored by the tracker. */
+export interface TaskUsageEntry {
+  taskId: string;
+  usage: UsageData;
+  cost: CostBreakdown;
+}
+
+/**
+ * Accumulates token usage across multiple task executions and calculates costs
+ * using configurable per-model pricing.
+ */
+export class TokenTracker {
+  private entries: TaskUsageEntry[] = [];
+  private pricingConfig: PricingConfig;
+
+  constructor(pricingConfig?: PricingConfig) {
+    this.pricingConfig = pricingConfig ?? getPricingConfig();
+  }
+
+  /**
+   * Record usage data from a completed task.
+   */
+  addTask(taskId: string, usage: UsageData): TaskUsageEntry {
+    const cost = this.calculateCost(usage);
+    const entry: TaskUsageEntry = { taskId, usage, cost };
+    this.entries.push(entry);
+    return entry;
+  }
+
+  /**
+   * Get all recorded task entries.
+   */
+  getEntries(): readonly TaskUsageEntry[] {
+    return this.entries;
+  }
+
+  /**
+   * Get accumulated totals across all tasks.
+   */
+  getTotals(): { usage: UsageData; cost: CostBreakdown } {
+    const totalUsage: UsageData = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0,
+      modelUsage: {},
+    };
+    const totalCost: CostBreakdown = {
+      inputCost: 0,
+      outputCost: 0,
+      cacheReadCost: 0,
+      cacheCreateCost: 0,
+      totalCost: 0,
+    };
+
+    for (const entry of this.entries) {
+      totalUsage.inputTokens += entry.usage.inputTokens;
+      totalUsage.outputTokens += entry.usage.outputTokens;
+      totalUsage.cacheReadInputTokens += entry.usage.cacheReadInputTokens;
+      totalUsage.cacheCreationInputTokens += entry.usage.cacheCreationInputTokens;
+
+      // Merge per-model usage
+      for (const [modelId, modelUsage] of Object.entries(entry.usage.modelUsage)) {
+        const existing = totalUsage.modelUsage[modelId];
+        if (existing) {
+          existing.inputTokens += modelUsage.inputTokens;
+          existing.outputTokens += modelUsage.outputTokens;
+          existing.cacheReadInputTokens += modelUsage.cacheReadInputTokens;
+          existing.cacheCreationInputTokens += modelUsage.cacheCreationInputTokens;
+        } else {
+          totalUsage.modelUsage[modelId] = { ...modelUsage };
+        }
+      }
+
+      totalCost.inputCost += entry.cost.inputCost;
+      totalCost.outputCost += entry.cost.outputCost;
+      totalCost.cacheReadCost += entry.cost.cacheReadCost;
+      totalCost.cacheCreateCost += entry.cost.cacheCreateCost;
+      totalCost.totalCost += entry.cost.totalCost;
+    }
+
+    return { usage: totalUsage, cost: totalCost };
+  }
+
+  /**
+   * Calculate cost for a given UsageData using per-model pricing.
+   * Uses per-model breakdown when available, falls back to aggregate with sonnet pricing.
+   */
+  calculateCost(usage: UsageData): CostBreakdown {
+    const result: CostBreakdown = {
+      inputCost: 0,
+      outputCost: 0,
+      cacheReadCost: 0,
+      cacheCreateCost: 0,
+      totalCost: 0,
+    };
+
+    const modelEntries = Object.entries(usage.modelUsage);
+
+    if (modelEntries.length > 0) {
+      // Use per-model breakdown for accurate pricing
+      for (const [modelId, modelUsage] of modelEntries) {
+        const category = resolveModelPricingCategory(modelId);
+        const pricing = this.pricingConfig[category ?? 'sonnet'];
+
+        result.inputCost += (modelUsage.inputTokens / 1_000_000) * pricing.inputPerMTok;
+        result.outputCost += (modelUsage.outputTokens / 1_000_000) * pricing.outputPerMTok;
+        result.cacheReadCost += (modelUsage.cacheReadInputTokens / 1_000_000) * pricing.cacheReadPerMTok;
+        result.cacheCreateCost += (modelUsage.cacheCreationInputTokens / 1_000_000) * pricing.cacheCreatePerMTok;
+      }
+    } else {
+      // Fallback: use aggregate totals with sonnet pricing
+      const pricing = this.pricingConfig.sonnet;
+      result.inputCost = (usage.inputTokens / 1_000_000) * pricing.inputPerMTok;
+      result.outputCost = (usage.outputTokens / 1_000_000) * pricing.outputPerMTok;
+      result.cacheReadCost = (usage.cacheReadInputTokens / 1_000_000) * pricing.cacheReadPerMTok;
+      result.cacheCreateCost = (usage.cacheCreationInputTokens / 1_000_000) * pricing.cacheCreatePerMTok;
+    }
+
+    result.totalCost = result.inputCost + result.outputCost + result.cacheReadCost + result.cacheCreateCost;
+    return result;
+  }
+}

package/src/utils/validation.ts

@@ -2,6 +2,9 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { execSync } from 'node:child_process';
 import { logger } from './logger.js';
+import type { ClaudeModelName, ModelScenario } from '../types/config.js';
+import { VALID_MODEL_ALIASES, FULL_MODEL_ID_PATTERN } from '../types/config.js';
+import { getModel } from './config.js';
 
 export interface ValidationResult {
   valid: boolean;
@@ -88,19 +91,21 @@ export function reportValidation(result: ValidationResult): void {
   }
 }
 
-const VALID_MODELS = ['sonnet', 'haiku', 'opus'] as const;
+/** @deprecated Use ClaudeModelName from types/config.js instead */
+export type ValidModelName = ClaudeModelName;
 
-export type ValidModelName = (typeof VALID_MODELS)[number];
-
-export function validateModelName(model: string): ValidModelName | null {
+export function validateModelName(model: string): ClaudeModelName | null {
   const normalized = model.toLowerCase();
-  if (VALID_MODELS.includes(normalized as ValidModelName)) {
-    return normalized as ValidModelName;
+  if ((VALID_MODEL_ALIASES as readonly string[]).includes(normalized)) {
+    return normalized as ClaudeModelName;
+  }
+  if (FULL_MODEL_ID_PATTERN.test(normalized)) {
+    return normalized as ClaudeModelName;
   }
   return null;
 }
 
-export function resolveModelOption(model?: string, sonnet?: boolean): ValidModelName {
+export function resolveModelOption(model?: string, sonnet?: boolean, scenario: ModelScenario = 'execute'): ClaudeModelName {
   // Check for conflicting flags
   if (model && sonnet) {
     throw new Error('Cannot specify both --model and --sonnet flags');
@@ -115,11 +120,11 @@ export function resolveModelOption(model?: string, sonnet?: boolean): ValidModel
   if (model) {
     const validated = validateModelName(model);
     if (!validated) {
-      throw new Error(`Invalid model name: "${model}". Valid options: ${VALID_MODELS.join(', ')}`);
+      throw new Error(`Invalid model name: "${model}". Valid options: ${VALID_MODEL_ALIASES.join(', ')} or a full model ID (e.g., claude-sonnet-4-5-20250929)`);
     }
     return validated;
   }
 
-  // Default to opus
-  return 'opus';
+  // Default from config
+  return getModel(scenario);
 }

package/src/utils/verbose-toggle.ts

@@ -0,0 +1,103 @@
+/**
+ * Runtime verbose toggle for task execution.
+ *
+ * Listens for Tab keypress on process.stdin to toggle verbose display on/off.
+ * When verbose is on, tool-use activity lines from stream-json are displayed.
+ * When verbose is off, they are suppressed (but data is still captured).
+ *
+ * Requires a TTY stdin. Silently skips setup when stdin is not a TTY (e.g., piped input).
+ */
+
+import { logger } from './logger.js';
+
+export class VerboseToggle {
+  private _verbose: boolean;
+  private _active = false;
+  private _dataHandler: ((data: Buffer) => void) | null = null;
+
+  constructor(initialVerbose: boolean) {
+    this._verbose = initialVerbose;
+  }
+
+  /** Current verbose display state. */
+  get isVerbose(): boolean {
+    return this._verbose;
+  }
+
+  /** Whether the toggle listener is currently active. */
+  get isActive(): boolean {
+    return this._active;
+  }
+
+  /**
+   * Start listening for Tab keypress on stdin.
+   * Sets stdin to raw mode to capture individual keypresses.
+   * Shows a hint message about the toggle.
+   *
+   * No-op if stdin is not a TTY or if already active.
+   */
+  start(): void {
+    if (this._active) return;
+    if (!process.stdin.isTTY) return;
+
+    try {
+      process.stdin.setRawMode(true);
+    } catch {
+      // Cannot set raw mode — skip
+      return;
+    }
+
+    process.stdin.resume();
+
+    this._dataHandler = (data: Buffer) => {
+      for (let i = 0; i < data.length; i++) {
+        const byte = data[i];
+
+        if (byte === 0x09) {
+          // Tab key
+          this._verbose = !this._verbose;
+          const state = this._verbose ? 'on' : 'off';
+          logger.dim(`  [verbose: ${state}]`);
+        } else if (byte === 0x03) {
+          // Ctrl+C — re-emit SIGINT so the shutdown handler catches it
+          process.emit('SIGINT');
+        }
+      }
+    };
+
+    process.stdin.on('data', this._dataHandler);
+    this._active = true;
+
+    // Show toggle hint
+    logger.dim('  Press Tab to toggle verbose mode');
+  }
+
+  /**
+   * Stop listening and restore stdin to normal mode.
+   * Safe to call multiple times.
+   */
+  stop(): void {
+    if (!this._active) return;
+
+    if (this._dataHandler) {
+      process.stdin.off('data', this._dataHandler);
+      this._dataHandler = null;
+    }
+
+    try {
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+    } catch {
+      // Ignore — stdin may already be closed
+    }
+
+    try {
+      process.stdin.pause();
+    } catch {
+      // Ignore
+    }
+
+    this._active = false;
+  }
+}

package/tests/unit/claude-runner.test.ts

@@ -305,8 +305,8 @@ describe('ClaudeRunner', () => {
       const runner = new ClaudeRunner();
       const runPromise = runner.run('test prompt', { timeout: 60 });
 
-      // Emit context overflow message
-      mockProc.stdout.emit('data', Buffer.from('Error: context length exceeded'));
+      // Emit context overflow message (with newline so NDJSON line buffer processes it)
+      mockProc.stdout.emit('data', Buffer.from('Error: context length exceeded\n'));
 
       const result = await runPromise;
       expect(result.contextOverflow).toBe(true);
@@ -333,7 +333,8 @@ describe('ClaudeRunner', () => {
         const runner = new ClaudeRunner();
         const runPromise = runner.run('test prompt', { timeout: 60 });
 
-        mockProc.stdout.emit('data', Buffer.from(`Error: ${pattern}`));
+        // Trailing newline needed for NDJSON line buffer processing
+        mockProc.stdout.emit('data', Buffer.from(`Error: ${pattern}\n`));
 
         const result = await runPromise;
         expect(result.contextOverflow).toBe(true);
@@ -696,7 +697,7 @@ describe('ClaudeRunner', () => {
       expect(spawnArgs).toContain('--verbose');
     });
 
-    it('should NOT include --output-format or --verbose flags in run()', async () => {
+    it('should include --output-format stream-json and --verbose flags in run() (unified stream-json)', async () => {
       const mockProc = createMockProcess();
       mockSpawn.mockReturnValue(mockProc);
 
@@ -707,9 +708,9 @@ describe('ClaudeRunner', () => {
       await runPromise;
 
       const spawnArgs = mockSpawn.mock.calls[0][1] as string[];
-      expect(spawnArgs).not.toContain('--output-format');
-      expect(spawnArgs).not.toContain('stream-json');
-      expect(spawnArgs).not.toContain('--verbose');
+      expect(spawnArgs).toContain('--output-format');
+      expect(spawnArgs).toContain('stream-json');
+      expect(spawnArgs).toContain('--verbose');
     });
 
     it('should extract text from NDJSON assistant events', async () => {
@@ -756,6 +757,169 @@ describe('ClaudeRunner', () => {
     });
   });
 
+  describe('usage data extraction', () => {
+    function createMockProcess() {
+      const stdout = new EventEmitter();
+      const stderr = new EventEmitter();
+      const proc = new EventEmitter() as any;
+      proc.stdout = stdout;
+      proc.stderr = stderr;
+      proc.kill = jest.fn();
+      return proc;
+    }
+
+    it('should return usageData from run() when result event has usage', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', { timeout: 60 });
+
+      const assistantEvent = JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'Done' }] },
+      });
+      const resultEvent = JSON.stringify({
+        type: 'result',
+        usage: { input_tokens: 1000, output_tokens: 500, cache_read_input_tokens: 200, cache_creation_input_tokens: 100 },
+        modelUsage: { 'claude-opus-4-6': { inputTokens: 1000, outputTokens: 500, cacheReadInputTokens: 200, cacheCreationInputTokens: 100 } },
+      });
+
+      mockProc.stdout.emit('data', Buffer.from(assistantEvent + '\n' + resultEvent + '\n'));
+      mockProc.emit('close', 0);
+
+      const result = await runPromise;
+      expect(result.usageData).toBeDefined();
+      expect(result.usageData!.inputTokens).toBe(1000);
+      expect(result.usageData!.outputTokens).toBe(500);
+      expect(result.usageData!.modelUsage['claude-opus-4-6']).toEqual({
+        inputTokens: 1000,
+        outputTokens: 500,
+        cacheReadInputTokens: 200,
+        cacheCreationInputTokens: 100,
+      });
+    });
+
+    it('should return usageData from runVerbose() when result event has usage', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.runVerbose('test prompt', { timeout: 60 });
+
+      const resultEvent = JSON.stringify({
+        type: 'result',
+        usage: { input_tokens: 2000, output_tokens: 800 },
+        modelUsage: { 'claude-sonnet-4-5-20250929': { inputTokens: 2000, outputTokens: 800 } },
+      });
+
+      mockProc.stdout.emit('data', Buffer.from(resultEvent + '\n'));
+      mockProc.emit('close', 0);
+
+      const result = await runPromise;
+      expect(result.usageData).toBeDefined();
+      expect(result.usageData!.inputTokens).toBe(2000);
+      expect(result.usageData!.outputTokens).toBe(800);
+    });
+
+    it('should return undefined usageData when no result event', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', { timeout: 60 });
+
+      const assistantEvent = JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'Output' }] },
+      });
+
+      mockProc.stdout.emit('data', Buffer.from(assistantEvent + '\n'));
+      mockProc.emit('close', 0);
+
+      const result = await runPromise;
+      expect(result.usageData).toBeUndefined();
+    });
+
+    it('should suppress display in run() but still capture usage data', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      // Spy on stdout.write to verify no display output in non-verbose mode
+      const writeSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', { timeout: 60 });
+
+      const toolEvent = JSON.stringify({
+        type: 'assistant',
+        message: { content: [
+          { type: 'text', text: 'Working...' },
+          { type: 'tool_use', name: 'Read', input: { file_path: '/test.ts' } },
+        ] },
+      });
+      const resultEvent = JSON.stringify({
+        type: 'result',
+        usage: { input_tokens: 100, output_tokens: 50 },
+      });
+
+      mockProc.stdout.emit('data', Buffer.from(toolEvent + '\n' + resultEvent + '\n'));
+      mockProc.emit('close', 0);
+
+      const result = await runPromise;
+
+      // No display output (run() is non-verbose)
+      expect(writeSpy).not.toHaveBeenCalled();
+
+      // But usage data is still captured
+      expect(result.usageData).toBeDefined();
+      expect(result.usageData!.inputTokens).toBe(100);
+
+      // And text content is captured
+      expect(result.output).toContain('Working...');
+
+      writeSpy.mockRestore();
+    });
+
+    it('should use verboseCheck callback to dynamically control display', async () => {
+      const mockProc = createMockProcess();
+      mockSpawn.mockReturnValue(mockProc);
+
+      const writeSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+
+      let dynamicVerbose = false;
+      const runner = new ClaudeRunner();
+      const runPromise = runner.run('test prompt', {
+        timeout: 60,
+        verboseCheck: () => dynamicVerbose,
+      });
+
+      // First event with verbose OFF — should not display
+      const event1 = JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'tool_use', name: 'Read', input: { file_path: '/a.ts' } }] },
+      });
+      mockProc.stdout.emit('data', Buffer.from(event1 + '\n'));
+      expect(writeSpy).not.toHaveBeenCalled();
+
+      // Toggle verbose ON
+      dynamicVerbose = true;
+
+      // Second event with verbose ON — should display
+      const event2 = JSON.stringify({
+        type: 'assistant',
+        message: { content: [{ type: 'tool_use', name: 'Read', input: { file_path: '/b.ts' } }] },
+      });
+      mockProc.stdout.emit('data', Buffer.from(event2 + '\n'));
+      expect(writeSpy).toHaveBeenCalled();
+
+      mockProc.emit('close', 0);
+      await runPromise;
+
+      writeSpy.mockRestore();
+    });
+  });
+
   describe('retry isolation (timeout per attempt)', () => {
     function createMockProcess() {
       const stdout = new EventEmitter();

package/tests/unit/config-command.test.ts

@@ -0,0 +1,163 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { Command } from 'commander';
+import { createConfigCommand } from '../../src/commands/config.js';
+import { validateConfig, ConfigValidationError } from '../../src/utils/config.js';
+
+describe('Config Command', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-config-cmd-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('Command setup', () => {
+    it('should create a command named "config"', () => {
+      const cmd = createConfigCommand();
+      expect(cmd.name()).toBe('config');
+    });
+
+    it('should have a description', () => {
+      const cmd = createConfigCommand();
+      expect(cmd.description()).toBeTruthy();
+      expect(cmd.description()).toContain('config');
+    });
+
+    it('should accept a variadic prompt argument', () => {
+      const cmd = createConfigCommand();
+      const args = cmd.registeredArguments;
+      expect(args.length).toBe(1);
+      expect(args[0]!.variadic).toBe(true);
+    });
+
+    it('should have a --reset option', () => {
+      const cmd = createConfigCommand();
+      const resetOption = cmd.options.find((o) => o.long === '--reset');
+      expect(resetOption).toBeDefined();
+    });
+
+    it('should register in a parent program', () => {
+      const program = new Command();
+      program.addCommand(createConfigCommand());
+      const configCmd = program.commands.find((c) => c.name() === 'config');
+      expect(configCmd).toBeDefined();
+    });
+  });
+
+  describe('Post-session validation logic', () => {
+    it('should accept valid config with model override', () => {
+      const config = { models: { execute: 'sonnet' } };
+      expect(() => validateConfig(config)).not.toThrow();
+    });
+
+    it('should accept valid config with effort override', () => {
+      const config = { effort: { plan: 'low' } };
+      expect(() => validateConfig(config)).not.toThrow();
+    });
+
+    it('should accept valid config with timeout', () => {
+      const config = { timeout: 120 };
+      expect(() => validateConfig(config)).not.toThrow();
+    });
+
+    it('should reject config with unknown keys', () => {
+      const config = { unknownKey: true };
+      expect(() => validateConfig(config)).toThrow(ConfigValidationError);
+    });
+
+    it('should reject config with invalid model name', () => {
+      const config = { models: { execute: 'gpt-4' } };
+      expect(() => validateConfig(config)).toThrow(ConfigValidationError);
+    });
+
+    it('should reject config with invalid effort level', () => {
+      const config = { effort: { plan: 'max' } };
+      expect(() => validateConfig(config)).toThrow(ConfigValidationError);
+    });
+
+    it('should reject non-object config', () => {
+      expect(() => validateConfig('string')).toThrow(ConfigValidationError);
+      expect(() => validateConfig(null)).toThrow(ConfigValidationError);
+      expect(() => validateConfig([])).toThrow(ConfigValidationError);
+    });
+
+    it('should accept an empty config (all defaults)', () => {
+      expect(() => validateConfig({})).not.toThrow();
+    });
+  });
+
+  describe('Reset flow - file operations', () => {
+    it('should be able to delete config file', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+      fs.writeFileSync(configPath, JSON.stringify({ timeout: 90 }, null, 2));
+      expect(fs.existsSync(configPath)).toBe(true);
+
+      fs.unlinkSync(configPath);
+      expect(fs.existsSync(configPath)).toBe(false);
+    });
+
+    it('should handle non-existent config file gracefully', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+      expect(fs.existsSync(configPath)).toBe(false);
+      // Reset when no file exists should not throw
+    });
+  });
+
+  describe('Config file round-trip', () => {
+    it('should write and read valid config', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+      const config = { models: { execute: 'sonnet' as const }, timeout: 90 };
+
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+      const content = fs.readFileSync(configPath, 'utf-8');
+      const parsed = JSON.parse(content);
+
+      expect(parsed.models.execute).toBe('sonnet');
+      expect(parsed.timeout).toBe(90);
+      expect(() => validateConfig(parsed)).not.toThrow();
+    });
+
+    it('should detect invalid JSON after write', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+      fs.writeFileSync(configPath, '{ invalid json }}}');
+
+      const content = fs.readFileSync(configPath, 'utf-8');
+      expect(() => JSON.parse(content)).toThrow(SyntaxError);
+    });
+
+    it('should detect validation errors after write', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+      fs.writeFileSync(configPath, JSON.stringify({ badKey: true }, null, 2));
+
+      const content = fs.readFileSync(configPath, 'utf-8');
+      const parsed = JSON.parse(content);
+      expect(() => validateConfig(parsed)).toThrow(ConfigValidationError);
+    });
+  });
+
+  describe('System prompt construction', () => {
+    it('should indicate no config when file does not exist', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+      const exists = fs.existsSync(configPath);
+      const state = exists
+        ? fs.readFileSync(configPath, 'utf-8')
+        : 'No config file exists yet.';
+      expect(state).toContain('No config file');
+    });
+
+    it('should include config contents when file exists', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+      const config = { timeout: 120, worktree: true };
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+      const content = fs.readFileSync(configPath, 'utf-8');
+      expect(content).toContain('"timeout": 120');
+      expect(content).toContain('"worktree": true');
+    });
+  });
+});