rafcode 2.2.0 → 2.4.0

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

@@ -3,17 +3,26 @@ 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';
+import {
+  validateConfig,
+  ConfigValidationError,
+  resolveConfig,
+  getModel,
+  resetConfigCache,
+} from '../../src/utils/config.js';
+import { DEFAULT_CONFIG } from '../../src/types/config.js';
 
 describe('Config Command', () => {
   let tempDir: string;
 
   beforeEach(() => {
     tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-config-cmd-test-'));
+    resetConfigCache();
   });
 
   afterEach(() => {
     fs.rmSync(tempDir, { recursive: true, force: true });
+    resetConfigCache();
   });
 
   describe('Command setup', () => {
@@ -55,8 +64,8 @@ describe('Config Command', () => {
       expect(() => validateConfig(config)).not.toThrow();
     });
 
-    it('should accept valid config with effort override', () => {
-      const config = { effort: { plan: 'low' } };
+    it('should accept valid config with effortMapping override', () => {
+      const config = { effortMapping: { low: 'haiku', medium: 'sonnet' } };
       expect(() => validateConfig(config)).not.toThrow();
     });
 
@@ -75,8 +84,8 @@ describe('Config Command', () => {
       expect(() => validateConfig(config)).toThrow(ConfigValidationError);
     });
 
-    it('should reject config with invalid effort level', () => {
-      const config = { effort: { plan: 'max' } };
+    it('should reject config with invalid effortMapping model', () => {
+      const config = { effortMapping: { low: 'gpt-4' } };
       expect(() => validateConfig(config)).toThrow(ConfigValidationError);
     });
 
@@ -160,4 +169,74 @@ describe('Config Command', () => {
       expect(content).toContain('"worktree": true');
     });
   });
+
+  describe('Error recovery - invalid config fallback', () => {
+    // These tests verify the behaviors that runConfigSession relies on for error recovery
+    // The config command catches errors from getModel/getEffort and falls back to defaults
+
+    it('should throw on invalid JSON when resolving config', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+      fs.writeFileSync(configPath, '{ invalid json }}}');
+
+      expect(() => resolveConfig(configPath)).toThrow(SyntaxError);
+    });
+
+    it('should throw on schema validation failure when resolving config', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+      fs.writeFileSync(configPath, JSON.stringify({ unknownKey: true }));
+
+      expect(() => resolveConfig(configPath)).toThrow(ConfigValidationError);
+    });
+
+    it('should have valid default fallback values for config scenario', () => {
+      // These are the values that runConfigSession uses when config loading fails
+      expect(DEFAULT_CONFIG.models.config).toBe('sonnet');
+      // effortMapping defaults used for per-task model resolution
+      expect(DEFAULT_CONFIG.effortMapping.medium).toBe('sonnet');
+    });
+
+    it('should be able to read raw file contents even when config is invalid JSON', () => {
+      // This verifies that getCurrentConfigState can still read the broken file
+      // so Claude can see and help fix it
+      const configPath = path.join(tempDir, 'raf.config.json');
+      const invalidContent = '{ "broken": true, }'; // trailing comma = invalid
+      fs.writeFileSync(configPath, invalidContent);
+
+      // File is readable even though it's invalid JSON
+      const content = fs.readFileSync(configPath, 'utf-8');
+      expect(content).toBe(invalidContent);
+    });
+
+    it('should be able to read raw file contents even when config fails schema validation', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+      const invalidContent = JSON.stringify({ badKey: 'value' }, null, 2);
+      fs.writeFileSync(configPath, invalidContent);
+
+      // File is readable even though it fails validation
+      const content = fs.readFileSync(configPath, 'utf-8');
+      expect(JSON.parse(content)).toEqual({ badKey: 'value' });
+    });
+
+    it('resetConfigCache should clear the cached config', () => {
+      // This is used by runConfigSession to clear a broken cached config
+      // so subsequent operations don't fail
+      const configPath = path.join(tempDir, 'valid.json');
+      fs.writeFileSync(configPath, JSON.stringify({ timeout: 99 }));
+
+      // Load the config
+      const config1 = resolveConfig(configPath);
+      expect(config1.timeout).toBe(99);
+
+      // Write different content
+      fs.writeFileSync(configPath, JSON.stringify({ timeout: 120 }));
+
+      // Without reset, we'd still get cached value (but resolveConfig doesn't use cache)
+      // This test verifies resetConfigCache exists and can be called
+      resetConfigCache();
+
+      // After reset, we should get new value
+      const config2 = resolveConfig(configPath);
+      expect(config2.timeout).toBe(120);
+    });
+  });
 });

package/tests/unit/config.test.ts

@@ -8,14 +8,19 @@ import {
   ConfigValidationError,
   resolveConfig,
   getModel,
-  getEffort,
+  getEffortMapping,
+  resolveEffortToModel,
+  getModelTier,
+  applyModelCeiling,
   getCommitFormat,
   getCommitPrefix,
   getTimeout,
   getMaxRetries,
   getAutoCommit,
   getWorktreeDefault,
-  getClaudeCommand,
+  getSyncMainBranch,
+  getModelShortName,
+  resolveFullModelId,
   resetConfigCache,
   saveConfig,
   renderCommitMessage,
@@ -89,13 +94,12 @@ describe('Config', () => {
     it('should accept a full valid config', () => {
       const config = {
         models: { plan: 'opus', execute: 'haiku' },
-        effort: { plan: 'high', execute: 'low' },
+        effortMapping: { low: 'haiku', medium: 'sonnet', high: 'opus' },
         timeout: 30,
         maxRetries: 5,
         autoCommit: false,
         worktree: true,
         commitFormat: { prefix: 'MY', task: '{prefix}[{projectId}] {description}' },
-        claudeCommand: '/usr/local/bin/claude',
       };
       expect(() => validateConfig(config)).not.toThrow();
     });
@@ -112,12 +116,16 @@ describe('Config', () => {
       expect(() => validateConfig({ unknownKey: 'value' })).toThrow('Unknown config key: unknownKey');
     });
 
+    it('should reject removed claudeCommand key', () => {
+      expect(() => validateConfig({ claudeCommand: 'claude' })).toThrow('Unknown config key: claudeCommand');
+    });
+
     it('should reject unknown model keys', () => {
       expect(() => validateConfig({ models: { unknownScenario: 'opus' } })).toThrow('Unknown config key: models.unknownScenario');
     });
 
-    it('should reject unknown effort keys', () => {
-      expect(() => validateConfig({ effort: { unknownScenario: 'high' } })).toThrow('Unknown config key: effort.unknownScenario');
+    it('should reject unknown effortMapping keys', () => {
+      expect(() => validateConfig({ effortMapping: { unknownLevel: 'haiku' } })).toThrow('Unknown config key: effortMapping.unknownLevel');
     });
 
     it('should reject unknown commitFormat keys', () => {
@@ -150,9 +158,9 @@ describe('Config', () => {
       expect(() => validateConfig({ models: { plan: 123 } })).toThrow('models.plan must be');
     });
 
-    // Invalid effort values
-    it('should reject invalid effort levels', () => {
-      expect(() => validateConfig({ effort: { plan: 'ultra' } })).toThrow('effort.plan must be one of');
+    // Invalid effortMapping values
+    it('should reject invalid effortMapping model names', () => {
+      expect(() => validateConfig({ effortMapping: { low: 'invalid-model' } })).toThrow('effortMapping.low must be a short alias');
     });
 
     // Invalid types for nested objects
@@ -164,8 +172,8 @@ describe('Config', () => {
       expect(() => validateConfig({ models: ['opus'] })).toThrow('models must be an object');
     });
 
-    it('should reject non-object effort', () => {
-      expect(() => validateConfig({ effort: 'high' })).toThrow('effort must be an object');
+    it('should reject non-object effortMapping', () => {
+      expect(() => validateConfig({ effortMapping: 'high' })).toThrow('effortMapping must be an object');
     });
 
     it('should reject non-object commitFormat', () => {
@@ -207,17 +215,13 @@ describe('Config', () => {
       expect(() => validateConfig({ worktree: 1 })).toThrow('worktree must be a boolean');
     });
 
-    // Invalid claudeCommand
-    it('should reject empty claudeCommand', () => {
-      expect(() => validateConfig({ claudeCommand: '' })).toThrow('claudeCommand must be a non-empty string');
-    });
-
-    it('should reject whitespace-only claudeCommand', () => {
-      expect(() => validateConfig({ claudeCommand: '   ' })).toThrow('claudeCommand must be a non-empty string');
+    it('should reject non-boolean syncMainBranch', () => {
+      expect(() => validateConfig({ syncMainBranch: 'yes' })).toThrow('syncMainBranch must be a boolean');
     });
 
-    it('should reject non-string claudeCommand', () => {
-      expect(() => validateConfig({ claudeCommand: 123 })).toThrow('claudeCommand must be a non-empty string');
+    it('should accept boolean syncMainBranch', () => {
+      expect(() => validateConfig({ syncMainBranch: true })).not.toThrow();
+      expect(() => validateConfig({ syncMainBranch: false })).not.toThrow();
     });
 
     // Non-string commitFormat values
@@ -267,13 +271,14 @@ describe('Config', () => {
       expect(config.models.failureAnalysis).toBe('haiku'); // default preserved
     });
 
-    it('should deep-merge partial effort override', () => {
+    it('should deep-merge partial effortMapping override', () => {
       const configPath = path.join(tempDir, 'raf.config.json');
-      fs.writeFileSync(configPath, JSON.stringify({ effort: { execute: 'high' } }));
+      fs.writeFileSync(configPath, JSON.stringify({ effortMapping: { medium: 'opus' } }));
 
       const config = resolveConfig(configPath);
-      expect(config.effort.execute).toBe('high');
-      expect(config.effort.plan).toBe('high'); // default preserved
+      expect(config.effortMapping.medium).toBe('opus');
+      expect(config.effortMapping.low).toBe('haiku'); // default preserved
+      expect(config.effortMapping.high).toBe('opus'); // default preserved
     });
 
     it('should deep-merge partial commitFormat override', () => {
@@ -296,6 +301,19 @@ describe('Config', () => {
       expect(config.maxRetries).toBe(3); // default preserved
     });
 
+    it('should override syncMainBranch', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+      fs.writeFileSync(configPath, JSON.stringify({ syncMainBranch: false }));
+
+      const config = resolveConfig(configPath);
+      expect(config.syncMainBranch).toBe(false);
+    });
+
+    it('should default syncMainBranch to true', () => {
+      const config = resolveConfig(path.join(tempDir, 'nonexistent.json'));
+      expect(config.syncMainBranch).toBe(true);
+    });
+
     it('should throw on invalid config file', () => {
       const configPath = path.join(tempDir, 'raf.config.json');
       fs.writeFileSync(configPath, JSON.stringify({ unknownKey: true }));
@@ -348,11 +366,12 @@ describe('Config', () => {
       expect(config.models.execute).toBe('opus');
     });
 
-    it('getEffort returns correct effort for scenario', () => {
+    it('effortMapping resolves correctly from config', () => {
       const configPath = path.join(tempDir, 'raf.config.json');
-      fs.writeFileSync(configPath, JSON.stringify({ effort: { plan: 'low' } }));
+      fs.writeFileSync(configPath, JSON.stringify({ effortMapping: { high: 'sonnet' } }));
       const config = resolveConfig(configPath);
-      expect(config.effort.plan).toBe('low');
+      expect(config.effortMapping.high).toBe('sonnet');
+      expect(config.effortMapping.low).toBe('haiku'); // default preserved
     });
 
     it('getCommitFormat returns correct format', () => {
@@ -371,7 +390,6 @@ describe('Config', () => {
       expect(config.maxRetries).toBe(3);
       expect(config.autoCommit).toBe(true);
       expect(config.worktree).toBe(false);
-      expect(config.claudeCommand).toBe('claude');
     });
   });
 
@@ -385,13 +403,10 @@ describe('Config', () => {
       expect(DEFAULT_CONFIG.models.config).toBe('sonnet');
     });
 
-    it('should have all effort scenarios defined', () => {
-      expect(DEFAULT_CONFIG.effort.plan).toBe('high');
-      expect(DEFAULT_CONFIG.effort.execute).toBe('medium');
-      expect(DEFAULT_CONFIG.effort.nameGeneration).toBe('low');
-      expect(DEFAULT_CONFIG.effort.failureAnalysis).toBe('low');
-      expect(DEFAULT_CONFIG.effort.prGeneration).toBe('medium');
-      expect(DEFAULT_CONFIG.effort.config).toBe('medium');
+    it('should have all effortMapping levels defined', () => {
+      expect(DEFAULT_CONFIG.effortMapping.low).toBe('haiku');
+      expect(DEFAULT_CONFIG.effortMapping.medium).toBe('sonnet');
+      expect(DEFAULT_CONFIG.effortMapping.high).toBe('opus');
     });
 
     it('should have all commit format fields defined', () => {
@@ -471,8 +486,10 @@ describe('Config', () => {
       expect(DEFAULT_CONFIG.models.prGeneration).toBe('sonnet');
     });
 
-    it('should default effort to match previous hardcoded values', () => {
-      expect(DEFAULT_CONFIG.effort.execute).toBe('medium');
+    it('should default effortMapping to haiku/sonnet/opus', () => {
+      expect(DEFAULT_CONFIG.effortMapping.low).toBe('haiku');
+      expect(DEFAULT_CONFIG.effortMapping.medium).toBe('sonnet');
+      expect(DEFAULT_CONFIG.effortMapping.high).toBe('opus');
     });
 
     it('should default timeout to 60', () => {
@@ -491,10 +508,6 @@ describe('Config', () => {
       expect(DEFAULT_CONFIG.worktree).toBe(false);
     });
 
-    it('should default claudeCommand to claude', () => {
-      expect(DEFAULT_CONFIG.claudeCommand).toBe('claude');
-    });
-
     it('should default commit format to match previous hardcoded format', () => {
       // The task format should produce the same output as the old hardcoded format
       const result = renderCommitMessage(DEFAULT_CONFIG.commitFormat.task, {
@@ -616,6 +629,49 @@ describe('Config', () => {
     });
   });
 
+  describe('getModelShortName', () => {
+    it('should return short aliases as-is', () => {
+      expect(getModelShortName('opus')).toBe('opus');
+      expect(getModelShortName('sonnet')).toBe('sonnet');
+      expect(getModelShortName('haiku')).toBe('haiku');
+    });
+
+    it('should extract family from full model IDs', () => {
+      expect(getModelShortName('claude-opus-4-6')).toBe('opus');
+      expect(getModelShortName('claude-opus-4-5-20251101')).toBe('opus');
+      expect(getModelShortName('claude-sonnet-4-5-20250929')).toBe('sonnet');
+      expect(getModelShortName('claude-sonnet-4-5')).toBe('sonnet');
+      expect(getModelShortName('claude-haiku-4-5-20251001')).toBe('haiku');
+    });
+
+    it('should return unknown model IDs as-is', () => {
+      expect(getModelShortName('gpt-4')).toBe('gpt-4');
+      expect(getModelShortName('claude-unknown-3-0')).toBe('claude-unknown-3-0');
+      expect(getModelShortName('')).toBe('');
+      expect(getModelShortName('some-random-model')).toBe('some-random-model');
+    });
+  });
+
+  describe('resolveFullModelId', () => {
+    it('should resolve short aliases to full model IDs', () => {
+      expect(resolveFullModelId('opus')).toBe('claude-opus-4-6');
+      expect(resolveFullModelId('sonnet')).toBe('claude-sonnet-4-5-20250929');
+      expect(resolveFullModelId('haiku')).toBe('claude-haiku-4-5-20251001');
+    });
+
+    it('should return full model IDs as-is', () => {
+      expect(resolveFullModelId('claude-opus-4-6')).toBe('claude-opus-4-6');
+      expect(resolveFullModelId('claude-sonnet-4-5-20250929')).toBe('claude-sonnet-4-5-20250929');
+      expect(resolveFullModelId('claude-haiku-4-5-20251001')).toBe('claude-haiku-4-5-20251001');
+    });
+
+    it('should return unknown model strings as-is', () => {
+      expect(resolveFullModelId('gpt-4')).toBe('gpt-4');
+      expect(resolveFullModelId('claude-unknown-3-0')).toBe('claude-unknown-3-0');
+      expect(resolveFullModelId('')).toBe('');
+    });
+  });
+
   describe('config integration - overrides work', () => {
     it('should use custom model when configured', () => {
       const configPath = path.join(tempDir, 'custom-models.json');
@@ -628,13 +684,14 @@ describe('Config', () => {
       expect(config.models.failureAnalysis).toBe('haiku');
     });
 
-    it('should use custom effort when configured', () => {
+    it('should use custom effortMapping when configured', () => {
       const configPath = path.join(tempDir, 'custom-effort.json');
-      saveConfig(configPath, { effort: { execute: 'high' } });
+      saveConfig(configPath, { effortMapping: { high: 'sonnet' } });
       const config = resolveConfig(configPath);
-      expect(config.effort.execute).toBe('high');
+      expect(config.effortMapping.high).toBe('sonnet');
       // Others should remain at defaults
-      expect(config.effort.plan).toBe('high');
+      expect(config.effortMapping.low).toBe('haiku');
+      expect(config.effortMapping.medium).toBe('sonnet');
     });
 
     it('should use custom commit format when configured', () => {
@@ -647,4 +704,194 @@ describe('Config', () => {
       expect(config.commitFormat.plan).toBe(DEFAULT_CONFIG.commitFormat.plan);
     });
   });
+
+  describe('validateConfig - display', () => {
+    it('should accept valid display config', () => {
+      expect(() => validateConfig({
+        display: {
+          showRateLimitEstimate: true,
+          showCacheTokens: false,
+        },
+      })).not.toThrow();
+    });
+
+    it('should accept partial display override', () => {
+      expect(() => validateConfig({
+        display: { showRateLimitEstimate: false },
+      })).not.toThrow();
+    });
+
+    it('should reject non-object display', () => {
+      expect(() => validateConfig({ display: 'full' })).toThrow('display must be an object');
+    });
+
+    it('should reject unknown display keys', () => {
+      expect(() => validateConfig({ display: { unknownKey: true } })).toThrow('Unknown config key: display.unknownKey');
+    });
+
+    it('should reject non-boolean display values', () => {
+      expect(() => validateConfig({ display: { showRateLimitEstimate: 'yes' } })).toThrow('display.showRateLimitEstimate must be a boolean');
+    });
+  });
+
+  describe('validateConfig - rateLimitWindow', () => {
+    it('should accept valid rateLimitWindow config', () => {
+      expect(() => validateConfig({
+        rateLimitWindow: { sonnetTokenCap: 100000 },
+      })).not.toThrow();
+    });
+
+    it('should reject non-object rateLimitWindow', () => {
+      expect(() => validateConfig({ rateLimitWindow: 88000 })).toThrow('rateLimitWindow must be an object');
+    });
+
+    it('should reject unknown rateLimitWindow keys', () => {
+      expect(() => validateConfig({ rateLimitWindow: { unknownKey: 50000 } })).toThrow('Unknown config key: rateLimitWindow.unknownKey');
+    });
+
+    it('should reject non-positive sonnetTokenCap', () => {
+      expect(() => validateConfig({ rateLimitWindow: { sonnetTokenCap: 0 } })).toThrow('rateLimitWindow.sonnetTokenCap must be a positive number');
+      expect(() => validateConfig({ rateLimitWindow: { sonnetTokenCap: -100 } })).toThrow('rateLimitWindow.sonnetTokenCap must be a positive number');
+    });
+
+    it('should reject non-number sonnetTokenCap', () => {
+      expect(() => validateConfig({ rateLimitWindow: { sonnetTokenCap: '88000' } })).toThrow('rateLimitWindow.sonnetTokenCap must be a positive number');
+    });
+  });
+
+  describe('resolveConfig - display and rateLimitWindow', () => {
+    it('should include default display when no config file', () => {
+      const config = resolveConfig(path.join(tempDir, 'nonexistent.json'));
+      expect(config.display.showRateLimitEstimate).toBe(true);
+      expect(config.display.showCacheTokens).toBe(true);
+    });
+
+    it('should include default rateLimitWindow when no config file', () => {
+      const config = resolveConfig(path.join(tempDir, 'nonexistent.json'));
+      expect(config.rateLimitWindow.sonnetTokenCap).toBe(88000);
+    });
+
+    it('should deep-merge partial display override', () => {
+      const configPath = path.join(tempDir, 'display.json');
+      fs.writeFileSync(configPath, JSON.stringify({
+        display: { showRateLimitEstimate: false },
+      }));
+
+      const config = resolveConfig(configPath);
+      expect(config.display.showRateLimitEstimate).toBe(false);
+      expect(config.display.showCacheTokens).toBe(true); // default preserved
+    });
+
+    it('should deep-merge partial rateLimitWindow override', () => {
+      const configPath = path.join(tempDir, 'rateLimit.json');
+      fs.writeFileSync(configPath, JSON.stringify({
+        rateLimitWindow: { sonnetTokenCap: 100000 },
+      }));
+
+      const config = resolveConfig(configPath);
+      expect(config.rateLimitWindow.sonnetTokenCap).toBe(100000);
+    });
+  });
+
+  describe('DEFAULT_CONFIG - display and rateLimitWindow', () => {
+    it('should have default display settings', () => {
+      expect(DEFAULT_CONFIG.display.showRateLimitEstimate).toBe(true);
+      expect(DEFAULT_CONFIG.display.showCacheTokens).toBe(true);
+    });
+
+    it('should have default rateLimitWindow settings', () => {
+      expect(DEFAULT_CONFIG.rateLimitWindow.sonnetTokenCap).toBe(88000);
+    });
+  });
+
+  describe('getModelTier', () => {
+    it('should return correct tier for short aliases', () => {
+      expect(getModelTier('haiku')).toBe(1);
+      expect(getModelTier('sonnet')).toBe(2);
+      expect(getModelTier('opus')).toBe(3);
+    });
+
+    it('should extract tier from full model IDs', () => {
+      expect(getModelTier('claude-haiku-4-5-20251001')).toBe(1);
+      expect(getModelTier('claude-sonnet-4-5-20250929')).toBe(2);
+      expect(getModelTier('claude-opus-4-6')).toBe(3);
+    });
+
+    it('should return highest tier for unknown models', () => {
+      expect(getModelTier('unknown-model')).toBe(3);
+      expect(getModelTier('claude-future-5-0')).toBe(3);
+      expect(getModelTier('')).toBe(3);
+    });
+  });
+
+  describe('applyModelCeiling', () => {
+    it('should return resolved model when below ceiling', () => {
+      expect(applyModelCeiling('haiku', 'sonnet')).toBe('haiku');
+      expect(applyModelCeiling('haiku', 'opus')).toBe('haiku');
+      expect(applyModelCeiling('sonnet', 'opus')).toBe('sonnet');
+    });
+
+    it('should return ceiling model when above ceiling', () => {
+      expect(applyModelCeiling('opus', 'sonnet')).toBe('sonnet');
+      expect(applyModelCeiling('opus', 'haiku')).toBe('haiku');
+      expect(applyModelCeiling('sonnet', 'haiku')).toBe('haiku');
+    });
+
+    it('should return resolved model when at ceiling', () => {
+      expect(applyModelCeiling('sonnet', 'sonnet')).toBe('sonnet');
+      expect(applyModelCeiling('opus', 'opus')).toBe('opus');
+    });
+
+    it('should work with full model IDs', () => {
+      expect(applyModelCeiling('claude-opus-4-6', 'sonnet')).toBe('sonnet');
+      expect(applyModelCeiling('claude-haiku-4-5-20251001', 'claude-opus-4-6')).toBe('claude-haiku-4-5-20251001');
+    });
+  });
+
+  describe('resolveEffortToModel', () => {
+    it('should resolve effort levels to default models', () => {
+      const configPath = path.join(tempDir, 'default.json');
+      // Use default config
+      const config = resolveConfig(path.join(tempDir, 'nonexistent.json'));
+      expect(config.effortMapping.low).toBe('haiku');
+      expect(config.effortMapping.medium).toBe('sonnet');
+      expect(config.effortMapping.high).toBe('opus');
+    });
+  });
+
+  describe('validateConfig - effortMapping', () => {
+    it('should accept valid effortMapping config', () => {
+      expect(() => validateConfig({
+        effortMapping: {
+          low: 'haiku',
+          medium: 'sonnet',
+          high: 'opus',
+        },
+      })).not.toThrow();
+    });
+
+    it('should accept partial effortMapping override', () => {
+      expect(() => validateConfig({
+        effortMapping: { high: 'sonnet' },
+      })).not.toThrow();
+    });
+
+    it('should accept full model IDs in effortMapping', () => {
+      expect(() => validateConfig({
+        effortMapping: { low: 'claude-haiku-4-5-20251001' },
+      })).not.toThrow();
+    });
+
+    it('should reject invalid model names in effortMapping', () => {
+      expect(() => validateConfig({
+        effortMapping: { low: 'gpt-4' },
+      })).toThrow('effortMapping.low must be a short alias');
+    });
+
+    it('should reject unknown keys in effortMapping', () => {
+      expect(() => validateConfig({
+        effortMapping: { extra: 'haiku' },
+      })).toThrow('Unknown config key: effortMapping.extra');
+    });
+  });
 });