rafcode 3.0.0 → 3.8.0

package/tests/unit/terminal-symbols.test.ts

@@ -1,5 +1,6 @@
 import {
   SYMBOLS,
+  formatModelMetadata,
   formatTaskProgress,
   formatProjectHeader,
   formatSummary,
@@ -15,6 +16,28 @@ import type { UsageData } from '../../src/types/config.js';
 import type { CostBreakdown, TaskUsageEntry } from '../../src/utils/token-tracker.js';
 
 describe('Terminal Symbols', () => {
+  describe('formatModelMetadata', () => {
+    it('should format model only when no metadata is present', () => {
+      expect(formatModelMetadata('sonnet')).toBe('sonnet');
+    });
+
+    it('should append effort when present', () => {
+      expect(formatModelMetadata('sonnet', { effort: 'low' })).toBe('sonnet, low');
+    });
+
+    it('should append fast when enabled', () => {
+      expect(formatModelMetadata('sonnet', { fast: true })).toBe('sonnet, fast');
+    });
+
+    it('should append effort and fast in order', () => {
+      expect(formatModelMetadata('sonnet', { effort: 'low', fast: true })).toBe('sonnet, low, fast');
+    });
+
+    it('should omit falsy fast values', () => {
+      expect(formatModelMetadata('sonnet', { effort: 'low', fast: false })).toBe('sonnet, low');
+    });
+  });
+
   describe('SYMBOLS', () => {
     it('should have all required symbols', () => {
       expect(SYMBOLS.running).toBe('●');
@@ -115,6 +138,11 @@ describe('Terminal Symbols', () => {
       expect(result).toBe('● auth-login (sonnet) 1m 23s');
     });
 
+    it('should show model metadata in parentheses for running task with time', () => {
+      const result = formatTaskProgress(1, 5, 'running', 'auth-login', 83000, undefined, 'sonnet', { effort: 'low', fast: true });
+      expect(result).toBe('● auth-login (sonnet, low, fast) 1m 23s');
+    });
+
     it('should show model name in parentheses for running task without time', () => {
       const result = formatTaskProgress(1, 5, 'running', 'auth-login', undefined, undefined, 'opus');
       expect(result).toBe('● auth-login (opus) 1/5');
@@ -125,6 +153,11 @@ describe('Terminal Symbols', () => {
       expect(result).toBe('✓ setup-db (haiku) 2m 34s');
     });
 
+    it('should omit effort when unavailable and omit falsy fast', () => {
+      const result = formatTaskProgress(3, 5, 'completed', 'setup-db', 154000, undefined, 'haiku', { fast: false });
+      expect(result).toBe('✓ setup-db (haiku) 2m 34s');
+    });
+
     it('should show model name in parentheses for completed task without time', () => {
       const result = formatTaskProgress(3, 5, 'completed', 'setup-db', undefined, undefined, 'sonnet');
       expect(result).toBe('✓ setup-db (sonnet) 3/5');
@@ -145,6 +178,11 @@ describe('Terminal Symbols', () => {
       expect(result).toBe('● 001-auth-login (sonnet) 1m 23s');
     });
 
+    it('should show normalized canonical model names in task progress', () => {
+      const result = formatTaskProgress(1, 5, 'running', 'auth-login', 83000, '001', 'gpt-5.4');
+      expect(result).toBe('● 001-auth-login (gpt-5.4) 1m 23s');
+    });
+
     it('should show model name for blocked task without time', () => {
       const result = formatTaskProgress(2, 5, 'blocked', 'depends-on-failed', undefined, undefined, 'sonnet');
       expect(result).toBe('⊘ depends-on-failed (sonnet) 2/5');
@@ -164,6 +202,14 @@ describe('Terminal Symbols', () => {
       const result = formatTaskProgress(2, 5, 'completed', 'setup-db', 154000, '002', 'opus');
       expect(result).toBe('✓ 002-setup-db (opus) 2m 34s');
     });
+
+    it('should keep truncation stable with model metadata', () => {
+      const longName = 'this-is-a-very-long-task-name-that-should-be-truncated-for-display';
+      const result = formatTaskProgress(1, 1, 'running', longName, 1000, '001', 'sonnet', { effort: 'low', fast: true });
+
+      expect(result).toContain('001-this-is-a-very-long-task-name-that-shou…');
+      expect(result).toContain('(sonnet, low, fast) 1s');
+    });
   });
 
   describe('formatProjectHeader', () => {
@@ -317,6 +363,10 @@ describe('Terminal Symbols', () => {
       expect(formatCost(0)).toBe('$0.00');
     });
 
+    it('should format unavailable cost', () => {
+      expect(formatCost(null)).toBe('unavailable');
+    });
+
     it('should format normal costs with 2 decimals', () => {
       expect(formatCost(1.23)).toBe('$1.23');
     });
@@ -341,10 +391,11 @@ describe('Terminal Symbols', () => {
       cacheReadInputTokens: 0,
       cacheCreationInputTokens: 0,
       modelUsage: {},
+      totalCostUsd: 0,
       ...overrides,
     });
 
-    const makeCost = (total: number): CostBreakdown => ({
+    const makeCost = (total: number | null): CostBreakdown => ({
       totalCost: total,
     });
 
@@ -391,6 +442,12 @@ describe('Terminal Symbols', () => {
         const result = formatTaskTokenSummary(makeEntry(usage, makeCost(0.42), []));
         expect(result).toBe('  Tokens: 5,234 in / 1,023 out | Cost: $0.42');
       });
+
+      it('should omit cost when exact cost is unknown', () => {
+        const usage = makeUsage({ totalCostUsd: null });
+        const result = formatTaskTokenSummary(makeEntry(usage, makeCost(null)));
+        expect(result).toBe('  Tokens: 5,234 in / 1,023 out');
+      });
     });
 
     describe('multi-attempt tasks', () => {
@@ -460,6 +517,34 @@ describe('Terminal Symbols', () => {
         expect(lines[2]).toContain('Attempt 3');
         expect(lines[3]).toContain('Total');
       });
+
+      it('should omit cost for attempts and totals with unknown exact cost', () => {
+        const attempt1 = makeUsage({ inputTokens: 1000, outputTokens: 200, totalCostUsd: null });
+        const attempt2 = makeUsage({ inputTokens: 2000, outputTokens: 400, totalCostUsd: null });
+        const totalUsage = makeUsage({ inputTokens: 3000, outputTokens: 600, totalCostUsd: null });
+        const entry = makeEntry(totalUsage, makeCost(null), [attempt1, attempt2]);
+
+        const result = formatTaskTokenSummary(entry);
+        const lines = result.split('\n');
+
+        expect(lines[0]).toBe('    Attempt 1: 1,000 in / 200 out');
+        expect(lines[1]).toBe('    Attempt 2: 2,000 in / 400 out');
+        expect(lines[2]).toBe('    Total: 3,000 in / 600 out');
+      });
+
+      it('should preserve exact zero cost instead of omitting it', () => {
+        const attempt1 = makeUsage({ inputTokens: 1000, outputTokens: 200, totalCostUsd: 0 });
+        const attempt2 = makeUsage({ inputTokens: 2000, outputTokens: 400, totalCostUsd: null });
+        const totalUsage = makeUsage({ inputTokens: 3000, outputTokens: 600, totalCostUsd: 0 });
+        const entry = makeEntry(totalUsage, makeCost(0), [attempt1, attempt2]);
+
+        const result = formatTaskTokenSummary(entry);
+        const lines = result.split('\n');
+
+        expect(lines[0]).toBe('    Attempt 1: 1,000 in / 200 out | Cost: $0.00');
+        expect(lines[1]).toBe('    Attempt 2: 2,000 in / 400 out');
+        expect(lines[2]).toBe('    Total: 3,000 in / 600 out | Cost: $0.00');
+      });
     });
   });
 
@@ -474,7 +559,7 @@ describe('Terminal Symbols', () => {
       ...overrides,
     });
 
-    const makeCost = (total: number): CostBreakdown => ({
+    const makeCost = (total: number | null): CostBreakdown => ({
       totalCost: total,
     });
 
@@ -528,6 +613,11 @@ describe('Terminal Symbols', () => {
       );
       expect(result).not.toContain('Cache:');
     });
+
+    it('should omit total cost when exact cost is unknown', () => {
+      const result = formatTokenTotalSummary(makeUsage(), makeCost(null));
+      expect(result).not.toContain('Total cost:');
+    });
   });
 
   describe('formatTaskTokenSummary with options', () => {
@@ -537,10 +627,11 @@ describe('Terminal Symbols', () => {
       cacheReadInputTokens: 0,
       cacheCreationInputTokens: 0,
       modelUsage: {},
+      totalCostUsd: 0,
       ...overrides,
     });
 
-    const makeCost = (total: number): CostBreakdown => ({
+    const makeCost = (total: number | null): CostBreakdown => ({
       totalCost: total,
     });
 

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

@@ -1,4 +1,4 @@
-import { TokenTracker, CostBreakdown, accumulateUsage, sumCostBreakdowns } from '../../src/utils/token-tracker.js';
+import { TokenTracker, CostBreakdown, accumulateUsage, mergeUsageData, sumCostBreakdowns } from '../../src/utils/token-tracker.js';
 import { UsageData } from '../../src/types/config.js';
 
 function makeUsage(overrides: Partial<UsageData> = {}): UsageData {
@@ -85,6 +85,26 @@ describe('TokenTracker', () => {
       expect(entry.cost.totalCost).toBe(25.0);
     });
 
+    it('should mark total cost unavailable when any attempt has unknown exact cost', () => {
+      const tracker = new TokenTracker();
+      const attempt1 = makeUsage({
+        inputTokens: 100,
+        outputTokens: 50,
+        totalCostUsd: null,
+      });
+      const attempt2 = makeUsage({
+        inputTokens: 200,
+        outputTokens: 75,
+        totalCostUsd: 0.5,
+      });
+
+      const entry = tracker.addTask('01', [attempt1, attempt2]);
+      expect(entry.usage.inputTokens).toBe(300);
+      expect(entry.usage.outputTokens).toBe(125);
+      expect(entry.cost.totalCost).toBeNull();
+      expect(entry.usage.totalCostUsd).toBeNull();
+    });
+
     it('should store attempts array in entry', () => {
       const tracker = new TokenTracker();
       const usage = makeUsage({ inputTokens: 100, totalCostUsd: 0.01 });
@@ -129,6 +149,27 @@ describe('TokenTracker', () => {
       expect(totals.usage.outputTokens).toBe(750_000);
     });
 
+    it('should keep grand total cost unavailable when any task cost is unknown', () => {
+      const tracker = new TokenTracker();
+
+      tracker.addTask('01', [makeUsage({
+        inputTokens: 100,
+        outputTokens: 10,
+        totalCostUsd: null,
+      })]);
+
+      tracker.addTask('02', [makeUsage({
+        inputTokens: 200,
+        outputTokens: 20,
+        totalCostUsd: 1.25,
+      })]);
+
+      const totals = tracker.getTotals();
+      expect(totals.usage.inputTokens).toBe(300);
+      expect(totals.cost.totalCost).toBeNull();
+      expect(totals.usage.totalCostUsd).toBeNull();
+    });
+
     it('should return empty totals when no tasks added', () => {
       const tracker = new TokenTracker();
       const totals = tracker.getTotals();
@@ -330,6 +371,21 @@ describe('TokenTracker', () => {
       expect(result.totalCostUsd).toBe(1.5);
     });
 
+    it('should keep accumulated cost unavailable when any attempt has unknown cost', () => {
+      const attempt1 = makeUsage({
+        inputTokens: 100,
+        totalCostUsd: null,
+      });
+      const attempt2 = makeUsage({
+        inputTokens: 200,
+        totalCostUsd: 1.0,
+      });
+
+      const result = accumulateUsage([attempt1, attempt2]);
+      expect(result.inputTokens).toBe(300);
+      expect(result.totalCostUsd).toBeNull();
+    });
+
     it('should merge modelUsage for same model across attempts', () => {
       const attempt1 = makeUsage({
         modelUsage: {
@@ -440,6 +496,121 @@ describe('TokenTracker', () => {
     });
   });
 
+  describe('mergeUsageData', () => {
+    it('should initialize usage when existing is undefined', () => {
+      const incoming = makeUsage({
+        inputTokens: 10,
+        outputTokens: 5,
+        totalCostUsd: 0.25,
+        modelUsage: {
+          'claude-opus-4-6': {
+            inputTokens: 10,
+            outputTokens: 5,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+            costUsd: 0.25,
+          },
+        },
+      });
+
+      const result = mergeUsageData(undefined, incoming);
+      expect(result).toEqual(incoming);
+    });
+
+    it('should return existing usage when incoming is undefined', () => {
+      const existing = makeUsage({
+        inputTokens: 10,
+        outputTokens: 5,
+      });
+
+      const result = mergeUsageData(existing, undefined);
+      expect(result).toEqual(existing);
+    });
+
+    it('should sum usage fields and model usage across both inputs', () => {
+      const existing = makeUsage({
+        inputTokens: 100,
+        outputTokens: 40,
+        cacheReadInputTokens: 10,
+        cacheCreationInputTokens: 5,
+        totalCostUsd: 1.0,
+        modelUsage: {
+          'claude-opus-4-6': {
+            inputTokens: 100,
+            outputTokens: 40,
+            cacheReadInputTokens: 10,
+            cacheCreationInputTokens: 5,
+            costUsd: 1.0,
+          },
+        },
+      });
+      const incoming = makeUsage({
+        inputTokens: 50,
+        outputTokens: 20,
+        cacheReadInputTokens: 4,
+        cacheCreationInputTokens: 2,
+        totalCostUsd: 0.5,
+        modelUsage: {
+          'claude-opus-4-6': {
+            inputTokens: 50,
+            outputTokens: 20,
+            cacheReadInputTokens: 4,
+            cacheCreationInputTokens: 2,
+            costUsd: 0.5,
+          },
+        },
+      });
+
+      const result = mergeUsageData(existing, incoming);
+      expect(result).toEqual({
+        inputTokens: 150,
+        outputTokens: 60,
+        cacheReadInputTokens: 14,
+        cacheCreationInputTokens: 7,
+        totalCostUsd: 1.5,
+        modelUsage: {
+          'claude-opus-4-6': {
+            inputTokens: 150,
+            outputTokens: 60,
+            cacheReadInputTokens: 14,
+            cacheCreationInputTokens: 7,
+            costUsd: 1.5,
+          },
+        },
+      });
+    });
+
+    it('should treat missing numeric fields as zero while merging', () => {
+      const existing = makeUsage({
+        inputTokens: 20,
+        outputTokens: 10,
+        totalCostUsd: null,
+      });
+      const incoming = {
+        inputTokens: 5,
+        modelUsage: {
+          codex: {
+            inputTokens: 5,
+          },
+        },
+      } as unknown as UsageData;
+
+      const result = mergeUsageData(existing, incoming);
+      expect(result!.inputTokens).toBe(25);
+      expect(result!.outputTokens).toBe(10);
+      expect(result!.cacheReadInputTokens).toBe(0);
+      expect(result!.cacheCreationInputTokens).toBe(0);
+      expect(result!.totalCostUsd).toBeNull();
+      expect(result!.modelUsage.codex).toEqual({
+        inputTokens: 5,
+        outputTokens: 0,
+        cacheReadInputTokens: 0,
+        cacheCreationInputTokens: 0,
+        costUsd: null,
+      });
+    });
+  });
+
   describe('sumCostBreakdowns', () => {
     it('should return zero breakdown for empty array', () => {
       const result = sumCostBreakdowns([]);
@@ -464,5 +635,13 @@ describe('TokenTracker', () => {
       const result = sumCostBreakdowns([cost1, cost2]);
       expect(result.totalCost).toBe(49.5);
     });
+
+    it('should keep total cost unavailable when any breakdown is unknown', () => {
+      const result = sumCostBreakdowns([
+        { totalCost: 33 },
+        { totalCost: null },
+      ]);
+      expect(result.totalCost).toBeNull();
+    });
   });
 });

package/tests/unit/validation.test.ts

@@ -2,7 +2,6 @@ import {
   validateProjectName,
   sanitizeProjectName,
   validateModelName,
-  resolveModelOption,
 } from '../../src/utils/validation.js';
 
 describe('Validation', () => {
@@ -67,6 +66,11 @@ describe('Validation', () => {
       expect(validateModelName('OPUS')).toBe('opus');
     });
 
+    it('should accept Codex model names', () => {
+      expect(validateModelName('gpt-5.4')).toBe('gpt-5.4');
+      expect(validateModelName('gpt54')).toBe('gpt54');
+    });
+
     it('should reject invalid model names', () => {
       expect(validateModelName('gpt4')).toBeNull();
       expect(validateModelName('claude')).toBeNull();
@@ -75,46 +79,10 @@ describe('Validation', () => {
     });
   });
 
-  describe('resolveModelOption', () => {
-    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', () => {
-      expect(resolveModelOption('sonnet')).toBe('sonnet');
-      expect(resolveModelOption('haiku')).toBe('haiku');
-      expect(resolveModelOption('opus')).toBe('opus');
-    });
-
-    it('should normalize model name to lowercase', () => {
-      expect(resolveModelOption('SONNET')).toBe('sonnet');
-      expect(resolveModelOption('Haiku')).toBe('haiku');
-    });
-
-    it('should use --sonnet shorthand', () => {
-      expect(resolveModelOption(undefined, true)).toBe('sonnet');
-    });
-
-    it('should throw error for conflicting flags', () => {
-      expect(() => resolveModelOption('haiku', true)).toThrow(
-        'Cannot specify both --model and --sonnet flags'
-      );
-      expect(() => resolveModelOption('opus', true)).toThrow(
-        'Cannot specify both --model and --sonnet flags'
-      );
-    });
-
-    it('should throw error for invalid model name', () => {
-      expect(() => resolveModelOption('gpt4')).toThrow(
-        'Invalid model name: "gpt4". Valid options: sonnet, haiku, opus'
-      );
-      expect(() => resolveModelOption('invalid')).toThrow(
-        'Invalid model name: "invalid". Valid options: sonnet, haiku, opus'
-      );
+  describe('resolveModelOption removed', () => {
+    it('should not be exported from validation module', async () => {
+      const validationModule = await import('../../src/utils/validation.js');
+      expect('resolveModelOption' in validationModule).toBe(false);
     });
   });
 });

package/tests/unit/worktree-flag-override.test.ts

@@ -1,186 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { Command } from 'commander';
-import { createPlanCommand } from '../../src/commands/plan.js';
-import { createDoCommand } from '../../src/commands/do.js';
-import { getWorktreeDefault, resetConfigCache, saveConfig } from '../../src/utils/config.js';
-
-describe('Worktree Flag Override', () => {
-  let tempDir: string;
-  let originalHome: string | undefined;
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-worktree-flag-test-'));
-    originalHome = process.env.HOME;
-    process.env.HOME = tempDir;
-    resetConfigCache();
-  });
-
-  afterEach(() => {
-    process.env.HOME = originalHome;
-    fs.rmSync(tempDir, { recursive: true, force: true });
-    resetConfigCache();
-  });
-
-  describe('Commander.js --no-worktree flag parsing', () => {
-    it('should parse --worktree as true', () => {
-      const planCommand = createPlanCommand();
-      // Use parseOptions instead of parse to avoid running the action
-      planCommand.parseOptions(['--worktree']);
-      const opts = planCommand.opts();
-      expect(opts.worktree).toBe(true);
-    });
-
-    it('should parse --no-worktree as false', () => {
-      const planCommand = createPlanCommand();
-      planCommand.parseOptions(['--no-worktree']);
-      const opts = planCommand.opts();
-      expect(opts.worktree).toBe(false);
-    });
-
-    it('should parse omitted flag as undefined', () => {
-      const planCommand = createPlanCommand();
-      planCommand.parseOptions([]);
-      const opts = planCommand.opts();
-      expect(opts.worktree).toBeUndefined();
-    });
-
-    it('should parse --worktree for do command as true', () => {
-      const doCommand = createDoCommand();
-      doCommand.parseOptions(['--worktree']);
-      const opts = doCommand.opts();
-      expect(opts.worktree).toBe(true);
-    });
-
-    it('should parse --no-worktree for do command as false', () => {
-      const doCommand = createDoCommand();
-      doCommand.parseOptions(['--no-worktree']);
-      const opts = doCommand.opts();
-      expect(opts.worktree).toBe(false);
-    });
-
-    it('should parse omitted flag for do command as undefined', () => {
-      const doCommand = createDoCommand();
-      doCommand.parseOptions([]);
-      const opts = doCommand.opts();
-      expect(opts.worktree).toBeUndefined();
-    });
-  });
-
-  describe('Config resolution with --no-worktree flag', () => {
-    it('should resolve to true when --worktree flag is passed (regardless of config)', () => {
-      // Simulate: options.worktree = true (from --worktree flag)
-      const options = { worktree: true };
-      // With nullish coalescing, explicit true takes precedence
-      const resolved = options.worktree ?? getWorktreeDefault();
-      expect(resolved).toBe(true);
-    });
-
-    it('should resolve to false when --no-worktree flag is passed (regardless of config)', () => {
-      // Simulate: options.worktree = false (from --no-worktree flag)
-      const options = { worktree: false };
-      // With nullish coalescing, explicit false takes precedence
-      const resolved = options.worktree ?? getWorktreeDefault();
-      expect(resolved).toBe(false);
-    });
-
-    it('should resolve to config default when no flag is passed', () => {
-      // Simulate: options.worktree = undefined (no flag passed)
-      const options = { worktree: undefined };
-      // With nullish coalescing, undefined falls back to getWorktreeDefault()
-      const resolved = options.worktree ?? getWorktreeDefault();
-      // We can't assert a specific value here since it depends on the user's actual config
-      expect(typeof resolved).toBe('boolean');
-    });
-  });
-
-  describe('Tri-state behavior verification', () => {
-    it('should correctly handle all three states (true/false/undefined) in plan command', () => {
-      // State 1: --worktree (explicit true)
-      const planCmd1 = createPlanCommand();
-      planCmd1.parseOptions(['--worktree']);
-      const opts1 = planCmd1.opts();
-      expect(opts1.worktree).toBe(true);
-      const resolved1 = opts1.worktree ?? getWorktreeDefault();
-      expect(resolved1).toBe(true);
-
-      // State 2: --no-worktree (explicit false)
-      const planCmd2 = createPlanCommand();
-      planCmd2.parseOptions(['--no-worktree']);
-      const opts2 = planCmd2.opts();
-      expect(opts2.worktree).toBe(false);
-      const resolved2 = opts2.worktree ?? getWorktreeDefault();
-      expect(resolved2).toBe(false);
-
-      // State 3: omitted (undefined, falls back to config)
-      const planCmd3 = createPlanCommand();
-      planCmd3.parseOptions([]);
-      const opts3 = planCmd3.opts();
-      expect(opts3.worktree).toBeUndefined();
-      const resolved3 = opts3.worktree ?? getWorktreeDefault();
-      // Should be a boolean (actual value depends on config)
-      expect(typeof resolved3).toBe('boolean');
-    });
-
-    it('should correctly handle all three states (true/false/undefined) in do command', () => {
-      // State 1: --worktree (explicit true)
-      const doCmd1 = createDoCommand();
-      doCmd1.parseOptions(['--worktree']);
-      const opts1 = doCmd1.opts();
-      expect(opts1.worktree).toBe(true);
-      const resolved1 = opts1.worktree ?? getWorktreeDefault();
-      expect(resolved1).toBe(true);
-
-      // State 2: --no-worktree (explicit false)
-      const doCmd2 = createDoCommand();
-      doCmd2.parseOptions(['--no-worktree']);
-      const opts2 = doCmd2.opts();
-      expect(opts2.worktree).toBe(false);
-      const resolved2 = opts2.worktree ?? getWorktreeDefault();
-      expect(resolved2).toBe(false);
-
-      // State 3: omitted (undefined, falls back to config)
-      const doCmd3 = createDoCommand();
-      doCmd3.parseOptions([]);
-      const opts3 = doCmd3.opts();
-      expect(opts3.worktree).toBeUndefined();
-      const resolved3 = opts3.worktree ?? getWorktreeDefault();
-      // Should be a boolean (actual value depends on config)
-      expect(typeof resolved3).toBe('boolean');
-    });
-  });
-
-  describe('Override semantics', () => {
-    it('--no-worktree should override config default (explicit false takes precedence)', () => {
-      const planCommand = createPlanCommand();
-      planCommand.parseOptions(['--no-worktree']);
-      const opts = planCommand.opts();
-      const resolved = opts.worktree ?? getWorktreeDefault();
-
-      expect(opts.worktree).toBe(false); // Flag sets explicit false
-      expect(resolved).toBe(false); // Final result is false (flag takes precedence)
-    });
-
-    it('--worktree should override config default (explicit true takes precedence)', () => {
-      const doCommand = createDoCommand();
-      doCommand.parseOptions(['--worktree']);
-      const opts = doCommand.opts();
-      const resolved = opts.worktree ?? getWorktreeDefault();
-
-      expect(opts.worktree).toBe(true); // Flag sets explicit true
-      expect(resolved).toBe(true); // Final result is true (flag takes precedence)
-    });
-
-    it('omitting flag should fall back to config default', () => {
-      const planCommand = createPlanCommand();
-      planCommand.parseOptions([]);
-      const opts = planCommand.opts();
-      const resolved = opts.worktree ?? getWorktreeDefault();
-
-      expect(opts.worktree).toBeUndefined(); // Flag not set
-      expect(typeof resolved).toBe('boolean'); // Falls back to config (which is a boolean)
-      expect(resolved).toBe(getWorktreeDefault()); // Final result matches config
-    });
-  });
-});