rafcode 1.3.2 → 2.1.0

package/src/commands/do.ts

@@ -1,5 +1,7 @@
 import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { Command } from 'commander';
+import { select } from '@inquirer/prompts';
 import { ProjectManager } from '../core/project-manager.js';
 import { ClaudeRunner } from '../core/claude-runner.js';
 import { shutdownHandler } from '../core/shutdown-handler.js';
@@ -7,20 +9,21 @@ import { stashChanges, hasUncommittedChanges, isGitRepo, getHeadCommitHash } fro
 import { getExecutionPrompt } from '../prompts/execution.js';
 import { parseOutput, isRetryableFailure } from '../parsers/output-parser.js';
 import { validatePlansExist, resolveModelOption } from '../utils/validation.js';
-import { getRafDir, extractProjectNumber, extractProjectName, extractTaskNameFromPlanFile, resolveProjectIdentifierWithDetails, getOutcomeFilePath } from '../utils/paths.js';
-import { pickPendingProject, getPendingProjects } from '../ui/project-picker.js';
+import { getRafDir, extractProjectNumber, extractProjectName, extractTaskNameFromPlanFile, resolveProjectIdentifierWithDetails, getOutcomeFilePath, parseProjectPrefix } from '../utils/paths.js';
+import { pickPendingProject, getPendingProjects, getPendingWorktreeProjects } from '../ui/project-picker.js';
+import type { PendingProjectInfo } from '../ui/project-picker.js';
 import { logger } from '../utils/logger.js';
 import { getConfig } from '../utils/config.js';
 import { createTaskTimer, formatElapsedTime } from '../utils/timer.js';
 import { createStatusLine } from '../utils/status-line.js';
 import {
-  SYMBOLS,
   formatProjectHeader,
   formatSummary,
   formatTaskProgress,
 } from '../utils/terminal-symbols.js';
 import {
   deriveProjectState,
+  discoverProjects,
   getNextExecutableTask,
   getDerivedStats,
   getDerivedStatsForTasks,
@@ -31,8 +34,29 @@ import {
   type DerivedProjectState,
 } from '../core/state-derivation.js';
 import { analyzeFailure } from '../core/failure-analyzer.js';
+import {
+  getRepoRoot,
+  getRepoBasename,
+  getCurrentBranch,
+  computeWorktreePath,
+  computeWorktreeBaseDir,
+  validateWorktree,
+  listWorktreeProjects,
+  mergeWorktreeBranch,
+  removeWorktree,
+  resolveWorktreeProjectByIdentifier,
+} from '../core/worktree.js';
+import { createPullRequest, prPreflight } from '../core/pull-request.js';
 import type { DoCommandOptions } from '../types/config.js';
 
+/**
+ * Post-execution action chosen by the user before task execution begins.
+ * - 'merge': merge the worktree branch into the original branch
+ * - 'pr': push the branch and create a GitHub PR
+ * - 'leave': do nothing, keep the branch as-is
+ */
+export type PostExecutionAction = 'merge' | 'pr' | 'leave';
+
 /**
  * Format failure history for console output.
  * Shows attempts that failed before eventual success or final failure.
@@ -90,25 +114,28 @@ interface ProjectExecutionResult {
 
 export function createDoCommand(): Command {
   const command = new Command('do')
-    .description('Execute planned tasks for one or more projects')
+    .description('Execute planned tasks for a project')
     .alias('act')
-    .argument('[projects...]', 'Project identifier(s): number (3), name (my-project), or folder (001-my-project)')
+    .argument('[project]', 'Project identifier: ID (00j3k1), name (my-project), or folder (00j3k1-my-project)')
     .option('-t, --timeout <minutes>', 'Timeout per task in minutes', '60')
     .option('-v, --verbose', 'Show full Claude output')
     .option('-d, --debug', 'Save all logs and show debug output')
     .option('-f, --force', 'Re-run all tasks regardless of status')
     .option('-m, --model <name>', 'Claude model to use (sonnet, haiku, opus)')
     .option('--sonnet', 'Use Sonnet model (shorthand for --model sonnet)')
-    .action(async (projects: string[], options: DoCommandOptions) => {
-      await runDoCommand(projects, options);
+    .option('-w, --worktree', 'Execute tasks in a git worktree')
+    .option('-r, --resume <session-id>', 'Resume an interrupted Claude session')
+    .action(async (project: string | undefined, options: DoCommandOptions) => {
+      await runDoCommand(project, options);
     });
 
   return command;
 }
 
-async function runDoCommand(projectIdentifiersArg: string[], options: DoCommandOptions): Promise<void> {
+async function runDoCommand(projectIdentifierArg: string | undefined, options: DoCommandOptions): Promise<void> {
   const rafDir = getRafDir();
-  let projectIdentifiers = projectIdentifiersArg;
+  let projectIdentifier = projectIdentifierArg;
+  let worktreeMode = options.worktree ?? false;
 
   // Validate and resolve model option
   let model: string;
@@ -119,28 +146,71 @@ async function runDoCommand(projectIdentifiersArg: string[], options: DoCommandO
     process.exit(1);
   }
 
-  // Handle empty project list - show interactive picker
-  if (projectIdentifiers.length === 0) {
-    // Check if there are any pending projects
+  // Variables for worktree context (set when --worktree is used)
+  let worktreeRoot: string | undefined;
+  let originalBranch: string | undefined;
+
+  if (worktreeMode) {
+    // Validate git repo
+    const repoRoot = getRepoRoot();
+    if (!repoRoot) {
+      logger.error('--worktree requires a git repository');
+      process.exit(1);
+    }
+    const repoBasename = getRepoBasename()!;
+    const rafRelativePath = path.relative(repoRoot, rafDir);
+
+    // Record original branch before any worktree operations
+    originalBranch = getCurrentBranch() ?? undefined;
+
+    if (!projectIdentifier) {
+      // Auto-discovery flow
+      const selected = await discoverAndPickWorktreeProject(repoBasename, rafDir, rafRelativePath);
+      if (!selected) {
+        process.exit(0);
+      }
+      worktreeRoot = selected.worktreeRoot;
+      projectIdentifier = selected.projectFolder;
+    }
+  }
+
+  // Handle no project identifier (non-worktree mode) - show interactive picker
+  if (!projectIdentifier) {
+    // Discover worktree projects for the current repo (if in a git repo)
+    let worktreeProjects: PendingProjectInfo[] = [];
+    const repoRoot = getRepoRoot();
+    if (repoRoot) {
+      const repoBasename = getRepoBasename()!;
+      const rafRelativePath = path.relative(repoRoot, rafDir);
+      worktreeProjects = getPendingWorktreeProjects(repoBasename, rafRelativePath);
+    }
+
+    // Check if there are any pending projects (local or worktree)
     const pendingProjects = getPendingProjects(rafDir);
 
-    if (pendingProjects.length === 0) {
+    if (pendingProjects.length === 0 && worktreeProjects.length === 0) {
       logger.info('No pending projects found.');
       logger.info("Run 'raf plan' to create a new project.");
       process.exit(0);
     }
 
     try {
-      const selectedProject = await pickPendingProject(rafDir);
+      const selectedProject = await pickPendingProject(rafDir, worktreeProjects);
 
       if (!selectedProject) {
-        // This shouldn't happen since we already checked pendingProjects.length
         logger.info('No pending projects found.');
         process.exit(0);
       }
 
       // Use the selected project
-      projectIdentifiers = [selectedProject];
+      projectIdentifier = selectedProject.folder;
+
+      // If a worktree project was selected, auto-switch to worktree mode
+      if (selectedProject.source === 'worktree' && selectedProject.worktreeRoot) {
+        worktreeMode = true;
+        worktreeRoot = selectedProject.worktreeRoot;
+        originalBranch = getCurrentBranch() ?? undefined;
+      }
     } catch (error) {
       // Handle Ctrl+C (user cancellation)
       if (error instanceof Error && error.message.includes('User force closed')) {
@@ -150,51 +220,135 @@ async function runDoCommand(projectIdentifiersArg: string[], options: DoCommandO
     }
   }
 
-  // Resolve all project identifiers and remove duplicates
-  const resolvedProjects: Array<{ identifier: string; path: string; name: string }> = [];
-  const seenPaths = new Set<string>();
-  const errors: Array<{ identifier: string; error: string }> = [];
-
-  for (const identifier of projectIdentifiers) {
-    const result = resolveProjectIdentifierWithDetails(rafDir, identifier);
-
-    if (!result.path) {
-      if (result.error === 'ambiguous' && result.matches) {
-        const matchList = result.matches
-          .map((m) => `  - ${m.folder}`)
-          .join('\n');
-        errors.push({
-          identifier,
-          error: `Ambiguous project name. Multiple projects match:\n${matchList}\nPlease specify the project ID or full folder name.`,
-        });
+  // Resolve project identifier
+  let resolvedProject: { identifier: string; path: string; name: string } | undefined;
+
+  if (worktreeMode) {
+    // Worktree mode: resolve project inside the worktree
+    const repoRoot = getRepoRoot()!;
+    const repoBasename = getRepoBasename()!;
+    const rafRelativePath = path.relative(repoRoot, rafDir);
+
+    // If worktreeRoot was set by auto-discovery, use it directly
+    if (worktreeRoot) {
+      const wtRafDir = path.join(worktreeRoot, rafRelativePath);
+      const result = resolveProjectIdentifierWithDetails(wtRafDir, projectIdentifier);
+      if (!result.path) {
+        logger.error(`Project not found in worktree: ${projectIdentifier}`);
+        process.exit(1);
+      }
+      const projectName = extractProjectName(result.path) ?? projectIdentifier;
+      resolvedProject = { identifier: projectIdentifier, path: result.path, name: projectName };
+    } else {
+      // Explicit identifier: resolve from main repo to get folder name, then validate worktree
+      const mainResult = resolveProjectIdentifierWithDetails(rafDir, projectIdentifier);
+
+      let projectFolderName: string;
+      if (mainResult.path) {
+        // Found in main repo - use its folder name
+        projectFolderName = path.basename(mainResult.path);
       } else {
-        errors.push({ identifier, error: 'Project not found' });
+        // Not found in main repo - try to find it in worktrees directly
+        // This handles projects that only exist in worktrees
+        const worktreeBaseDir = computeWorktreeBaseDir(repoBasename);
+        if (!fs.existsSync(worktreeBaseDir)) {
+          logger.error(`No worktree found for project "${projectIdentifier}". Did you plan with --worktree?`);
+          process.exit(1);
+        }
+
+        // Search worktrees for the project
+        const wtProjects = listWorktreeProjects(repoBasename);
+        let found = false;
+        for (const wtProjectDir of wtProjects) {
+          const wtPath = computeWorktreePath(repoBasename, wtProjectDir);
+          const wtRafDir = path.join(wtPath, rafRelativePath);
+          if (!fs.existsSync(wtRafDir)) continue;
+
+          const resolution = resolveProjectIdentifierWithDetails(wtRafDir, projectIdentifier);
+          if (resolution.path) {
+            projectFolderName = path.basename(resolution.path);
+            worktreeRoot = wtPath;
+            found = true;
+            break;
+          }
+        }
+
+        if (!found) {
+          logger.error(`No worktree found for project "${projectIdentifier}". Did you plan with --worktree?`);
+          process.exit(1);
+        }
       }
-      continue;
-    }
 
-    const projectPath = result.path;
+      // Compute worktree path if not already set
+      if (!worktreeRoot) {
+        worktreeRoot = computeWorktreePath(repoBasename, projectFolderName!);
+      }
 
-    // Skip duplicates
-    if (seenPaths.has(projectPath)) {
-      logger.info(`Skipping duplicate: ${identifier}`);
-      continue;
+      // Validate the worktree
+      const wtProjectRelPath = path.join(rafRelativePath, projectFolderName!);
+      const validation = validateWorktree(worktreeRoot, wtProjectRelPath);
+
+      if (!validation.exists || !validation.isValidWorktree) {
+        logger.error(`No worktree found for project "${projectIdentifier}". Did you plan with --worktree?`);
+        logger.error(`Expected worktree at: ${worktreeRoot}`);
+        process.exit(1);
+      }
+
+      if (!validation.hasProjectFolder || !validation.hasPlans) {
+        logger.error(`Worktree exists but project content is missing.`);
+        logger.error(`Expected project folder at: ${validation.projectPath ?? path.join(worktreeRoot, wtProjectRelPath)}`);
+        process.exit(1);
+      }
+
+      const projectPath = validation.projectPath!;
+      const projectName = extractProjectName(projectPath) ?? projectIdentifier;
+      resolvedProject = { identifier: projectIdentifier, path: projectPath, name: projectName };
+    }
+  } else {
+    // Standard mode: check worktrees first (worktree takes priority), then main repo
+    const repoRoot = getRepoRoot();
+    const repoBasename = repoRoot ? getRepoBasename() : null;
+
+    // Try worktree resolution first (preferred when project exists in both)
+    if (repoBasename) {
+      const wtResolution = resolveWorktreeProjectByIdentifier(repoBasename, projectIdentifier);
+      if (wtResolution) {
+        const rafRelativePath = path.relative(repoRoot!, rafDir);
+        const wtRafDir = path.join(wtResolution.worktreeRoot, rafRelativePath);
+        const wtProjectPath = path.join(wtRafDir, wtResolution.folder);
+
+        if (fs.existsSync(wtProjectPath)) {
+          // Auto-switch to worktree mode
+          worktreeMode = true;
+          worktreeRoot = wtResolution.worktreeRoot;
+          originalBranch = getCurrentBranch() ?? undefined;
+
+          const projectName = extractProjectName(wtResolution.folder) ?? projectIdentifier;
+          resolvedProject = { identifier: projectIdentifier, path: wtProjectPath, name: projectName };
+        }
+      }
     }
 
-    seenPaths.add(projectPath);
-    const projectName = extractProjectName(projectPath) ?? identifier;
-    resolvedProjects.push({ identifier, path: projectPath, name: projectName });
-  }
+    // Fall back to main repo if worktree didn't match
+    if (!resolvedProject) {
+      const result = resolveProjectIdentifierWithDetails(rafDir, projectIdentifier);
 
-  // Report resolution errors
-  for (const { identifier, error } of errors) {
-    logger.error(`${identifier}: ${error}`);
-  }
+      if (!result.path) {
+        if (result.error === 'ambiguous' && result.matches) {
+          const matchList = result.matches
+            .map((m) => `  - ${m.folder}`)
+            .join('\n');
+          logger.error(`${projectIdentifier}: Ambiguous project name. Multiple projects match:\n${matchList}\nPlease specify the project ID or full folder name.`);
+        } else {
+          logger.error(`${projectIdentifier}: Project not found`);
+        }
+        logger.info("Run 'raf status' to see available projects.");
+        process.exit(1);
+      }
 
-  if (resolvedProjects.length === 0) {
-    logger.error('No valid projects to execute.');
-    logger.info("Run 'raf status' to see available projects.");
-    process.exit(1);
+      const projectName = extractProjectName(result.path) ?? projectIdentifier;
+      resolvedProject = { identifier: projectIdentifier, path: result.path, name: projectName };
+    }
   }
 
   // Get configuration
@@ -203,72 +357,297 @@ async function runDoCommand(projectIdentifiersArg: string[], options: DoCommandO
   const verbose = options.verbose ?? false;
   const debug = options.debug ?? false;
   const force = options.force ?? false;
+  const resumeSessionId = options.resume;
   const maxRetries = config.maxRetries;
   const autoCommit = config.autoCommit;
 
   // Configure logger
   logger.configure({ verbose, debug });
 
-  // Log Claude model name once (verbose mode only for multi-project)
-  if (verbose && model && resolvedProjects.length > 1) {
-    logger.info(`Using model: ${model}`);
-    logger.newline();
+  // Show post-execution picker before task execution (worktree mode only)
+  let postAction: PostExecutionAction = 'leave';
+  if (worktreeMode && worktreeRoot) {
+    try {
+      postAction = await pickPostExecutionAction(worktreeRoot);
+    } catch (error) {
+      // Handle Ctrl+C (user cancellation)
+      if (error instanceof Error && error.message.includes('User force closed')) {
+        process.exit(0);
+      }
+      throw error;
+    }
   }
 
-  // Execute projects
-  const results: ProjectExecutionResult[] = [];
-  const isMultiProject = resolvedProjects.length > 1;
+  // Execute project
+  let result: ProjectExecutionResult;
 
-  for (const [i, project] of resolvedProjects.entries()) {
-    if (isMultiProject && verbose) {
-      logger.info(`=== Project ${i + 1}/${resolvedProjects.length}: ${project.name} ===`);
-      logger.newline();
+  try {
+    result = await executeSingleProject(
+      resolvedProject.path,
+      resolvedProject.name,
+      {
+        timeout,
+        verbose,
+        debug,
+        force,
+        maxRetries,
+        autoCommit,
+        showModel: true,
+        model,
+        worktreeCwd: worktreeRoot,
+        resumeSessionId,
+      }
+    );
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error(`Project ${resolvedProject.name} failed: ${errorMessage}`);
+    process.exit(1);
+  }
+
+  // Execute post-execution action based on picker choice
+  if (worktreeMode && worktreeRoot) {
+    const worktreeBranch = path.basename(worktreeRoot);
+
+    if (result.success) {
+      await executePostAction(postAction, worktreeRoot, worktreeBranch, originalBranch, resolvedProject.path);
+    } else {
+      if (postAction !== 'leave') {
+        logger.newline();
+        logger.info(`Skipping post-execution action — project has failures. Branch "${worktreeBranch}" is available for inspection.`);
+      }
     }
+  }
 
-    try {
-      const result = await executeSingleProject(
-        project.path,
-        project.name,
-        {
-          timeout,
-          verbose,
-          debug,
-          force,
-          maxRetries,
-          autoCommit,
-          showModel: !isMultiProject, // Only show model for single project
-          model,
-        }
-      );
-      results.push(result);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      results.push({
-        projectName: project.name,
-        projectPath: project.path,
-        success: false,
-        tasksCompleted: 0,
-        totalTasks: 0,
-        error: errorMessage,
-      });
-      logger.error(`Project ${project.name} failed: ${errorMessage}`);
+  // Exit with appropriate code
+  if (!result.success) {
+    process.exit(1);
+  }
+}
+
+/**
+ * Show an interactive picker for the post-execution action in worktree mode.
+ * Presented before task execution so the user declares intent upfront.
+ *
+ * If "Create PR" is chosen, runs preflight checks immediately. If preflight fails,
+ * warns the user and falls back to re-prompting.
+ */
+export async function pickPostExecutionAction(worktreeRoot: string): Promise<PostExecutionAction> {
+  const worktreeBranch = path.basename(worktreeRoot);
+
+  const chosen = await select<PostExecutionAction>({
+    message: `After tasks complete, what should happen with branch "${worktreeBranch}"?`,
+    choices: [
+      { name: 'Merge into current branch', value: 'merge' as const },
+      { name: 'Create a GitHub PR', value: 'pr' as const },
+      { name: 'Leave branch as-is', value: 'leave' as const },
+    ],
+  });
+
+  // Early preflight check for PR option
+  if (chosen === 'pr') {
+    const preflight = prPreflight(worktreeBranch, worktreeRoot);
+    if (!preflight.ready) {
+      logger.warn(`PR preflight failed: ${preflight.error}`);
+      logger.warn('Falling back to "Leave branch" — you can create a PR manually later.');
+      return 'leave';
+    }
+  }
+
+  return chosen;
+}
+
+/**
+ * Execute the chosen post-execution action.
+ * Called after all tasks succeed.
+ */
+async function executePostAction(
+  action: PostExecutionAction,
+  worktreeRoot: string,
+  worktreeBranch: string,
+  originalBranch: string | undefined,
+  projectPath: string,
+): Promise<void> {
+  switch (action) {
+    case 'merge': {
+      // Clean up worktree before merge (merge uses branch, not directory)
+      const cleanupResult = removeWorktree(worktreeRoot);
+      if (cleanupResult.success) {
+        logger.info(`Cleaned up worktree: ${worktreeRoot}`);
+      } else {
+        logger.warn(`Could not clean up worktree: ${cleanupResult.error}`);
+      }
+
+      if (!originalBranch) {
+        logger.warn('Could not determine original branch for merge.');
+        return;
+      }
+
+      logger.newline();
+      logger.info(`Merging branch "${worktreeBranch}" into "${originalBranch}"...`);
+
+      const mergeResult = mergeWorktreeBranch(worktreeBranch, originalBranch);
+
+      if (mergeResult.success) {
+        const mergeType = mergeResult.fastForward ? 'fast-forward' : 'merge commit';
+        logger.success(`Merged "${worktreeBranch}" into "${originalBranch}" (${mergeType})`);
+      } else {
+        logger.warn(`Could not auto-merge: ${mergeResult.error}`);
+        logger.warn(`You can merge manually: git merge ${worktreeBranch}`);
+      }
+      break;
     }
 
-    if (isMultiProject && i < resolvedProjects.length - 1) {
+    case 'pr': {
       logger.newline();
+      logger.info(`Creating PR for branch "${worktreeBranch}"...`);
+
+      const prResult = await createPullRequest(worktreeBranch, projectPath, { cwd: worktreeRoot });
+
+      if (prResult.success) {
+        logger.success(`PR created: ${prResult.prUrl}`);
+      } else {
+        logger.warn(`Could not create PR: ${prResult.error}`);
+        logger.warn(`Branch "${worktreeBranch}" has been pushed. You can create a PR manually.`);
+      }
+
+      // Clean up worktree directory (branch is preserved)
+      const prCleanupResult = removeWorktree(worktreeRoot);
+      if (prCleanupResult.success) {
+        logger.info(`Cleaned up worktree: ${worktreeRoot}`);
+      } else {
+        logger.warn(`Could not clean up worktree: ${prCleanupResult.error}`);
+      }
+      break;
     }
-  }
 
-  // Show multi-project summary
-  if (isMultiProject) {
-    printMultiProjectSummary(results, verbose);
+    case 'leave': {
+      // Clean up worktree directory (branch is preserved)
+      const cleanupResult = removeWorktree(worktreeRoot);
+      if (cleanupResult.success) {
+        logger.info(`Cleaned up worktree: ${worktreeRoot}`);
+      } else {
+        logger.warn(`Could not clean up worktree: ${cleanupResult.error}`);
+      }
+      break;
+    }
   }
+}
 
-  // Exit with appropriate code
-  const anyFailed = results.some((r) => !r.success);
-  if (anyFailed) {
+/**
+ * Auto-discovery flow for `raf do --worktree` without a project identifier.
+ * Lists worktree projects, finds latest completed main-tree project, filters,
+ * and shows an interactive picker.
+ *
+ * @returns Selected project info or null if cancelled/no projects
+ */
+async function discoverAndPickWorktreeProject(
+  repoBasename: string,
+  rafDir: string,
+  rafRelativePath: string,
+): Promise<{ worktreeRoot: string; projectFolder: string } | null> {
+  // List all worktree projects for this repo
+  const wtProjects = listWorktreeProjects(repoBasename);
+
+  if (wtProjects.length === 0) {
+    logger.error('No worktree projects found. Did you plan with --worktree?');
     process.exit(1);
   }
+
+  // Find the highest-numbered completed project in the MAIN tree
+  const mainProjects = discoverProjects(rafDir);
+  let highestCompletedNumber = 0;
+
+  for (const project of mainProjects) {
+    const state = deriveProjectState(project.path);
+    if (isProjectComplete(state) && state.tasks.length > 0) {
+      if (project.number > highestCompletedNumber) {
+        highestCompletedNumber = project.number;
+      }
+    }
+  }
+
+  // Filter threshold: highest completed - 3 (or 0 if none completed)
+  const threshold = highestCompletedNumber > 3 ? highestCompletedNumber - 3 : 0;
+
+  // Filter worktree projects by number threshold and completion status
+  const uncompletedProjects: Array<{
+    folder: string;
+    worktreeRoot: string;
+    projectPath: string;
+    completedTasks: number;
+    totalTasks: number;
+    projectNumber: number;
+  }> = [];
+
+  for (const wtProjectDir of wtProjects) {
+    // Extract project number from the worktree directory name
+    const numPrefix = extractProjectNumber(wtProjectDir);
+    if (!numPrefix) continue;
+    const projectNumber = parseProjectPrefix(numPrefix);
+    if (projectNumber === null) continue;
+
+    // Apply threshold filter
+    if (projectNumber < threshold) continue;
+
+    // Check if this worktree has a valid project
+    const wtPath = computeWorktreePath(repoBasename, wtProjectDir);
+    const wtProjectPath = path.join(wtPath, rafRelativePath, wtProjectDir);
+
+    if (!fs.existsSync(wtProjectPath)) continue;
+
+    // Derive project state from worktree
+    const state = deriveProjectState(wtProjectPath);
+    if (state.tasks.length === 0) continue;
+
+    // Keep only uncompleted projects
+    if (isProjectComplete(state)) continue;
+
+    const stats = getDerivedStats(state);
+    uncompletedProjects.push({
+      folder: wtProjectDir,
+      worktreeRoot: wtPath,
+      projectPath: wtProjectPath,
+      completedTasks: stats.completed,
+      totalTasks: stats.total,
+      projectNumber,
+    });
+  }
+
+  if (uncompletedProjects.length === 0) {
+    logger.info('All worktree projects are completed.');
+    return null;
+  }
+
+  // Sort by project number
+  uncompletedProjects.sort((a, b) => a.projectNumber - b.projectNumber);
+
+  // Show interactive picker (even if only one project)
+  const choices = uncompletedProjects.map((p) => {
+    const name = extractProjectName(p.folder) ?? p.folder;
+    const numPrefix = extractProjectNumber(p.folder) ?? '';
+    return {
+      name: `${numPrefix} ${name} (${p.completedTasks}/${p.totalTasks} tasks)`,
+      value: p,
+    };
+  });
+
+  try {
+    const selected = await select({
+      message: 'Select a worktree project to execute:',
+      choices,
+    });
+
+    return {
+      worktreeRoot: selected.worktreeRoot,
+      projectFolder: selected.folder,
+    };
+  } catch (error) {
+    // Handle Ctrl+C (user cancellation)
+    if (error instanceof Error && error.message.includes('User force closed')) {
+      return null;
+    }
+    throw error;
+  }
 }
 
 interface SingleProjectOptions {
@@ -280,6 +659,10 @@ interface SingleProjectOptions {
   autoCommit: boolean;
   showModel: boolean;
   model: string;
+  /** Worktree root directory. When set, Claude runs with cwd in the worktree. */
+  worktreeCwd?: string;
+  /** Session ID to resume an interrupted Claude session. Only applies to the first pending task. */
+  resumeSessionId?: string;
 }
 
 async function executeSingleProject(
@@ -287,7 +670,8 @@ async function executeSingleProject(
   projectName: string,
   options: SingleProjectOptions
 ): Promise<ProjectExecutionResult> {
-  const { timeout, verbose, debug, force, maxRetries, autoCommit, showModel, model } = options;
+  const { timeout, verbose, debug, force, maxRetries, autoCommit, showModel, model, worktreeCwd, resumeSessionId } = options;
+  let activeResumeSessionId = resumeSessionId;
 
   if (!validatePlansExist(projectPath)) {
     return {
@@ -484,13 +868,17 @@ async function executeSingleProject(
       logger.setContext(taskContext);
 
       // Log task execution status
-      if (task.status === 'failed') {
+      if (activeResumeSessionId) {
+        logger.info(`Resuming task ${taskLabel} with session ${activeResumeSessionId}`);
+      } else if (task.status === 'failed') {
         logger.info(`Retrying task ${taskLabel} (previously failed)...`);
       } else if (task.status === 'completed' && force) {
         logger.info(`Re-running task ${taskLabel} (force mode)...`);
       } else {
         logger.info(`Executing task ${taskLabel}...`);
       }
+    } else if (activeResumeSessionId) {
+      logger.info(`Resuming task ${task.id} with session ${activeResumeSessionId}`);
     }
 
     // Get previous outcomes for context
@@ -554,17 +942,23 @@ async function executeSingleProject(
       });
 
       // Capture HEAD hash before execution for commit verification
-      const preExecutionHead = isGitRepo() ? getHeadCommitHash() : null;
+      const preExecutionHead = isGitRepo(worktreeCwd) ? getHeadCommitHash(worktreeCwd) : null;
       const commitContext = preExecutionHead ? {
         preExecutionHead,
         expectedPrefix: `RAF[${projectNumber}:${task.id}]`,
         outcomeFilePath,
       } : undefined;
 
-      // Run Claude
-      const result = verbose
-        ? await claudeRunner.runVerbose(prompt, { timeout, outcomeFilePath, commitContext })
-        : await claudeRunner.run(prompt, { timeout, outcomeFilePath, commitContext });
+      // Run Claude (use worktree root as cwd if in worktree mode)
+      let result;
+      if (activeResumeSessionId && attempts === 1) {
+        // Resume mode: use --resume flag instead of normal prompt execution
+        result = await claudeRunner.runResume(activeResumeSessionId, { timeout, outcomeFilePath, commitContext, cwd: worktreeCwd, effortLevel: 'medium' });
+      } else {
+        result = verbose
+          ? await claudeRunner.runVerbose(prompt, { timeout, outcomeFilePath, commitContext, cwd: worktreeCwd, effortLevel: 'medium' })
+          : await claudeRunner.run(prompt, { timeout, outcomeFilePath, commitContext, cwd: worktreeCwd, effortLevel: 'medium' });
+      }
 
       lastOutput = result.output;
 
@@ -685,10 +1079,10 @@ Task completed. No detailed report provided.
     } else {
       // Stash any uncommitted changes on complete failure
       let stashName: string | undefined;
-      if (hasUncommittedChanges()) {
+      if (hasUncommittedChanges(worktreeCwd)) {
         const projectNum = extractProjectNumber(projectPath) ?? '000';
         stashName = `raf-${projectNum}-task-${task.id}-failed`;
-        const stashed = stashChanges(stashName);
+        const stashed = stashChanges(stashName, worktreeCwd);
         if (verbose && stashed) {
           logger.info(`  Changes for task ${taskLabel} stashed as: ${stashName}`);
         }
@@ -726,6 +1120,9 @@ ${stashName ? `- Stash: ${stashName}` : ''}
       logger.newline();
     }
 
+    // Clear resume flag after first task — subsequent tasks use normal execution
+    activeResumeSessionId = undefined;
+
     // Clear context before next task
     logger.clearContext();
 
@@ -832,34 +1229,3 @@ ${stashName ? `- Stash: ${stashName}` : ''}
   };
 }
 
-function printMultiProjectSummary(results: ProjectExecutionResult[], verbose: boolean): void {
-  logger.newline();
-
-  if (verbose) {
-    logger.info('=== Multi-Project Summary ===');
-    logger.newline();
-
-    for (const result of results) {
-      const statusSymbol = result.success ? SYMBOLS.completed : SYMBOLS.failed;
-      const statusText = result.success
-        ? `Completed (${result.tasksCompleted}/${result.totalTasks} tasks)`
-        : result.error
-          ? `Error: ${result.error}`
-          : `Failed (${result.tasksCompleted}/${result.totalTasks} tasks)`;
-
-      logger.info(`${statusSymbol} ${result.projectName}: ${statusText}`);
-    }
-
-    const completed = results.filter((r) => r.success).length;
-    const failed = results.length - completed;
-
-    logger.newline();
-    logger.info(`Total: ${completed} completed, ${failed} failed`);
-  } else {
-    // Minimal multi-project summary: just show each project result
-    for (const result of results) {
-      const symbol = result.success ? SYMBOLS.completed : SYMBOLS.failed;
-      logger.info(`${symbol} ${result.projectName}`);
-    }
-  }
-}