rafcode 1.3.2 → 2.1.0

package/dist/commands/do.js

@@ -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,15 +9,17 @@ 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 { 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, getNextExecutableTask, getDerivedStats, getDerivedStatsForTasks, isProjectComplete, hasProjectFailed, parseOutcomeStatus, } from '../core/state-derivation.js';
+import { formatProjectHeader, formatSummary, formatTaskProgress, } from '../utils/terminal-symbols.js';
+import { deriveProjectState, discoverProjects, getNextExecutableTask, getDerivedStats, getDerivedStatsForTasks, isProjectComplete, hasProjectFailed, parseOutcomeStatus, } 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';
 /**
  * Format failure history for console output.
  * Shows attempts that failed before eventual success or final failure.
@@ -38,23 +42,26 @@ export function formatRetryHistoryForConsole(taskId, taskName, failureHistory, f
 }
 export function createDoCommand() {
     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, options) => {
-        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, options) => {
+        await runDoCommand(project, options);
     });
     return command;
 }
-async function runDoCommand(projectIdentifiersArg, options) {
+async function runDoCommand(projectIdentifierArg, options) {
     const rafDir = getRafDir();
-    let projectIdentifiers = projectIdentifiersArg;
+    let projectIdentifier = projectIdentifierArg;
+    let worktreeMode = options.worktree ?? false;
     // Validate and resolve model option
     let model;
     try {
@@ -64,24 +71,61 @@ async function runDoCommand(projectIdentifiersArg, options) {
         logger.error(error.message);
         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;
+    let originalBranch;
+    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 = [];
+        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)
@@ -91,45 +135,123 @@ async function runDoCommand(projectIdentifiersArg, options) {
             throw error;
         }
     }
-    // Resolve all project identifiers and remove duplicates
-    const resolvedProjects = [];
-    const seenPaths = new Set();
-    const errors = [];
-    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;
+    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;
+            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;
-        // Skip duplicates
-        if (seenPaths.has(projectPath)) {
-            logger.info(`Skipping duplicate: ${identifier}`);
-            continue;
+            // Compute worktree path if not already set
+            if (!worktreeRoot) {
+                worktreeRoot = computeWorktreePath(repoBasename, projectFolderName);
+            }
+            // 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 };
         }
-        seenPaths.add(projectPath);
-        const projectName = extractProjectName(projectPath) ?? identifier;
-        resolvedProjects.push({ identifier, path: projectPath, name: projectName });
     }
-    // Report resolution errors
-    for (const { identifier, error } of errors) {
-        logger.error(`${identifier}: ${error}`);
-    }
-    if (resolvedProjects.length === 0) {
-        logger.error('No valid projects to execute.');
-        logger.info("Run 'raf status' to see available projects.");
-        process.exit(1);
+    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 };
+                }
+            }
+        }
+        // Fall back to main repo if worktree didn't match
+        if (!resolvedProject) {
+            const result = resolveProjectIdentifierWithDetails(rafDir, projectIdentifier);
+            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);
+            }
+            const projectName = extractProjectName(result.path) ?? projectIdentifier;
+            resolvedProject = { identifier: projectIdentifier, path: result.path, name: projectName };
+        }
     }
     // Get configuration
     const config = getConfig();
@@ -137,64 +259,256 @@ async function runDoCommand(projectIdentifiersArg, options) {
     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();
-    }
-    // Execute projects
-    const results = [];
-    const isMultiProject = resolvedProjects.length > 1;
-    for (const [i, project] of resolvedProjects.entries()) {
-        if (isMultiProject && verbose) {
-            logger.info(`=== Project ${i + 1}/${resolvedProjects.length}: ${project.name} ===`);
-            logger.newline();
-        }
+    // Show post-execution picker before task execution (worktree mode only)
+    let postAction = 'leave';
+    if (worktreeMode && worktreeRoot) {
         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);
+            postAction = await pickPostExecutionAction(worktreeRoot);
         }
         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}`);
-        }
-        if (isMultiProject && i < resolvedProjects.length - 1) {
-            logger.newline();
+            // Handle Ctrl+C (user cancellation)
+            if (error instanceof Error && error.message.includes('User force closed')) {
+                process.exit(0);
+            }
+            throw error;
         }
     }
-    // Show multi-project summary
-    if (isMultiProject) {
-        printMultiProjectSummary(results, verbose);
+    // Execute project
+    let result;
+    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.`);
+            }
+        }
     }
     // Exit with appropriate code
-    const anyFailed = results.some((r) => !r.success);
-    if (anyFailed) {
+    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) {
+    const worktreeBranch = path.basename(worktreeRoot);
+    const chosen = await select({
+        message: `After tasks complete, what should happen with branch "${worktreeBranch}"?`,
+        choices: [
+            { name: 'Merge into current branch', value: 'merge' },
+            { name: 'Create a GitHub PR', value: 'pr' },
+            { name: 'Leave branch as-is', value: 'leave' },
+        ],
+    });
+    // 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, worktreeRoot, worktreeBranch, originalBranch, projectPath) {
+    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;
+        }
+        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;
+        }
+        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;
+        }
+    }
+}
+/**
+ * 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, rafDir, rafRelativePath) {
+    // 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 = [];
+    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;
+    }
 }
 async function executeSingleProject(projectPath, projectName, options) {
-    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 {
             projectName,
@@ -365,7 +679,10 @@ async function executeSingleProject(projectPath, projectName, options) {
             const taskContext = `[Task ${taskNumber}/${totalTasks}: ${displayName}]`;
             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) {
@@ -375,6 +692,9 @@ async function executeSingleProject(projectPath, projectName, options) {
                 logger.info(`Executing task ${taskLabel}...`);
             }
         }
+        else if (activeResumeSessionId) {
+            logger.info(`Resuming task ${task.id} with session ${activeResumeSessionId}`);
+        }
         // Get previous outcomes for context
         const previousOutcomes = projectManager.readOutcomes(projectPath);
         // Get dependency outcomes - filter to only include outcomes for tasks this task depends on
@@ -426,16 +746,23 @@ async function executeSingleProject(projectPath, projectName, options) {
                 dependencyOutcomes,
             });
             // 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;
             // Parse result
             const parsed = parseOutput(result.output);
@@ -552,10 +879,10 @@ Task completed. No detailed report provided.
         else {
             // Stash any uncommitted changes on complete failure
             let stashName;
-            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}`);
                 }
@@ -589,6 +916,8 @@ ${stashName ? `- Stash: ${stashName}` : ''}
         if (verbose) {
             logger.newline();
         }
+        // Clear resume flag after first task — subsequent tasks use normal execution
+        activeResumeSessionId = undefined;
         // Clear context before next task
         logger.clearContext();
         // Re-derive state to get updated task statuses
@@ -667,31 +996,4 @@ ${stashName ? `- Stash: ${stashName}` : ''}
         retryHistory: projectRetryHistory,
     };
 }
-function printMultiProjectSummary(results, verbose) {
-    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}`);
-        }
-    }
-}
 //# sourceMappingURL=do.js.map