rafcode 2.3.0 → 2.4.0

package/tests/unit/config.test.ts

@@ -8,15 +8,19 @@ import {
   ConfigValidationError,
   resolveConfig,
   getModel,
-  getEffort,
+  getEffortMapping,
+  resolveEffortToModel,
+  getModelTier,
+  applyModelCeiling,
   getCommitFormat,
   getCommitPrefix,
   getTimeout,
   getMaxRetries,
   getAutoCommit,
   getWorktreeDefault,
-  getClaudeCommand,
+  getSyncMainBranch,
   getModelShortName,
+  resolveFullModelId,
   resetConfigCache,
   saveConfig,
   renderCommitMessage,
@@ -90,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();
     });
@@ -113,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', () => {
@@ -151,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
@@ -165,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', () => {
@@ -208,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
@@ -268,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', () => {
@@ -297,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 }));
@@ -349,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', () => {
@@ -372,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');
     });
   });
 
@@ -386,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', () => {
@@ -472,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', () => {
@@ -492,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, {
@@ -640,6 +652,26 @@ describe('Config', () => {
     });
   });
 
+  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');
@@ -652,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', () => {
@@ -671,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');
+    });
+  });
 });

package/tests/unit/frontmatter.test.ts

@@ -0,0 +1,182 @@
+import { parsePlanFrontmatter } from '../../src/utils/frontmatter.js';
+
+describe('parsePlanFrontmatter', () => {
+  describe('valid frontmatter', () => {
+    it('should parse effort field', () => {
+      const content = `effort: medium
+---
+# Task: Test Task`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.effort).toBe('medium');
+      expect(result.warnings).toHaveLength(0);
+    });
+
+    it('should parse model field', () => {
+      const content = `model: sonnet
+---
+# Task: Test Task`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.model).toBe('sonnet');
+      expect(result.warnings).toHaveLength(0);
+    });
+
+    it('should parse both effort and model', () => {
+      const content = `effort: high
+model: opus
+---
+# Task: Test Task`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.effort).toBe('high');
+      expect(result.frontmatter.model).toBe('opus');
+    });
+
+    it('should accept all effort levels', () => {
+      for (const level of ['low', 'medium', 'high']) {
+        const content = `effort: ${level}
+---
+# Task: Test`;
+        const result = parsePlanFrontmatter(content);
+        expect(result.hasFrontmatter).toBe(true);
+        expect(result.frontmatter.effort).toBe(level);
+      }
+    });
+
+    it('should accept full model IDs', () => {
+      const content = `model: claude-opus-4-6
+---
+# Task: Test`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.model).toBe('claude-opus-4-6');
+    });
+
+    it('should be case-insensitive for effort values', () => {
+      const content = `effort: MEDIUM
+---
+# Task: Test`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.effort).toBe('medium');
+    });
+
+    it('should handle empty lines in frontmatter', () => {
+      const content = `effort: low
+
+model: haiku
+---
+# Task: Test`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.effort).toBe('low');
+      expect(result.frontmatter.model).toBe('haiku');
+    });
+  });
+
+  describe('no frontmatter', () => {
+    it('should return empty for content without delimiter', () => {
+      const content = `# Task: Test Task
+
+## Objective
+Do something`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(false);
+      expect(result.frontmatter.effort).toBeUndefined();
+      expect(result.frontmatter.model).toBeUndefined();
+    });
+
+    it('should return empty for empty content', () => {
+      const result = parsePlanFrontmatter('');
+      expect(result.hasFrontmatter).toBe(false);
+    });
+
+    it('should return empty when markdown heading appears before delimiter', () => {
+      const content = `# Task: Test Task
+---
+More content`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(false);
+      expect(result.warnings).toContain('Frontmatter section contains markdown content before closing delimiter');
+    });
+  });
+
+  describe('warnings', () => {
+    it('should warn on unknown frontmatter keys', () => {
+      const content = `effort: medium
+unknownKey: value
+---
+# Task: Test`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.warnings).toContain('Unknown frontmatter key: "unknownkey"');
+    });
+
+    it('should warn on invalid effort value', () => {
+      const content = `effort: invalid
+---
+# Task: Test`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(false); // No valid frontmatter extracted
+      expect(result.warnings.some(w => w.includes('Invalid effort value'))).toBe(true);
+    });
+
+    it('should warn on invalid model value', () => {
+      const content = `model: gpt-4
+---
+# Task: Test`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(false);
+      expect(result.warnings.some(w => w.includes('Invalid model value'))).toBe(true);
+    });
+
+    it('should collect multiple warnings', () => {
+      const content = `effort: invalid
+model: gpt-4
+unknownKey: value
+---
+# Task: Test`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.warnings.length).toBeGreaterThanOrEqual(3);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle delimiter with content after it', () => {
+      const content = `effort: medium
+---
+# Task: Test
+
+## Objective
+Do something
+
+---
+
+More content with another delimiter`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.effort).toBe('medium');
+    });
+
+    it('should handle whitespace around values', () => {
+      const content = `effort:   high
+model:  sonnet
+---
+# Task: Test`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.effort).toBe('high');
+      expect(result.frontmatter.model).toBe('sonnet');
+    });
+
+    it('should handle tabs in whitespace', () => {
+      const content = `effort:\thigh
+---
+# Task: Test`;
+      const result = parsePlanFrontmatter(content);
+      expect(result.hasFrontmatter).toBe(true);
+      expect(result.frontmatter.effort).toBe('high');
+    });
+  });
+});

package/tests/unit/post-execution-picker.test.ts

@@ -45,6 +45,8 @@ jest.unstable_mockModule('../../src/core/pull-request.js', () => ({
 // Mock worktree module
 const mockMergeWorktreeBranch = jest.fn();
 const mockRemoveWorktree = jest.fn();
+const mockPullMainBranch = jest.fn();
+const mockPushMainBranch = jest.fn();
 jest.unstable_mockModule('../../src/core/worktree.js', () => ({
   getRepoRoot: jest.fn(),
   getRepoBasename: jest.fn(),
@@ -60,6 +62,9 @@ jest.unstable_mockModule('../../src/core/worktree.js', () => ({
   branchExists: jest.fn(),
   getWorktreeProjectPath: jest.fn(),
   resolveWorktreeProjectByIdentifier: jest.fn(),
+  pullMainBranch: mockPullMainBranch,
+  pushMainBranch: mockPushMainBranch,
+  detectMainBranch: jest.fn(),
 }));
 
 // Import after mocking