rafcode 2.3.0 → 2.4.1-0

package/tests/unit/token-tracker.test.ts

@@ -1,4 +1,4 @@
-import { TokenTracker, CostBreakdown, accumulateUsage } from '../../src/utils/token-tracker.js';
+import { TokenTracker, CostBreakdown, accumulateUsage, sumCostBreakdowns } from '../../src/utils/token-tracker.js';
 import { UsageData, PricingConfig, DEFAULT_CONFIG } from '../../src/types/config.js';
 
 function makeUsage(overrides: Partial<UsageData> = {}): UsageData {
@@ -654,6 +654,172 @@ describe('TokenTracker', () => {
     });
   });
 
+  describe('mixed-attempt cost calculation (aggregate + modelUsage)', () => {
+    it('should correctly price attempts with mixed modelUsage presence', () => {
+      const tracker = new TokenTracker(testPricing);
+      // Attempt 1: has modelUsage (opus)
+      const attempt1 = makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 500_000,
+        modelUsage: {
+          'claude-opus-4-6': {
+            inputTokens: 1_000_000,
+            outputTokens: 500_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      });
+      // Attempt 2: NO modelUsage (aggregate-only, should use sonnet fallback)
+      const attempt2 = makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 1_000_000,
+        modelUsage: {}, // Empty - should fallback to sonnet pricing
+      });
+
+      const entry = tracker.addTask('01', [attempt1, attempt2]);
+
+      // Attempt 1 (Opus): 1M*$15 + 0.5M*$75 = $15 + $37.5 = $52.5
+      // Attempt 2 (Sonnet fallback): 1M*$3 + 1M*$15 = $3 + $15 = $18
+      // Total: $52.5 + $18 = $70.5
+      expect(entry.cost.inputCost).toBeCloseTo(18); // 15 + 3
+      expect(entry.cost.outputCost).toBeCloseTo(52.5); // 37.5 + 15
+      expect(entry.cost.totalCost).toBeCloseTo(70.5);
+    });
+
+    it('should not underreport cost when first attempt has no modelUsage', () => {
+      const tracker = new TokenTracker(testPricing);
+      // Attempt 1: aggregate-only (no modelUsage)
+      const attempt1 = makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 1_000_000,
+        modelUsage: {},
+      });
+      // Attempt 2: has modelUsage
+      const attempt2 = makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 500_000,
+        modelUsage: {
+          'claude-opus-4-6': {
+            inputTokens: 1_000_000,
+            outputTokens: 500_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      });
+
+      const entry = tracker.addTask('01', [attempt1, attempt2]);
+
+      // Attempt 1 (Sonnet fallback): 1M*$3 + 1M*$15 = $18
+      // Attempt 2 (Opus): 1M*$15 + 0.5M*$75 = $52.5
+      // Total: $18 + $52.5 = $70.5
+      expect(entry.cost.totalCost).toBeCloseTo(70.5);
+    });
+
+    it('should handle all aggregate-only attempts', () => {
+      const tracker = new TokenTracker(testPricing);
+      const attempt1 = makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 1_000_000,
+        modelUsage: {},
+      });
+      const attempt2 = makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 1_000_000,
+        modelUsage: {},
+      });
+
+      const entry = tracker.addTask('01', [attempt1, attempt2]);
+
+      // Both use sonnet fallback: 2 * (1M*$3 + 1M*$15) = 2 * $18 = $36
+      expect(entry.cost.totalCost).toBeCloseTo(36);
+    });
+
+    it('should include cache costs from aggregate-only attempts', () => {
+      const tracker = new TokenTracker(testPricing);
+      // Attempt 1: has modelUsage with cache
+      const attempt1 = makeUsage({
+        inputTokens: 500_000,
+        outputTokens: 200_000,
+        cacheReadInputTokens: 100_000,
+        cacheCreationInputTokens: 50_000,
+        modelUsage: {
+          'claude-opus-4-6': {
+            inputTokens: 500_000,
+            outputTokens: 200_000,
+            cacheReadInputTokens: 100_000,
+            cacheCreationInputTokens: 50_000,
+          },
+        },
+      });
+      // Attempt 2: aggregate-only with cache
+      const attempt2 = makeUsage({
+        inputTokens: 500_000,
+        outputTokens: 200_000,
+        cacheReadInputTokens: 100_000,
+        cacheCreationInputTokens: 50_000,
+        modelUsage: {},
+      });
+
+      const entry = tracker.addTask('01', [attempt1, attempt2]);
+
+      // Opus cache rates: $1.5/MTok read, $18.75/MTok create
+      // Sonnet cache rates: $0.30/MTok read, $3.75/MTok create
+      // Attempt 1 cache: 0.1M*$1.5 + 0.05M*$18.75 = $0.15 + $0.9375 = $1.0875
+      // Attempt 2 cache: 0.1M*$0.30 + 0.05M*$3.75 = $0.03 + $0.1875 = $0.2175
+      // Total cache: $1.0875 + $0.2175 = $1.305
+      expect(entry.cost.cacheReadCost).toBeCloseTo(0.15 + 0.03);
+      expect(entry.cost.cacheCreateCost).toBeCloseTo(0.9375 + 0.1875);
+    });
+  });
+
+  describe('sumCostBreakdowns', () => {
+    it('should return zero breakdown for empty array', () => {
+      const result = sumCostBreakdowns([]);
+      expect(result.inputCost).toBe(0);
+      expect(result.outputCost).toBe(0);
+      expect(result.cacheReadCost).toBe(0);
+      expect(result.cacheCreateCost).toBe(0);
+      expect(result.totalCost).toBe(0);
+    });
+
+    it('should return same breakdown for single element', () => {
+      const cost: CostBreakdown = {
+        inputCost: 10,
+        outputCost: 20,
+        cacheReadCost: 1,
+        cacheCreateCost: 2,
+        totalCost: 33,
+      };
+      const result = sumCostBreakdowns([cost]);
+      expect(result).toEqual(cost);
+    });
+
+    it('should sum all cost fields across breakdowns', () => {
+      const cost1: CostBreakdown = {
+        inputCost: 10,
+        outputCost: 20,
+        cacheReadCost: 1,
+        cacheCreateCost: 2,
+        totalCost: 33,
+      };
+      const cost2: CostBreakdown = {
+        inputCost: 5,
+        outputCost: 10,
+        cacheReadCost: 0.5,
+        cacheCreateCost: 1,
+        totalCost: 16.5,
+      };
+      const result = sumCostBreakdowns([cost1, cost2]);
+      expect(result.inputCost).toBe(15);
+      expect(result.outputCost).toBe(30);
+      expect(result.cacheReadCost).toBe(1.5);
+      expect(result.cacheCreateCost).toBe(3);
+      expect(result.totalCost).toBe(49.5);
+    });
+  });
+
   describe('custom pricing', () => {
     it('should use custom pricing config', () => {
       const customPricing: PricingConfig = {
@@ -682,4 +848,141 @@ describe('TokenTracker', () => {
       expect(cost.totalCost).toBeCloseTo(60);
     });
   });
+
+  describe('rate limit estimation', () => {
+    it('should calculate rate limit percentage from cost', () => {
+      const tracker = new TokenTracker(testPricing);
+      // With default sonnet pricing ($3 input, $15 output), avg = $9/MTok
+      // Sonnet-equivalent tokens = cost / (9/1M) = cost * 1M/9
+      // Percentage = sonnetEquivTokens / cap * 100
+
+      // Test with $0.18 cost (should be ~2222 Sonnet-equiv tokens)
+      // With cap of 88000, that's ~2.5%
+      const percentage = tracker.calculateRateLimitPercentage(0.18, 88000);
+      // $0.18 / ($9/1M) = 20000 Sonnet-equiv tokens
+      // 20000 / 88000 * 100 = ~22.7%
+      expect(percentage).toBeCloseTo(22.73, 1);
+    });
+
+    it('should return 0 for zero cost', () => {
+      const tracker = new TokenTracker(testPricing);
+      expect(tracker.calculateRateLimitPercentage(0, 88000)).toBe(0);
+    });
+
+    it('should respect custom sonnetTokenCap', () => {
+      const tracker = new TokenTracker(testPricing);
+      const percentageDefault = tracker.calculateRateLimitPercentage(0.09, 88000);
+      const percentageHigherCap = tracker.calculateRateLimitPercentage(0.09, 176000);
+      // Higher cap should halve the percentage
+      expect(percentageHigherCap).toBeCloseTo(percentageDefault / 2, 1);
+    });
+
+    it('should calculate cumulative rate limit across tasks', () => {
+      const tracker = new TokenTracker(testPricing);
+
+      // Add a task with sonnet usage: 1M in / 1M out = $3 + $15 = $18
+      tracker.addTask('01', [makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 1_000_000,
+        modelUsage: {
+          'claude-sonnet-4-5': {
+            inputTokens: 1_000_000,
+            outputTokens: 1_000_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      })]);
+
+      const percentage = tracker.getCumulativeRateLimitPercentage(88000);
+      // $18 / ($9/1M) = 2,000,000 Sonnet-equiv tokens
+      // 2,000,000 / 88,000 * 100 = ~2272.7%
+      expect(percentage).toBeCloseTo(2272.73, 0);
+    });
+
+    it('should correctly weight Opus usage higher than Sonnet', () => {
+      const tracker = new TokenTracker(testPricing);
+
+      // Opus task: 1M in / 1M out = $15 + $75 = $90
+      tracker.addTask('01', [makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 1_000_000,
+        modelUsage: {
+          'claude-opus-4-6': {
+            inputTokens: 1_000_000,
+            outputTokens: 1_000_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      })]);
+
+      const opusPercentage = tracker.getCumulativeRateLimitPercentage(88000);
+
+      // Sonnet equivalent of $90 = $90 / ($9/1M) = 10,000,000 tokens
+      // 10,000,000 / 88,000 * 100 = ~11363.6%
+      expect(opusPercentage).toBeCloseTo(11363.6, 0);
+    });
+
+    it('should correctly weight Haiku usage lower than Sonnet', () => {
+      const tracker = new TokenTracker(testPricing);
+
+      // Haiku task: 1M in / 1M out = $1 + $5 = $6
+      tracker.addTask('01', [makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 1_000_000,
+        modelUsage: {
+          'claude-haiku-4-5': {
+            inputTokens: 1_000_000,
+            outputTokens: 1_000_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      })]);
+
+      const haikuPercentage = tracker.getCumulativeRateLimitPercentage(88000);
+
+      // Sonnet equivalent of $6 = $6 / ($9/1M) = ~666,667 tokens
+      // 666,667 / 88,000 * 100 = ~757.6%
+      expect(haikuPercentage).toBeCloseTo(757.6, 0);
+    });
+
+    it('should handle multi-model tasks correctly for rate limit', () => {
+      const tracker = new TokenTracker(testPricing);
+
+      // Mixed task: Opus attempt ($52.5) + Sonnet attempt ($18) = $70.5
+      const attempt1 = makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 500_000,
+        modelUsage: {
+          'claude-opus-4-6': {
+            inputTokens: 1_000_000,
+            outputTokens: 500_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      });
+      const attempt2 = makeUsage({
+        inputTokens: 1_000_000,
+        outputTokens: 1_000_000,
+        modelUsage: {
+          'claude-sonnet-4-5': {
+            inputTokens: 1_000_000,
+            outputTokens: 1_000_000,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          },
+        },
+      });
+
+      tracker.addTask('01', [attempt1, attempt2]);
+      const percentage = tracker.getCumulativeRateLimitPercentage(88000);
+
+      // $70.5 / ($9/1M) = 7,833,333 Sonnet-equiv tokens
+      // 7,833,333 / 88,000 * 100 = ~8901.5%
+      expect(percentage).toBeCloseTo(8901.5, 0);
+    });
+  });
 });

package/tests/unit/validation.test.ts

@@ -76,10 +76,12 @@ describe('Validation', () => {
   });
 
   describe('resolveModelOption', () => {
-    it('should return opus as default', () => {
-      expect(resolveModelOption()).toBe('opus');
-      expect(resolveModelOption(undefined, undefined)).toBe('opus');
-      expect(resolveModelOption(undefined, false)).toBe('opus');
+    it('should return a valid model as default', () => {
+      // Default comes from config, could be short alias or full model ID
+      const result = resolveModelOption();
+      expect(result).toMatch(/^(opus|sonnet|haiku|claude-(opus|sonnet|haiku)-.+)$/);
+      expect(resolveModelOption(undefined, undefined)).toBe(result);
+      expect(resolveModelOption(undefined, false)).toBe(result);
     });
 
     it('should use --model flag when provided', () => {

package/tests/unit/worktree.test.ts

@@ -43,6 +43,10 @@ const {
   removeWorktree,
   listWorktreeProjects,
   resolveWorktreeProjectByIdentifier,
+  detectMainBranch,
+  pullMainBranch,
+  pushMainBranch,
+  rebaseOntoMain,
 } = await import('../../src/core/worktree.js');
 
 const HOME = os.homedir();
@@ -622,4 +626,309 @@ describe('worktree utilities', () => {
       );
     });
   });
+
+  describe('detectMainBranch', () => {
+    it('should detect main branch from origin/HEAD', () => {
+      mockExecSync.mockReturnValue('refs/remotes/origin/main\n');
+      expect(detectMainBranch()).toBe('main');
+    });
+
+    it('should detect master from origin/HEAD', () => {
+      mockExecSync.mockReturnValue('refs/remotes/origin/master\n');
+      expect(detectMainBranch()).toBe('master');
+    });
+
+    it('should fall back to main when origin/HEAD not set', () => {
+      let callCount = 0;
+      mockExecSync.mockImplementation((cmd: unknown) => {
+        callCount++;
+        const cmdStr = cmd as string;
+        if (cmdStr.includes('symbolic-ref')) {
+          throw new Error('ref refs/remotes/origin/HEAD is not a symbolic ref');
+        }
+        if (cmdStr.includes('refs/heads/main') && callCount === 2) {
+          return 'valid\n';
+        }
+        throw new Error('fatal');
+      });
+
+      expect(detectMainBranch()).toBe('main');
+    });
+
+    it('should fall back to master when main does not exist', () => {
+      let callCount = 0;
+      mockExecSync.mockImplementation((cmd: unknown) => {
+        callCount++;
+        const cmdStr = cmd as string;
+        if (cmdStr.includes('symbolic-ref')) {
+          throw new Error('ref refs/remotes/origin/HEAD is not a symbolic ref');
+        }
+        if (cmdStr.includes('refs/heads/main')) {
+          throw new Error('fatal: Needed a single revision');
+        }
+        if (cmdStr.includes('refs/heads/master') && callCount === 3) {
+          return 'valid\n';
+        }
+        throw new Error('fatal');
+      });
+
+      expect(detectMainBranch()).toBe('master');
+    });
+
+    it('should return null when no main branch found', () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('not found');
+      });
+
+      expect(detectMainBranch()).toBeNull();
+    });
+  });
+
+  describe('pullMainBranch', () => {
+    it('should return error when main branch cannot be detected', () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('not found');
+      });
+
+      const result = pullMainBranch();
+
+      expect(result.success).toBe(false);
+      expect(result.mainBranch).toBeNull();
+      expect(result.error).toContain('Could not detect main branch');
+    });
+
+    it('should fetch main when not on main branch', () => {
+      let commands: string[] = [];
+      mockExecSync.mockImplementation((cmd: unknown) => {
+        const cmdStr = cmd as string;
+        commands.push(cmdStr);
+        if (cmdStr.includes('symbolic-ref')) return 'refs/remotes/origin/main\n';
+        if (cmdStr.includes('branch --show-current')) return 'feature-branch\n';
+        if (cmdStr.includes('fetch origin main:main')) return '';
+        return '';
+      });
+
+      const result = pullMainBranch();
+
+      expect(result.success).toBe(true);
+      expect(result.mainBranch).toBe('main');
+      expect(result.hadChanges).toBe(true);
+      expect(commands).toContain('git fetch origin main:main');
+    });
+
+    it('should warn when local main has diverged', () => {
+      let commands: string[] = [];
+      mockExecSync.mockImplementation((cmd: unknown) => {
+        const cmdStr = cmd as string;
+        commands.push(cmdStr);
+        if (cmdStr.includes('symbolic-ref')) return 'refs/remotes/origin/main\n';
+        if (cmdStr.includes('branch --show-current')) return 'feature-branch\n';
+        if (cmdStr.includes('fetch origin main:main')) throw new Error('not fast-forward');
+        if (cmdStr.includes('fetch origin main')) return '';
+        return '';
+      });
+
+      const result = pullMainBranch();
+
+      expect(result.success).toBe(false);
+      expect(result.mainBranch).toBe('main');
+      expect(result.hadChanges).toBe(false);
+      expect(result.error).toContain('diverged');
+    });
+
+    it('should fail when on main but has uncommitted changes', () => {
+      mockExecSync.mockImplementation((cmd: unknown) => {
+        const cmdStr = cmd as string;
+        if (cmdStr.includes('symbolic-ref')) return 'refs/remotes/origin/main\n';
+        if (cmdStr.includes('branch --show-current')) return 'main\n';
+        if (cmdStr.includes('status --porcelain')) return ' M file.ts\n';
+        return '';
+      });
+
+      const result = pullMainBranch();
+
+      expect(result.success).toBe(false);
+      expect(result.mainBranch).toBe('main');
+      expect(result.error).toContain('uncommitted changes');
+    });
+
+    it('should pull successfully when on main with no changes', () => {
+      mockExecSync.mockImplementation((cmd: unknown) => {
+        const cmdStr = cmd as string;
+        if (cmdStr.includes('symbolic-ref')) return 'refs/remotes/origin/main\n';
+        if (cmdStr.includes('branch --show-current')) return 'main\n';
+        if (cmdStr.includes('status --porcelain')) return '';
+        if (cmdStr.includes('fetch origin main')) return '';
+        if (cmdStr.includes('merge --ff-only')) return 'Updating abc123..def456\n';
+        return '';
+      });
+
+      const result = pullMainBranch();
+
+      expect(result.success).toBe(true);
+      expect(result.mainBranch).toBe('main');
+      expect(result.hadChanges).toBe(true);
+    });
+
+    it('should report no changes when already up to date', () => {
+      mockExecSync.mockImplementation((cmd: unknown) => {
+        const cmdStr = cmd as string;
+        if (cmdStr.includes('symbolic-ref')) return 'refs/remotes/origin/main\n';
+        if (cmdStr.includes('branch --show-current')) return 'main\n';
+        if (cmdStr.includes('status --porcelain')) return '';
+        if (cmdStr.includes('fetch origin main')) return '';
+        if (cmdStr.includes('merge --ff-only')) return 'Already up to date.\n';
+        return '';
+      });
+
+      const result = pullMainBranch();
+
+      expect(result.success).toBe(true);
+      expect(result.mainBranch).toBe('main');
+      expect(result.hadChanges).toBe(false);
+    });
+
+    it('should fail when branch has diverged', () => {
+      mockExecSync.mockImplementation((cmd: unknown) => {
+        const cmdStr = cmd as string;
+        if (cmdStr.includes('symbolic-ref')) return 'refs/remotes/origin/main\n';
+        if (cmdStr.includes('branch --show-current')) return 'main\n';
+        if (cmdStr.includes('status --porcelain')) return '';
+        if (cmdStr.includes('fetch origin main')) return '';
+        if (cmdStr.includes('merge --ff-only')) throw new Error('Not possible to fast-forward');
+        return '';
+      });
+
+      const result = pullMainBranch();
+
+      expect(result.success).toBe(false);
+      expect(result.mainBranch).toBe('main');
+      expect(result.error).toContain('diverged from origin');
+    });
+  });
+
+  describe('rebaseOntoMain', () => {
+    it('should successfully rebase onto main branch', () => {
+      mockExecSync.mockImplementation((cmd: unknown) => {
+        const cmdStr = cmd as string;
+        if (cmdStr.includes('git rebase main')) return '';
+        return '';
+      });
+
+      const result = rebaseOntoMain('main', '/path/to/worktree');
+
+      expect(result.success).toBe(true);
+      expect(result.error).toBeUndefined();
+      expect(mockExecSync).toHaveBeenCalledWith(
+        'git rebase main',
+        expect.objectContaining({
+          cwd: '/path/to/worktree',
+        })
+      );
+    });
+
+    it('should abort rebase and return failure on conflict', () => {
+      const commands: string[] = [];
+      mockExecSync.mockImplementation((cmd: unknown) => {
+        const cmdStr = cmd as string;
+        commands.push(cmdStr);
+        if (cmdStr.includes('git rebase main')) {
+          throw new Error('CONFLICT: Merge conflict in file.ts');
+        }
+        if (cmdStr.includes('git rebase --abort')) return '';
+        return '';
+      });
+
+      const result = rebaseOntoMain('main', '/path/to/worktree');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('CONFLICT');
+      expect(commands).toContain('git rebase main');
+      expect(commands).toContain('git rebase --abort');
+      expect(mockExecSync).toHaveBeenCalledWith(
+        'git rebase --abort',
+        expect.objectContaining({
+          cwd: '/path/to/worktree',
+        })
+      );
+    });
+
+    it('should handle rebase abort failure gracefully', () => {
+      mockExecSync.mockImplementation((cmd: unknown) => {
+        const cmdStr = cmd as string;
+        if (cmdStr.includes('git rebase main')) {
+          throw new Error('CONFLICT: Merge conflict');
+        }
+        if (cmdStr.includes('git rebase --abort')) {
+          throw new Error('abort failed');
+        }
+        return '';
+      });
+
+      const result = rebaseOntoMain('main', '/path/to/worktree');
+
+      // Should still return failure even if abort fails
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('CONFLICT');
+    });
+  });
+
+  describe('pushMainBranch', () => {
+    it('should return error when main branch cannot be detected', () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('not found');
+      });
+
+      const result = pushMainBranch();
+
+      expect(result.success).toBe(false);
+      expect(result.mainBranch).toBeNull();
+      expect(result.error).toContain('Could not detect main branch');
+    });
+
+    it('should push main successfully', () => {
+      mockExecSync.mockImplementation((cmd: unknown) => {
+        const cmdStr = cmd as string;
+        if (cmdStr.includes('symbolic-ref')) return 'refs/remotes/origin/main\n';
+        if (cmdStr.includes('push origin main')) return '';
+        return '';
+      });
+
+      const result = pushMainBranch();
+
+      expect(result.success).toBe(true);
+      expect(result.mainBranch).toBe('main');
+      expect(result.hadChanges).toBe(true);
+    });
+
+    it('should report no changes when already up to date', () => {
+      mockExecSync.mockImplementation((cmd: unknown) => {
+        const cmdStr = cmd as string;
+        if (cmdStr.includes('symbolic-ref')) return 'refs/remotes/origin/main\n';
+        if (cmdStr.includes('push origin main')) throw new Error('Everything up-to-date');
+        return '';
+      });
+
+      const result = pushMainBranch();
+
+      expect(result.success).toBe(true);
+      expect(result.mainBranch).toBe('main');
+      expect(result.hadChanges).toBe(false);
+    });
+
+    it('should fail when push is rejected', () => {
+      mockExecSync.mockImplementation((cmd: unknown) => {
+        const cmdStr = cmd as string;
+        if (cmdStr.includes('symbolic-ref')) return 'refs/remotes/origin/main\n';
+        if (cmdStr.includes('push origin main')) throw new Error('rejected - non-fast-forward');
+        return '';
+      });
+
+      const result = pushMainBranch();
+
+      expect(result.success).toBe(false);
+      expect(result.mainBranch).toBe('main');
+      expect(result.error).toContain('Failed to push main');
+    });
+  });
 });