rafcode 2.5.0-0 → 2.5.1-0

package/src/commands/plan.ts

@@ -49,6 +49,7 @@ import {
   removeWorktree,
   computeWorktreeBaseDir,
   pullMainBranch,
+  resolveWorktreeProjectByIdentifier,
 } from '../core/worktree.js';
 
 interface PlanCommandOptions {
@@ -72,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
@@ -317,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) {
@@ -631,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();
@@ -690,54 +698,58 @@ async function runResumeCommand(identifier: string, model?: string): Promise<voi
     process.exit(1);
   }
 
-  // First, try to resolve the project from main repo
+  // Try to resolve the project from worktrees first, then fall back to main repo
+  const repoBasename = getRepoBasename();
   const rafDir = getRafDir();
-  const mainResolution = resolveProjectIdentifierWithDetails(rafDir, identifier);
-
-  if (!mainResolution.path) {
-    if (mainResolution.error === 'ambiguous' && mainResolution.matches) {
-      logger.error(`Ambiguous project name: ${identifier}`);
-      logger.error('Multiple projects match:');
-      for (const match of mainResolution.matches) {
-        logger.error(`  - ${match.folder}`);
+
+  let projectPath: string | undefined;
+  let resumeCwd: string | undefined;
+  let folderName: string | undefined;
+
+  // 1. Try worktree resolution first (if we're in a git repo)
+  if (repoBasename) {
+    const worktreeResolution = resolveWorktreeProjectByIdentifier(repoBasename, identifier);
+
+    if (worktreeResolution) {
+      // Found in worktree - validate and use it
+      const wtValidation = validateWorktree(worktreeResolution.worktreeRoot, '');
+
+      if (wtValidation.isValidWorktree) {
+        folderName = worktreeResolution.folder;
+        const repoRoot = getRepoRoot()!;
+        const rafRelativePath = path.relative(repoRoot, rafDir);
+        projectPath = path.join(worktreeResolution.worktreeRoot, rafRelativePath, folderName);
+        resumeCwd = worktreeResolution.worktreeRoot;
+        logger.info(`Resuming session in worktree: ${resumeCwd}`);
+      } else {
+        logger.warn(`Worktree found but invalid: ${worktreeResolution.worktreeRoot}`);
+        logger.warn('Falling back to main repo resolution.');
+        // Fall through to main repo resolution
       }
-      logger.error('Please specify the project ID or full folder name.');
-    } else {
-      logger.error(`Project not found: ${identifier}`);
     }
-    process.exit(1);
   }
 
-  const projectPath = mainResolution.path;
-  const folderName = path.basename(projectPath);
-
-  // Determine if this is a worktree project by checking if a worktree exists
-  let resumeCwd = projectPath; // Default to main repo project path
-  const repoBasename = getRepoBasename();
-
-  if (repoBasename) {
-    const worktreeBaseDir = computeWorktreeBaseDir(repoBasename);
+  // 2. If not found in worktree (or invalid), try main repo
+  if (!projectPath) {
+    const mainResolution = resolveProjectIdentifierWithDetails(rafDir, identifier);
 
-    // Check if a worktree exists for this project
-    if (fs.existsSync(worktreeBaseDir)) {
-      const entries = fs.readdirSync(worktreeBaseDir, { withFileTypes: true });
-      const worktreeEntry = entries.find(
-        (entry) => entry.isDirectory() && entry.name === folderName
-      );
-
-      if (worktreeEntry) {
-        // Worktree exists - use it as the CWD
-        const worktreePath = path.join(worktreeBaseDir, worktreeEntry.name);
-        const wtValidation = validateWorktree(worktreePath, '');
-        if (wtValidation.isValidWorktree) {
-          resumeCwd = worktreePath;
-          logger.info(`Resuming session in worktree: ${worktreePath}`);
-        } else {
-          logger.warn(`Worktree found but invalid: ${worktreePath}`);
-          logger.warn('Falling back to main repo path.');
+    if (!mainResolution.path) {
+      if (mainResolution.error === 'ambiguous' && mainResolution.matches) {
+        logger.error(`Ambiguous project name: ${identifier}`);
+        logger.error('Multiple projects match:');
+        for (const match of mainResolution.matches) {
+          logger.error(`  - ${match.folder}`);
         }
+        logger.error('Please specify the project ID or full folder name.');
+      } else {
+        logger.error(`Project not found: ${identifier}`);
       }
+      process.exit(1);
     }
+
+    projectPath = mainResolution.path;
+    folderName = path.basename(projectPath);
+    resumeCwd = projectPath; // Use main repo project path as CWD
   }
 
   logger.info(`Project: ${folderName}`);

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/index.ts

@@ -4,7 +4,6 @@ import { Command } from 'commander';
 import { createPlanCommand } from './commands/plan.js';
 import { createDoCommand } from './commands/do.js';
 import { createStatusCommand } from './commands/status.js';
-import { createMigrateCommand } from './commands/migrate.js';
 import { createConfigCommand } from './commands/config.js';
 import { getVersion } from './utils/version.js';
 
@@ -18,7 +17,6 @@ program
 program.addCommand(createPlanCommand());
 program.addCommand(createDoCommand());
 program.addCommand(createStatusCommand());
-program.addCommand(createMigrateCommand());
 program.addCommand(createConfigCommand());
 
 program.parse();

package/src/prompts/amend.ts

@@ -200,7 +200,9 @@ This is rarely needed — prefer using the \`effort\` label so the user's config
 
 After creating all new plan files:
 1. Provide a summary of:
-   - The new tasks you've created
+   - The new tasks you've created, including the effort level for each task. Example format:
+     - Task 02: add-caching (effort: medium)
+     - Task 03: update-docs (effort: low)
    - How they relate to existing tasks
    - Total task count in the project
 2. Display this exit message to the user:

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/prompts/planning.ts

@@ -168,7 +168,10 @@ or for multiple dependencies:
 ### Step 5: Confirm Completion
 
 After creating all plan files:
-1. Provide a summary of the tasks you've created
+1. Provide a summary of the tasks you've created, including the effort level for each task. Example:
+   - Task 01: setup-database (effort: low)
+   - Task 02: implement-auth (effort: medium)
+   - Task 03: refactor-api (effort: high)
 2. Display this exit message to the user:
 
 \`\`\`

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,
@@ -138,11 +138,6 @@ export interface StatusCommandOptions {
   json?: boolean;
 }
 
-export interface MigrateCommandOptions {
-  dryRun?: boolean;
-  worktree?: boolean;
-}
-
 /** Per-model token usage breakdown from stream-json result event. */
 export interface ModelTokenUsage {
   inputTokens: number;

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();