rafcode 2.5.0 → 2.5.1-0

package/src/commands/plan.ts

@@ -73,6 +73,7 @@ export function createPlanCommand(): Command {
     .option('--sonnet', 'Use Sonnet model (shorthand for --model sonnet)')
     .option('-y, --auto', "Skip Claude's permission prompts for file operations")
     .option('-w, --worktree', 'Create a git worktree for isolated planning')
+    .option('--no-worktree', 'Disable worktree mode (overrides config)')
     .option('-r, --resume <identifier>', 'Resume a planning session for an existing project')
     .action(async (projectName: string | undefined, options: PlanCommandOptions) => {
       // Validate and resolve model option
@@ -318,8 +319,12 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
         logger.info(`  - plans/${planFile}`);
       }
 
-      // Commit planning artifacts (input.md and decisions.md)
-      await commitPlanningArtifacts(projectPath, worktreePath ? { cwd: worktreePath } : undefined);
+      // Commit planning artifacts (input.md, decisions.md, and plan files)
+      const planAbsolutePaths = planFiles.map((f) => path.join(plansDir, f));
+      await commitPlanningArtifacts(projectPath, {
+        cwd: worktreePath ?? undefined,
+        additionalFiles: planAbsolutePaths,
+      });
 
       logger.newline();
       if (worktreeMode) {
@@ -632,10 +637,12 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
         logger.info(`  - plans/${planFile}`);
       }
 
-      // Commit planning artifacts (input.md, decisions.md only — plan files committed during execution)
+      // Commit planning artifacts (input.md, decisions.md, and new plan files)
+      const newPlanAbsolutePaths = newPlanFiles.map((f) => path.join(plansDir, f));
       await commitPlanningArtifacts(projectPath, {
         cwd: worktreePath ?? undefined,
         isAmend: true,
+        additionalFiles: newPlanAbsolutePaths,
       });
 
       logger.newline();

package/src/core/git.ts

@@ -227,6 +227,9 @@ export function isFileCommittedInHead(filePath: string): boolean {
  */
 export async function commitPlanningArtifacts(projectPath: string, options?: { cwd?: string; additionalFiles?: string[]; isAmend?: boolean }): Promise<void> {
   const execCwd = options?.cwd;
+  const execOpts = execCwd ? { cwd: execCwd } : {};
+
+  logger.debug(`commitPlanningArtifacts: projectPath=${projectPath}, cwd=${execCwd ?? 'process.cwd()'}, isAmend=${options?.isAmend ?? false}`);
 
   // Check if we're in a git repository
   if (!isGitRepo(execCwd)) {
@@ -268,6 +271,20 @@ export async function commitPlanningArtifacts(projectPath: string, options?: { c
     ? absoluteFiles.map(f => path.relative(execCwd, f))
     : absoluteFiles;
 
+  logger.debug(`commitPlanningArtifacts: staging files: ${filesToStage.join(', ')}`);
+
+  // Check git status before staging to understand the current state
+  try {
+    const preStatus = execSync('git status --porcelain', {
+      encoding: 'utf-8',
+      stdio: 'pipe',
+      ...execOpts,
+    }).trim();
+    logger.debug(`commitPlanningArtifacts: pre-stage git status:\n${preStatus || '(clean)'}`);
+  } catch {
+    logger.debug('commitPlanningArtifacts: could not get pre-stage git status');
+  }
+
   // Stage each file individually so one missing file doesn't block the others
   let stagedCount = 0;
   for (const file of filesToStage) {
@@ -275,7 +292,7 @@ export async function commitPlanningArtifacts(projectPath: string, options?: { c
       execSync(`git add -- "${file}"`, {
         encoding: 'utf-8',
         stdio: 'pipe',
-        ...(execCwd ? { cwd: execCwd } : {}),
+        ...execOpts,
       });
       stagedCount++;
     } catch (error) {
@@ -294,19 +311,21 @@ export async function commitPlanningArtifacts(projectPath: string, options?: { c
     const stagedStatus = execSync('git diff --cached --name-only', {
       encoding: 'utf-8',
       stdio: 'pipe',
-      ...(execCwd ? { cwd: execCwd } : {}),
+      ...execOpts,
     }).trim();
 
     if (!stagedStatus) {
-      logger.debug('No changes to planning artifacts to commit');
+      logger.debug('No changes to planning artifacts to commit (git add succeeded but nothing changed in index)');
       return;
     }
 
+    logger.debug(`commitPlanningArtifacts: staged files: ${stagedStatus}`);
+
     // Commit the staged files
     execSync(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, {
       encoding: 'utf-8',
       stdio: 'pipe',
-      ...(execCwd ? { cwd: execCwd } : {}),
+      ...execOpts,
     });
 
     logger.debug(`Committed planning artifacts: ${commitMessage}`);

package/src/prompts/config-docs.md

@@ -49,8 +49,8 @@ Maps task complexity labels (in plan frontmatter) to Claude models. When a plan
 
 | Key | Default | Description |
 |-----|---------|-------------|
-| `effortMapping.low` | `"haiku"` | Model for low-complexity tasks |
-| `effortMapping.medium` | `"sonnet"` | Model for medium-complexity tasks |
+| `effortMapping.low` | `"sonnet"` | Model for low-complexity tasks |
+| `effortMapping.medium` | `"opus"` | Model for medium-complexity tasks |
 | `effortMapping.high` | `"opus"` | Model for high-complexity tasks |
 
 Values must be a short alias (`"sonnet"`, `"haiku"`, `"opus"`) or a full model ID.
@@ -61,11 +61,11 @@ Example:
 ```json
 {
   "models": { "execute": "sonnet" },
-  "effortMapping": { "low": "haiku", "medium": "sonnet", "high": "opus" }
+  "effortMapping": { "low": "sonnet", "medium": "opus", "high": "opus" }
 }
 ```
-- Task with `effort: low` → haiku (under ceiling)
-- Task with `effort: medium` → sonnet (at ceiling)
+- Task with `effort: low` → sonnet (at ceiling)
+- Task with `effort: medium` → sonnet (capped to ceiling, not opus)
 - Task with `effort: high` → sonnet (capped to ceiling, not opus)
 
 ### `timeout` — Task Timeout
@@ -217,8 +217,8 @@ Uses Sonnet for planning and caps task execution at Sonnet (tasks with `effort:
     "config": "sonnet"
   },
   "effortMapping": {
-    "low": "haiku",
-    "medium": "sonnet",
+    "low": "sonnet",
+    "medium": "opus",
     "high": "opus"
   },
   "timeout": 60,

package/src/types/config.ts

@@ -69,8 +69,8 @@ export const DEFAULT_CONFIG: RafConfig = {
     config: 'sonnet',
   },
   effortMapping: {
-    low: 'haiku',
-    medium: 'sonnet',
+    low: 'sonnet',
+    medium: 'opus',
     high: 'opus',
   },
   timeout: 60,

package/tests/unit/commit-planning-artifacts-worktree.test.ts

@@ -179,6 +179,50 @@ describe('commitPlanningArtifacts - worktree integration', () => {
     expect(committedFiles).not.toContain(`RAF/${projectFolder}/plans/02-new-task.md`);
   });
 
+  it('should commit amend artifacts with plan files as additionalFiles in worktree', async () => {
+    const projectFolder = 'aatest-my-project';
+
+    // Create initial project and commit
+    createInitialProject(repoDir, projectFolder);
+    execSync('git add -A', { cwd: repoDir, stdio: 'pipe' });
+    execSync('git commit -m "Initial plan"', { cwd: repoDir, stdio: 'pipe' });
+
+    // Create worktree
+    worktreePath = createWorktreeForProject(repoDir, projectFolder);
+    const wtProjectPath = path.join(worktreePath, 'RAF', projectFolder);
+
+    // Simulate amend: update files and create new plan
+    fs.writeFileSync(
+      path.join(wtProjectPath, 'input.md'),
+      'original input\n\n---\n\nnew task description'
+    );
+    fs.writeFileSync(
+      path.join(wtProjectPath, 'decisions.md'),
+      '# Decisions\n\n## Q1?\nA1\n\n## Q2?\nA2'
+    );
+    fs.writeFileSync(
+      path.join(wtProjectPath, 'plans', '02-new-task.md'),
+      '# Task: New Task'
+    );
+
+    // Call commitPlanningArtifacts with plan files as additionalFiles (as plan.ts now does)
+    await commitPlanningArtifacts(wtProjectPath, {
+      cwd: worktreePath,
+      isAmend: true,
+      additionalFiles: [path.join(wtProjectPath, 'plans', '02-new-task.md')],
+    });
+
+    // Verify commit was made with Amend prefix
+    const lastMsg = getLastCommitMessage(worktreePath);
+    expect(lastMsg).toMatch(/RAF\[aatest\] Amend: my-project/);
+
+    // Verify all files are in the commit (input, decisions, AND plan files)
+    const committedFiles = getLastCommitFiles(worktreePath);
+    expect(committedFiles).toContain(`RAF/${projectFolder}/input.md`);
+    expect(committedFiles).toContain(`RAF/${projectFolder}/decisions.md`);
+    expect(committedFiles).toContain(`RAF/${projectFolder}/plans/02-new-task.md`);
+  });
+
   it('should commit after worktree recreation from branch', async () => {
     const projectFolder = 'aatest-my-project';
 
@@ -247,6 +291,75 @@ describe('commitPlanningArtifacts - worktree integration', () => {
     expect(committedFiles).not.toContain(`RAF/${projectFolder}/plans/02-new-task.md`);
   });
 
+  it('should commit all artifacts after worktree recreation with additionalFiles', async () => {
+    const projectFolder = 'aatest-my-project';
+
+    // Create initial project, commit, and create initial worktree
+    createInitialProject(repoDir, projectFolder);
+    execSync('git add -A', { cwd: repoDir, stdio: 'pipe' });
+    execSync('git commit -m "Initial plan"', { cwd: repoDir, stdio: 'pipe' });
+
+    // Create worktree
+    const initialWtPath = createWorktreeForProject(repoDir, projectFolder);
+    const initialWtProjectPath = path.join(initialWtPath, 'RAF', projectFolder);
+
+    // Commit something on the worktree branch (simulating initial plan commit + task execution)
+    fs.writeFileSync(
+      path.join(initialWtProjectPath, 'decisions.md'),
+      '# Decisions\n\n## Q1?\nA1\n\n## Q2?\nA2'
+    );
+    execSync('git add -A', { cwd: initialWtPath, stdio: 'pipe' });
+    execSync('git commit -m "Plan commit on branch"', { cwd: initialWtPath, stdio: 'pipe' });
+
+    // Remove the worktree (simulating cleanup after execution)
+    execSync(`git worktree remove "${initialWtPath}" --force`, {
+      cwd: repoDir,
+      stdio: 'pipe',
+    });
+    worktreePaths.splice(worktreePaths.indexOf(initialWtPath), 1);
+
+    // Recreate worktree from existing branch (simulating amend --worktree)
+    const recreatedWtPath = path.join(makeTempDir('raf-wt-recreated-'), projectFolder);
+    execSync(`git worktree add "${recreatedWtPath}" "${projectFolder}"`, {
+      cwd: repoDir,
+      stdio: 'pipe',
+    });
+    worktreePaths.push(recreatedWtPath);
+
+    const recreatedProjectPath = path.join(recreatedWtPath, 'RAF', projectFolder);
+
+    // Simulate amend: update input.md, update decisions.md, create new plan
+    fs.writeFileSync(
+      path.join(recreatedProjectPath, 'input.md'),
+      'original input\n\n---\n\namend task description'
+    );
+    fs.writeFileSync(
+      path.join(recreatedProjectPath, 'decisions.md'),
+      '# Decisions\n\n## Q1?\nA1\n\n## Q2?\nA2\n\n## Q3?\nA3'
+    );
+    fs.writeFileSync(
+      path.join(recreatedProjectPath, 'plans', '02-new-task.md'),
+      '# Task: New Task'
+    );
+
+    // Call commitPlanningArtifacts with plan files as additionalFiles (as plan.ts now does)
+    await commitPlanningArtifacts(recreatedProjectPath, {
+      cwd: recreatedWtPath,
+      isAmend: true,
+      additionalFiles: [path.join(recreatedProjectPath, 'plans', '02-new-task.md')],
+    });
+
+    // Verify commit was made
+    const lastMsg = getLastCommitMessage(recreatedWtPath);
+    expect(lastMsg).toMatch(/RAF\[aatest\] Amend: my-project/);
+
+    // Verify all files are in the commit (including plan files)
+    const committedFiles = getLastCommitFiles(recreatedWtPath);
+    expect(committedFiles).toContain(`RAF/${projectFolder}/input.md`);
+    expect(committedFiles).toContain(`RAF/${projectFolder}/decisions.md`);
+    expect(committedFiles).toContain(`RAF/${projectFolder}/plans/02-new-task.md`);
+  });
+
   it('should work when only some files have changed', async () => {
     const projectFolder = 'aatest-my-project';
 

package/tests/unit/commit-planning-artifacts.test.ts

@@ -130,7 +130,7 @@ describe('commitPlanningArtifacts', () => {
 
     // Should log debug message and not throw
     expect(mockLogger.debug).toHaveBeenCalledWith(
-      'No changes to planning artifacts to commit'
+      'No changes to planning artifacts to commit (git add succeeded but nothing changed in index)'
     );
     expect(mockLogger.warn).not.toHaveBeenCalled();
   });

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

@@ -77,7 +77,7 @@ describe('Config Command', () => {
     });
 
     it('should accept valid config with effortMapping override', () => {
-      const config = { effortMapping: { low: 'haiku', medium: 'sonnet' } };
+      const config = { effortMapping: { low: 'sonnet', medium: 'opus' } };
       expect(() => validateConfig(config)).not.toThrow();
     });
 
@@ -204,7 +204,7 @@ describe('Config Command', () => {
       // 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');
+      expect(DEFAULT_CONFIG.effortMapping.medium).toBe('opus');
     });
 
     it('should be able to read raw file contents even when config is invalid JSON', () => {

package/tests/unit/config.test.ts

@@ -91,7 +91,7 @@ describe('Config', () => {
     it('should accept a full valid config', () => {
       const config = {
         models: { plan: 'opus', execute: 'haiku' },
-        effortMapping: { low: 'haiku', medium: 'sonnet', high: 'opus' },
+        effortMapping: { low: 'sonnet', medium: 'opus', high: 'opus' },
         timeout: 30,
         maxRetries: 5,
         autoCommit: false,
@@ -274,7 +274,7 @@ describe('Config', () => {
 
       const config = resolveConfig(configPath);
       expect(config.effortMapping.medium).toBe('opus');
-      expect(config.effortMapping.low).toBe('haiku'); // default preserved
+      expect(config.effortMapping.low).toBe('sonnet'); // default preserved
       expect(config.effortMapping.high).toBe('opus'); // default preserved
     });
 
@@ -368,7 +368,7 @@ describe('Config', () => {
       fs.writeFileSync(configPath, JSON.stringify({ effortMapping: { high: 'sonnet' } }));
       const config = resolveConfig(configPath);
       expect(config.effortMapping.high).toBe('sonnet');
-      expect(config.effortMapping.low).toBe('haiku'); // default preserved
+      expect(config.effortMapping.low).toBe('sonnet'); // default preserved
     });
 
     it('getCommitFormat returns correct format', () => {
@@ -401,8 +401,8 @@ describe('Config', () => {
     });
 
     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.low).toBe('sonnet');
+      expect(DEFAULT_CONFIG.effortMapping.medium).toBe('opus');
       expect(DEFAULT_CONFIG.effortMapping.high).toBe('opus');
     });
 
@@ -483,9 +483,9 @@ describe('Config', () => {
       expect(DEFAULT_CONFIG.models.prGeneration).toBe('sonnet');
     });
 
-    it('should default effortMapping to haiku/sonnet/opus', () => {
-      expect(DEFAULT_CONFIG.effortMapping.low).toBe('haiku');
-      expect(DEFAULT_CONFIG.effortMapping.medium).toBe('sonnet');
+    it('should default effortMapping to sonnet/opus/opus', () => {
+      expect(DEFAULT_CONFIG.effortMapping.low).toBe('sonnet');
+      expect(DEFAULT_CONFIG.effortMapping.medium).toBe('opus');
       expect(DEFAULT_CONFIG.effortMapping.high).toBe('opus');
     });
 
@@ -596,8 +596,8 @@ describe('Config', () => {
       const config = resolveConfig(configPath);
       expect(config.effortMapping.high).toBe('sonnet');
       // Others should remain at defaults
-      expect(config.effortMapping.low).toBe('haiku');
-      expect(config.effortMapping.medium).toBe('sonnet');
+      expect(config.effortMapping.low).toBe('sonnet');
+      expect(config.effortMapping.medium).toBe('opus');
     });
 
     it('should use custom commit format when configured', () => {
@@ -711,8 +711,8 @@ describe('Config', () => {
       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.low).toBe('sonnet');
+      expect(config.effortMapping.medium).toBe('opus');
       expect(config.effortMapping.high).toBe('opus');
     });
   });
@@ -721,8 +721,8 @@ describe('Config', () => {
     it('should accept valid effortMapping config', () => {
       expect(() => validateConfig({
         effortMapping: {
-          low: 'haiku',
-          medium: 'sonnet',
+          low: 'sonnet',
+          medium: 'opus',
           high: 'opus',
         },
       })).not.toThrow();

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

@@ -0,0 +1,186 @@
+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
+    });
+  });
+});