create-claude-workspace 2.3.11 → 2.3.13

package/dist/scheduler/loop.mjs

@@ -8,7 +8,7 @@ import { fetchOpenIssues, issueToTask, updateIssueStatus } from './tasks/issue-s
 import { buildGraph, getParallelBatches, isPhaseComplete, getNextPhase, isProjectComplete } from './tasks/queue.mjs';
 import { writeState, appendEvent, createEvent, rotateLog } from './state/state.mjs';
 import { recordSession, getSession, clearSession } from './state/session.mjs';
-import { createWorktree, commitInWorktree, getChangedFiles, cleanupWorktree, mergeToMain, syncMain, pushWorktree, forcePushWorktree, rebaseOnMain, cleanMainForMerge, popStash, getMainBranch, listWorktrees, listOrphanedWorktrees, isBranchMerged, getCurrentBranch, hasUncommittedChanges, abortMerge, deleteBranchRemote, } from './git/manager.mjs';
+import { createWorktree, commitInWorktree, getChangedFiles, cleanupWorktree, mergeToMain, syncMain, pushWorktree, forcePushWorktree, rebaseOnMain, cleanMainForMerge, popStash, getMainBranch, listWorktrees, listOrphanedWorktrees, isBranchMerged, getCurrentBranch, hasUncommittedChanges, deleteBranchRemote, } from './git/manager.mjs';
 import { createPR, getPRStatus, getPRComments, mergePR } from './git/pr-manager.mjs';
 import { scanAgents } from './agents/health-checker.mjs';
 import { detectCIPlatform, fetchFailureLogs } from './git/ci-watcher.mjs';
@@ -193,9 +193,72 @@ export async function runIteration(deps) {
     if (queued > 0) {
         logger.info(`Starting ${tasksToRun.length} tasks, ${queued} queued (waiting for workers)`);
     }
-    // Process each task through the pipeline
+    // Process recovered pipelines first (from recovery phase)
     let workDone = false;
+    const recoveredIds = Object.keys(state.pipelines).filter(id => {
+        const p = state.pipelines[id];
+        return p.workerId === -1 && p.step !== 'done' && p.step !== 'failed';
+    });
+    for (const taskId of recoveredIds) {
+        const slot = pool.idleSlot();
+        if (!slot)
+            break;
+        const pipeline = state.pipelines[taskId];
+        pipeline.workerId = slot.id;
+        // Find matching task from loaded tasks, or create a minimal one
+        let task = tasks.find(t => t.id === taskId);
+        if (!task) {
+            const issueNum = extractIssueNumber(taskId);
+            task = {
+                id: taskId,
+                title: `Recovered: ${taskId}`,
+                phase: state.currentPhase,
+                type: 'fullstack',
+                complexity: 'M',
+                dependsOn: [],
+                issueMarker: taskId,
+                kitUpgrade: false,
+                lineNumber: 0,
+                status: 'in-progress',
+                changelog: 'changed',
+            };
+        }
+        logger.info(`[${taskId}] Resuming recovered pipeline at step "${pipeline.step}"`);
+        try {
+            const success = await runTaskPipeline(task, slot.id, agents, deps);
+            workDone = true;
+            if (success) {
+                task.status = 'done';
+                state.completedTasks.push(task.id);
+                if (state.taskMode === 'platform') {
+                    const platform = detectCIPlatform(projectDir);
+                    if (platform !== 'none') {
+                        const issueNum = extractIssueNumber(task.issueMarker);
+                        if (issueNum)
+                            updateIssueStatus(projectDir, platform, issueNum, 'done');
+                    }
+                }
+                appendEvent(projectDir, createEvent('task_completed', { taskId: task.id }));
+            }
+            else {
+                task.status = 'skipped';
+                state.skippedTasks.push(task.id);
+                appendEvent(projectDir, createEvent('task_skipped', { taskId: task.id }));
+            }
+        }
+        catch (err) {
+            logger.error(`Recovered task ${taskId} failed: ${err.message}`);
+            state.skippedTasks.push(taskId);
+        }
+        writeState(projectDir, state);
+    }
+    // Process new tasks through the pipeline
     for (const task of tasksToRun) {
+        // Skip if already handled as recovered pipeline
+        if (state.pipelines[task.id])
+            continue;
+        if (state.completedTasks.includes(task.id) || state.skippedTasks.includes(task.id))
+            continue;
         const slot = pool.idleSlot();
         if (!slot)
             break;
@@ -246,12 +309,17 @@ export async function runIteration(deps) {
 async function runTaskPipeline(task, workerId, agents, deps) {
     const { pool, orchestrator, state, opts, logger, onMessage, onSpawnStart, onSpawnEnd } = deps;
     const projectDir = opts.projectDir;
-    // Create worktree
-    const slug = taskToSlug(task);
-    const worktreePath = createWorktree(projectDir, slug);
-    logger.info(`[${task.id}] Worktree created: ${slug}`);
-    // Initialize pipeline state
-    const pipeline = {
+    // Check for existing pipeline (recovered from previous run)
+    const existing = state.pipelines[task.id];
+    const resumeStep = existing?.step;
+    // Create worktree (returns existing path if already exists)
+    const slug = existing ? getCurrentBranch(existing.worktreePath) : taskToSlug(task);
+    const worktreePath = existing?.worktreePath ?? createWorktree(projectDir, taskToSlug(task));
+    if (!existing) {
+        logger.info(`[${task.id}] Worktree created: ${taskToSlug(task)}`);
+    }
+    // Initialize or reuse pipeline state
+    const pipeline = existing ?? {
         taskId: task.id,
         workerId,
         worktreePath,
@@ -266,149 +334,181 @@ async function runTaskPipeline(task, workerId, agents, deps) {
         assignedAgent: null,
         prState: null,
     };
+    pipeline.workerId = workerId;
     state.pipelines[task.id] = pipeline;
+    // Determine which steps to skip (for resumed pipelines)
+    const skipTo = resumeStep ?? 'plan';
+    const stepOrder = ['plan', 'implement', 'test', 'review', 'rework', 'commit', 'pr-create', 'pr-watch', 'merge'];
+    const skipToIndex = stepOrder.indexOf(skipTo);
+    const shouldSkip = (step) => stepOrder.indexOf(step) < skipToIndex;
     try {
         // Route task to agent
-        const routing = await orchestrator.routeTask(task, 'plan', agents);
+        const routing = await orchestrator.routeTask(task, shouldSkip('plan') ? skipTo : 'plan', agents);
         pipeline.assignedAgent = routing.agent;
-        if (routing.create) {
-            // Auto-create new agent
+        if (routing.create && !shouldSkip('plan')) {
             await createAgentFile(projectDir, routing.create);
             pipeline.assignedAgent = routing.create.name;
             appendEvent(projectDir, createEvent('agent_created', { agentType: routing.create.name }));
         }
-        // STEP 1: Plan
-        pipeline.step = 'plan';
-        appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'plan' }));
-        const planResult = await spawnAgent(pool, workerId, {
-            agent: pipeline.assignedAgent ?? undefined,
-            cwd: worktreePath,
-            prompt: buildPlanPrompt({ task, worktreePath, projectDir }),
-            model: getAgentModel(pipeline.assignedAgent, agents, task),
-        }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
-        if (!planResult.success) {
-            logger.error(`[${task.id}] Planning failed: ${planResult.error}`);
-            return false;
+        if (shouldSkip('plan')) {
+            logger.info(`[${task.id}] Resuming from step "${skipTo}" with agent ${pipeline.assignedAgent ?? 'default'}`);
         }
-        pipeline.architectPlan = planResult.output;
-        pipeline.testingSection = extractSection(planResult.output, 'TESTING');
-        // Check for split recommendation
-        if (task.complexity === 'L' && planResult.output.includes('SPLIT RECOMMENDATION') && !planResult.output.includes('No split needed')) {
-            logger.info(`[${task.id}] L-task split recommended — deferring to decomposition`);
-            // TODO: implement decomposition flow
+        // STEP 1: Plan
+        if (!shouldSkip('plan')) {
+            pipeline.step = 'plan';
+            appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'plan' }));
+            const planResult = await spawnAgent(pool, workerId, {
+                agent: pipeline.assignedAgent ?? undefined,
+                cwd: worktreePath,
+                prompt: buildPlanPrompt({ task, worktreePath, projectDir }),
+                model: getAgentModel(pipeline.assignedAgent, agents, task),
+            }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
+            if (!planResult.success) {
+                logger.error(`[${task.id}] Planning failed: ${planResult.error}`);
+                return false;
+            }
+            pipeline.architectPlan = planResult.output;
+            pipeline.testingSection = extractSection(planResult.output, 'TESTING');
+            if (task.complexity === 'L' && planResult.output.includes('SPLIT RECOMMENDATION') && !planResult.output.includes('No split needed')) {
+                logger.info(`[${task.id}] L-task split recommended — deferring to decomposition`);
+            }
         }
         // STEP 2: Implement (includes unit tests + build/lint)
-        pipeline.step = 'implement';
-        appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'implement' }));
-        // Re-route to implementation agent (may differ from planning agent)
-        // e.g., ui-engineer plans → angular-engineer implements
-        const implRouting = await orchestrator.routeTask(task, 'implement', agents);
-        const implAgent = implRouting.agent ?? pipeline.assignedAgent;
-        const implResult = await spawnAgent(pool, workerId, {
-            agent: implAgent ?? undefined,
-            cwd: worktreePath,
-            prompt: buildImplementPrompt({
-                task, worktreePath, projectDir,
-                architectPlan: pipeline.architectPlan,
-                apiContract: pipeline.apiContract ?? undefined,
-            }),
-            model: getAgentModel(implAgent, agents, task),
-        }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
-        if (!implResult.success) {
-            logger.error(`[${task.id}] Implementation failed: ${implResult.error}`);
-            return false;
-        }
-        // STEP 3: QA (E2E tests, integration tests, acceptance criteria verification)
-        // Only for tasks that need it — skip for pure refactoring, config changes, etc.
-        const needsQA = task.type !== 'fullstack' || !isRefactoringTask(task);
-        if (needsQA) {
-            pipeline.step = 'test';
-            appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'test' }));
-            const changedFiles = getChangedFiles(worktreePath);
-            const qaRouting = await orchestrator.routeTask(task, 'test', agents);
-            const qaResult = await spawnAgent(pool, workerId, {
-                agent: qaRouting.agent ?? undefined,
+        if (!shouldSkip('implement')) {
+            pipeline.step = 'implement';
+            appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'implement' }));
+            // Re-route to implementation agent (may differ from planning agent)
+            // e.g., ui-engineer plans → angular-engineer implements
+            const implRouting = await orchestrator.routeTask(task, 'implement', agents);
+            const implAgent = implRouting.agent ?? pipeline.assignedAgent;
+            const implResult = await spawnAgent(pool, workerId, {
+                agent: implAgent ?? undefined,
                 cwd: worktreePath,
-                prompt: buildQAPrompt({
-                    task, worktreePath, projectDir, changedFiles,
-                    testingSection: pipeline.testingSection ?? undefined,
+                prompt: buildImplementPrompt({
+                    task, worktreePath, projectDir,
+                    architectPlan: pipeline.architectPlan ?? undefined,
+                    apiContract: pipeline.apiContract ?? undefined,
                 }),
-                model: getAgentModel(qaRouting.agent, agents, task),
+                model: getAgentModel(implAgent, agents, task),
             }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
-            if (!qaResult.success) {
-                pipeline.buildFixes++;
-                if (pipeline.buildFixes >= MAX_BUILD_FIXES) {
-                    logger.error(`[${task.id}] QA failed ${MAX_BUILD_FIXES} times — skipping`);
-                    return false;
-                }
-                const decision = await orchestrator.handleFailure(task.title, 'test', qaResult.error ?? 'QA failed', pipeline.buildFixes);
-                if (decision.action === 'skip')
-                    return false;
+            if (!implResult.success) {
+                logger.error(`[${task.id}] Implementation failed: ${implResult.error}`);
+                return false;
             }
-        }
-        else {
-            logger.info(`[${task.id}] Skipping QA step (refactoring/config task)`);
-        }
-        // STEP 4: Review
-        pipeline.step = 'review';
-        appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'review' }));
-        const reviewRouting = await orchestrator.routeTask(task, 'review', agents);
-        let reviewPassed = false;
-        while (pipeline.reviewCycles < MAX_REVIEW_CYCLES && !reviewPassed) {
-            pipeline.reviewCycles++;
-            const reviewResult = await spawnAgent(pool, workerId, {
-                agent: reviewRouting.agent ?? undefined,
+        } // end if !shouldSkip('implement')
+        // For recovered pipelines at 'rework' step: run rework with context about what failed
+        if (resumeStep === 'rework') {
+            pipeline.step = 'rework';
+            appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'rework' }));
+            logger.info(`[${task.id}] Running rework step (recovered pipeline)`);
+            await spawnAgent(pool, workerId, {
+                agent: pipeline.assignedAgent ?? undefined,
                 cwd: worktreePath,
-                prompt: buildReviewPrompt({
+                prompt: buildReworkPrompt({
                     task, worktreePath, projectDir,
-                    changedFiles: getChangedFiles(worktreePath),
-                    testingSection: pipeline.testingSection ?? undefined,
+                    reviewFindings: 'This task was interrupted. The branch has existing work but may have build/lint failures, merge conflicts, or failing CI. Please:\n1. Run git fetch origin main && git rebase origin/main (resolve any conflicts)\n2. Run the build and lint scripts from package.json\n3. Fix any errors found\n4. Ensure all tests pass',
                 }),
-                model: getAgentModel(reviewRouting.agent, agents, task),
+                model: getAgentModel(pipeline.assignedAgent, agents, task),
             }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
-            if (reviewResult.output.includes('**PASS**') || reviewResult.output.includes('PASS')) {
-                reviewPassed = true;
+        }
+        // STEP 3: QA (E2E tests, integration tests, acceptance criteria verification)
+        // Only for tasks that need it — skip for pure refactoring, config changes, etc.
+        if (!shouldSkip('test')) {
+            const needsQA = task.type !== 'fullstack' || !isRefactoringTask(task);
+            if (needsQA) {
+                pipeline.step = 'test';
+                appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'test' }));
+                const changedFiles = getChangedFiles(worktreePath);
+                const qaRouting = await orchestrator.routeTask(task, 'test', agents);
+                const qaResult = await spawnAgent(pool, workerId, {
+                    agent: qaRouting.agent ?? undefined,
+                    cwd: worktreePath,
+                    prompt: buildQAPrompt({
+                        task, worktreePath, projectDir, changedFiles,
+                        testingSection: pipeline.testingSection ?? undefined,
+                    }),
+                    model: getAgentModel(qaRouting.agent, agents, task),
+                }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
+                if (!qaResult.success) {
+                    pipeline.buildFixes++;
+                    if (pipeline.buildFixes >= MAX_BUILD_FIXES) {
+                        logger.error(`[${task.id}] QA failed ${MAX_BUILD_FIXES} times — skipping`);
+                        return false;
+                    }
+                    const decision = await orchestrator.handleFailure(task.title, 'test', qaResult.error ?? 'QA failed', pipeline.buildFixes);
+                    if (decision.action === 'skip')
+                        return false;
+                }
             }
             else {
-                pipeline.reviewFindings = reviewResult.output;
-                if (pipeline.reviewCycles >= MAX_REVIEW_CYCLES) {
-                    logger.warn(`[${task.id}] Review limit (${MAX_REVIEW_CYCLES}) reached — proceeding anyway`);
+                logger.info(`[${task.id}] Skipping QA step (refactoring/config task)`);
+            }
+        } // end if !shouldSkip('test')
+        // STEP 4: Review
+        if (!shouldSkip('review')) {
+            pipeline.step = 'review';
+            appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'review' }));
+            const reviewRouting = await orchestrator.routeTask(task, 'review', agents);
+            let reviewPassed = false;
+            while (pipeline.reviewCycles < MAX_REVIEW_CYCLES && !reviewPassed) {
+                pipeline.reviewCycles++;
+                const reviewResult = await spawnAgent(pool, workerId, {
+                    agent: reviewRouting.agent ?? undefined,
+                    cwd: worktreePath,
+                    prompt: buildReviewPrompt({
+                        task, worktreePath, projectDir,
+                        changedFiles: getChangedFiles(worktreePath),
+                        testingSection: pipeline.testingSection ?? undefined,
+                    }),
+                    model: getAgentModel(reviewRouting.agent, agents, task),
+                }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
+                if (reviewResult.output.includes('**PASS**') || reviewResult.output.includes('PASS')) {
                     reviewPassed = true;
                 }
                 else {
-                    // Rework
-                    pipeline.step = 'rework';
-                    appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'rework' }));
-                    await spawnAgent(pool, workerId, {
-                        agent: pipeline.assignedAgent ?? undefined,
-                        cwd: worktreePath,
-                        prompt: buildReworkPrompt({
-                            task, worktreePath, projectDir,
-                            reviewFindings: pipeline.reviewFindings,
-                        }),
-                        model: getAgentModel(pipeline.assignedAgent, agents, task),
-                    }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
-                    pipeline.step = 're-review';
+                    pipeline.reviewFindings = reviewResult.output;
+                    if (pipeline.reviewCycles >= MAX_REVIEW_CYCLES) {
+                        logger.warn(`[${task.id}] Review limit (${MAX_REVIEW_CYCLES}) reached — proceeding anyway`);
+                        reviewPassed = true;
+                    }
+                    else {
+                        // Rework
+                        pipeline.step = 'rework';
+                        appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'rework' }));
+                        await spawnAgent(pool, workerId, {
+                            agent: pipeline.assignedAgent ?? undefined,
+                            cwd: worktreePath,
+                            prompt: buildReworkPrompt({
+                                task, worktreePath, projectDir,
+                                reviewFindings: pipeline.reviewFindings,
+                            }),
+                            model: getAgentModel(pipeline.assignedAgent, agents, task),
+                        }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
+                        pipeline.step = 're-review';
+                    }
                 }
             }
-        }
+        } // end if !shouldSkip('review')
         // STEP 5: Commit
-        pipeline.step = 'commit';
-        appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'commit' }));
-        // In local mode: update TODO.md checkbox inside worktree before commit
-        if (state.taskMode === 'local') {
-            const worktreeTodoPath = resolve(worktreePath, 'TODO.md');
-            if (task.lineNumber > 0 && existsSync(worktreeTodoPath)) {
-                const todoContent = readFileSync(worktreeTodoPath, 'utf-8');
-                const updated = updateTaskCheckbox(todoContent, task.lineNumber, 'done');
-                writeFileSync(worktreeTodoPath, updated, 'utf-8');
+        if (!shouldSkip('commit')) {
+            pipeline.step = 'commit';
+            appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'commit' }));
+            // In local mode: update TODO.md checkbox inside worktree before commit
+            if (state.taskMode === 'local') {
+                const worktreeTodoPath = resolve(worktreePath, 'TODO.md');
+                if (task.lineNumber > 0 && existsSync(worktreeTodoPath)) {
+                    const todoContent = readFileSync(worktreeTodoPath, 'utf-8');
+                    const updated = updateTaskCheckbox(todoContent, task.lineNumber, 'done');
+                    writeFileSync(worktreeTodoPath, updated, 'utf-8');
+                }
             }
-        }
+            const msg = `feat: ${task.title}${task.issueMarker ? ` (${task.issueMarker})` : ''}`;
+            const sha = commitInWorktree(worktreePath, msg);
+            if (!sha) {
+                logger.warn(`[${task.id}] Nothing to commit`);
+            }
+        } // end if !shouldSkip('commit')
         const commitMsg = `feat: ${task.title}${task.issueMarker ? ` (${task.issueMarker})` : ''}`;
-        const sha = commitInWorktree(worktreePath, commitMsg);
-        if (!sha) {
-            logger.warn(`[${task.id}] Nothing to commit`);
-        }
         // STEP 6: Push + PR/MR flow
         const ciPlatform = detectCIPlatform(projectDir);
         if (ciPlatform !== 'none') {
@@ -576,7 +676,7 @@ function isRefactoringTask(task) {
 }
 // ─── Orphaned worktree recovery ───
 /** Mark issue as done on the platform after a successful recovery merge */
-function closeRecoveredIssue(projectDir, branch, logger) {
+export function closeRecoveredIssue(projectDir, branch, logger) {
     const platform = detectCIPlatform(projectDir);
     if (platform === 'none')
         return;
@@ -591,21 +691,28 @@ function closeRecoveredIssue(projectDir, branch, logger) {
         logger.warn(`[recovery] Failed to close issue #${issueNum}: ${err.message}`);
     }
 }
-async function recoverOrphanedWorktrees(projectDir, state, logger, deps) {
+/**
+ * Recovery: diagnose orphaned worktrees + open MRs, then re-inject them
+ * into the normal pipeline so standard agents handle them via contracts.
+ *
+ * This does NOT spawn custom recovery agents — it just figures out the
+ * right pipeline step and lets runTaskPipeline do the real work.
+ */
+export async function recoverOrphanedWorktrees(projectDir, state, logger, _deps) {
     const knownPaths = Object.values(state.pipelines).map(p => p.worktreePath);
     const orphans = listOrphanedWorktrees(projectDir, knownPaths);
     const ciPlatform = detectCIPlatform(projectDir);
-    if (orphans.length === 0) {
-        logger.info('[recovery] No orphaned worktrees found');
+    if (orphans.length === 0 && ciPlatform === 'none') {
+        logger.info('[recovery] No orphaned worktrees or open MRs');
+        return;
     }
-    else {
+    if (orphans.length > 0) {
         logger.info(`[recovery] Found ${orphans.length} orphaned worktree(s)`);
     }
-    // Phase 1: Handle orphaned worktrees
+    // Phase 1: Orphaned worktrees → re-inject into pipelines
     for (const worktreePath of orphans) {
         try {
             const branch = getCurrentBranch(worktreePath);
-            logger.info(`[recovery] Processing worktree: ${branch}`);
             const alreadyMerged = isBranchMerged(projectDir, branch);
             if (alreadyMerged) {
                 logger.info(`[recovery] ${branch} already merged — cleaning up`);
@@ -617,159 +724,139 @@ async function recoverOrphanedWorktrees(projectDir, state, logger, deps) {
             const hasChanges = hasUncommittedChanges(worktreePath);
             const changedFromMain = getChangedFiles(worktreePath);
             const hasCommits = changedFromMain.length > 0;
-            logger.info(`[recovery] ${branch}: uncommitted=${hasChanges}, commits ahead=${hasCommits} (${changedFromMain.length} files)`);
             if (!hasCommits && !hasChanges) {
                 logger.info(`[recovery] ${branch} has no changes — cleaning up`);
                 cleanupWorktree(projectDir, worktreePath, branch);
                 deleteBranchRemote(projectDir, branch);
                 continue;
             }
+            // Auto-commit any uncommitted changes so the pipeline can work with them
             if (hasChanges) {
                 logger.info(`[recovery] ${branch} has uncommitted changes — committing`);
                 commitInWorktree(worktreePath, 'wip: auto-commit from recovery', true);
             }
-            // Delegate to AI agent: rebase onto main, fix any issues, then commit
-            logger.info(`[recovery] Spawning AI agent to finalize ${branch}`);
-            const slot = deps.pool.idleSlot();
-            if (!slot) {
-                logger.warn(`[recovery] No idle worker — skipping ${branch} for now`);
-                continue;
-            }
-            deps.onSpawnStart?.(`recovery-${branch}`);
-            try {
-                await deps.pool.spawn(slot.id, {
-                    cwd: worktreePath,
-                    prompt: [
-                        `You are in a git worktree for branch "${branch}".`,
-                        `This branch was interrupted and needs to be finalized for merge into main.`,
-                        ``,
-                        `Do the following:`,
-                        `1. Run: git fetch origin main && git rebase origin/main`,
-                        `2. If rebase has conflicts, resolve them sensibly (prefer feature branch intent)`,
-                        `3. After rebase, run the project's build/lint to check for errors:`,
-                        `   - Look at package.json for available scripts (build, lint, test)`,
-                        `   - Fix any build or lint errors in the code`,
-                        `4. Commit fixes: git add -A && git commit --no-verify -m "fix: resolve issues for merge"`,
-                        `5. Do NOT merge into main — just make the branch clean and ready`,
-                        ``,
-                        `Changed files in this branch: ${changedFromMain.join(', ')}`,
-                    ].join('\n'),
-                    model: 'claude-sonnet-4-6',
-                    onMessage: deps.onMessage,
-                });
-            }
-            finally {
-                deps.onSpawnEnd?.();
-            }
-            // Now try to merge
-            logger.info(`[recovery] Agent done — attempting merge of ${branch}`);
-            const stashed = cleanMainForMerge(projectDir);
-            syncMain(projectDir);
-            // Try platform merge (PR/MR) first
-            let merged = false;
-            if (ciPlatform !== 'none') {
-                const pushed = pushWorktree(worktreePath) || forcePushWorktree(worktreePath);
-                if (pushed) {
-                    try {
-                        const mainBranch = getMainBranch(projectDir);
-                        const issueNum = extractIssueFromBranch(branch);
-                        const prInfo = createPR({
-                            cwd: projectDir,
-                            platform: ciPlatform,
-                            branch,
-                            baseBranch: mainBranch,
-                            title: `feat: ${branch}`,
-                            body: 'Recovered and finalized by scheduler.',
-                            issueNumber: issueNum ?? undefined,
-                        });
-                        logger.info(`[recovery] PR: ${prInfo.url}`);
-                        if (prInfo.status === 'merged') {
-                            logger.info(`[recovery] ${branch} already merged via platform`);
-                            merged = true;
-                        }
-                        else {
-                            const prStatus = getPRStatus(projectDir, ciPlatform, branch);
-                            if (prStatus.mergeable) {
-                                merged = mergePR(projectDir, ciPlatform, prStatus.number);
-                                if (merged)
-                                    logger.info(`[recovery] ${branch} merged via platform`);
-                            }
-                            else {
-                                logger.info(`[recovery] PR for ${branch} not yet mergeable (CI: ${prStatus.ciStatus}) — leaving open`);
-                            }
-                        }
-                    }
-                    catch (err) {
-                        logger.warn(`[recovery] PR flow failed for ${branch}: ${err.message?.split('\n')[0]}`);
-                    }
-                }
-            }
-            // Local merge fallback
-            if (!merged) {
-                const mergeResult = mergeToMain(projectDir, branch);
-                if (mergeResult.success) {
-                    logger.info(`[recovery] ${branch} merged locally (${mergeResult.sha?.slice(0, 7)})`);
-                    merged = true;
-                }
-                else {
-                    logger.error(`[recovery] ${branch} merge failed: ${mergeResult.error ?? 'unknown'}`);
-                    abortMerge(projectDir);
-                }
-            }
-            if (merged) {
-                syncMain(projectDir);
-                cleanupWorktree(projectDir, worktreePath, branch);
-                deleteBranchRemote(projectDir, branch);
-                closeRecoveredIssue(projectDir, branch, logger);
-                appendEvent(projectDir, createEvent('merge_completed', { detail: `recovery: ${branch}` }));
-            }
-            if (stashed)
-                popStash(projectDir);
+            // Determine the right pipeline step to resume from
+            const issueNum = extractIssueFromBranch(branch);
+            const taskId = issueNum ? `#${issueNum}` : branch;
+            const step = diagnoseStep(projectDir, branch, ciPlatform);
+            logger.info(`[recovery] ${branch} → re-injecting into pipeline at step "${step}"`);
+            // Register in pipelines so the normal task loop picks it up
+            state.pipelines[taskId] = {
+                taskId,
+                workerId: -1, // Will be assigned when picked up
+                worktreePath,
+                step,
+                architectPlan: null,
+                apiContract: null,
+                reviewFindings: null,
+                testingSection: null,
+                reviewCycles: 0,
+                ciFixes: 0,
+                buildFixes: 0,
+                assignedAgent: null,
+                prState: null,
+            };
         }
         catch (err) {
-            logger.error(`[recovery] Failed to recover ${worktreePath}: ${err.message}`);
+            logger.error(`[recovery] Failed to process ${worktreePath}: ${err.message}`);
         }
     }
-    // Phase 2: Check for open MRs/PRs without local worktrees
+    // Phase 2: Open MRs/PRs without local worktrees
     if (ciPlatform !== 'none') {
-        await recoverOpenMRs(projectDir, ciPlatform, state, logger);
+        recoverOpenMRs(projectDir, ciPlatform, state, logger);
     }
 }
-/** Find open MRs/PRs that don't have local worktrees and try to merge them */
-async function recoverOpenMRs(projectDir, platform, state, logger) {
+/** Diagnose which pipeline step a recovered worktree should resume from */
+export function diagnoseStep(projectDir, branch, ciPlatform) {
+    // Check if there's an open MR/PR for this branch
+    if (ciPlatform !== 'none') {
+        try {
+            const prStatus = getPRStatus(projectDir, ciPlatform, branch);
+            if (prStatus.status === 'open') {
+                if (prStatus.ciStatus === 'failed')
+                    return 'rework'; // CI failed → rework
+                if (prStatus.mergeable)
+                    return 'merge'; // Ready to merge
+                if (prStatus.ciStatus === 'pending')
+                    return 'pr-watch'; // CI still running
+                return 'rework'; // Not mergeable for other reasons
+            }
+            if (prStatus.status === 'merged')
+                return 'done';
+        }
+        catch { /* no PR exists */ }
+    }
+    // No PR — branch has commits but hasn't been reviewed/pushed yet
+    // Start from review step (implementation is done since there are commits)
+    return 'review';
+}
+/** Re-inject open MRs that have no local worktree into the pipeline */
+export function recoverOpenMRs(projectDir, platform, state, logger) {
     try {
-        // Get all open MRs
         const openMRs = getOpenMRs(projectDir, platform);
         if (openMRs.length === 0)
             return;
-        const existingBranches = new Set(listWorktrees(projectDir).map(wt => {
+        // Collect branches that already have worktrees or pipelines
+        const handledBranches = new Set();
+        for (const wt of listWorktrees(projectDir)) {
             try {
-                return getCurrentBranch(wt);
+                handledBranches.add(getCurrentBranch(wt));
             }
-            catch {
-                return '';
+            catch { /* skip */ }
+        }
+        for (const p of Object.values(state.pipelines)) {
+            try {
+                const branch = getCurrentBranch(p.worktreePath);
+                handledBranches.add(branch);
             }
-        }));
+            catch { /* skip */ }
+        }
         for (const mr of openMRs) {
-            if (existingBranches.has(mr.branch))
-                continue; // Handled in phase 1
-            logger.info(`[recovery] Found open MR !${mr.number} for ${mr.branch} (no local worktree)`);
+            if (handledBranches.has(mr.branch))
+                continue;
             const prStatus = getPRStatus(projectDir, platform, mr.branch);
             if (prStatus.status === 'merged') {
-                logger.info(`[recovery] MR !${mr.number} already merged`);
+                logger.info(`[recovery] MR !${mr.number} already merged — closing issue`);
                 closeRecoveredIssue(projectDir, mr.branch, logger);
                 continue;
             }
-            if (prStatus.mergeable) {
-                const merged = mergePR(projectDir, platform, prStatus.number);
-                if (merged) {
-                    logger.info(`[recovery] MR !${mr.number} merged via platform`);
-                    syncMain(projectDir);
-                    closeRecoveredIssue(projectDir, mr.branch, logger);
-                }
+            // Create a worktree for the MR branch so the pipeline can work on it
+            const issueNum = extractIssueFromBranch(mr.branch);
+            const taskId = issueNum ? `#${issueNum}` : mr.branch;
+            // Skip if already completed/skipped
+            if (state.completedTasks.includes(taskId) || state.skippedTasks.includes(taskId))
+                continue;
+            let step;
+            if (prStatus.ciStatus === 'failed')
+                step = 'rework';
+            else if (prStatus.mergeable)
+                step = 'merge';
+            else if (prStatus.ciStatus === 'pending')
+                step = 'pr-watch';
+            else
+                step = 'rework';
+            logger.info(`[recovery] MR !${mr.number} (${mr.branch}) → creating worktree, pipeline at "${step}"`);
+            try {
+                const slug = mr.branch.replace(/^feat\//, '');
+                const worktreePath = createWorktree(projectDir, mr.branch);
+                state.pipelines[taskId] = {
+                    taskId,
+                    workerId: -1,
+                    worktreePath,
+                    step,
+                    architectPlan: null,
+                    apiContract: null,
+                    reviewFindings: null,
+                    testingSection: null,
+                    reviewCycles: 0,
+                    ciFixes: 0,
+                    buildFixes: 0,
+                    assignedAgent: null,
+                    prState: { prNumber: mr.number, url: '', issueNumber: issueNum },
+                };
             }
-            else {
-                logger.info(`[recovery] MR !${mr.number} not mergeable (CI: ${prStatus.ciStatus}) — leaving open`);
+            catch (err) {
+                logger.warn(`[recovery] Failed to create worktree for MR !${mr.number}: ${err.message?.split('\n')[0]}`);
             }
         }
     }
@@ -777,7 +864,7 @@ async function recoverOpenMRs(projectDir, platform, state, logger) {
         logger.warn(`[recovery] MR scan failed: ${err.message?.split('\n')[0]}`);
     }
 }
-function getOpenMRs(projectDir, platform) {
+export function getOpenMRs(projectDir, platform) {
     try {
         if (platform === 'github') {
             const output = execFileSync('gh', ['pr', 'list', '--json', 'number,headRefName', '--state', 'open'], { cwd: projectDir, encoding: 'utf-8', stdio: 'pipe', timeout: 30_000 }).trim();
@@ -910,7 +997,7 @@ function extractIssueNumber(marker) {
     return match ? parseInt(match[1], 10) : null;
 }
 /** Extract issue number from branch name like "feat/#94-description" or "feat/94-description" */
-function extractIssueFromBranch(branch) {
+export function extractIssueFromBranch(branch) {
     const match = branch.match(/#?(\d+)/);
     return match ? parseInt(match[1], 10) : null;
 }

package/dist/scheduler/loop.spec.js

@@ -139,3 +139,156 @@ describe('pipeline state tracking', () => {
         expect(pipeline.reviewCycles < 5).toBe(true);
     });
 });
+// ─── Test exports of recovery functions ───
+describe('recovery function exports', () => {
+    it('exports diagnoseStep', async () => {
+        const mod = await import('./loop.mjs');
+        expect(typeof mod.diagnoseStep).toBe('function');
+    });
+    it('exports recoverOrphanedWorktrees', async () => {
+        const mod = await import('./loop.mjs');
+        expect(typeof mod.recoverOrphanedWorktrees).toBe('function');
+    });
+    it('exports recoverOpenMRs', async () => {
+        const mod = await import('./loop.mjs');
+        expect(typeof mod.recoverOpenMRs).toBe('function');
+    });
+    it('exports getOpenMRs', async () => {
+        const mod = await import('./loop.mjs');
+        expect(typeof mod.getOpenMRs).toBe('function');
+    });
+    it('exports extractIssueFromBranch', async () => {
+        const mod = await import('./loop.mjs');
+        expect(typeof mod.extractIssueFromBranch).toBe('function');
+    });
+    it('exports closeRecoveredIssue', async () => {
+        const mod = await import('./loop.mjs');
+        expect(typeof mod.closeRecoveredIssue).toBe('function');
+    });
+});
+// ─── Test shouldSkip pattern used in runTaskPipeline ───
+describe('shouldSkip pattern (pipeline resume logic)', () => {
+    const stepOrder = ['plan', 'implement', 'test', 'review', 'rework', 'commit', 'pr-create', 'pr-watch', 'merge'];
+    function shouldSkip(step, resumeFrom) {
+        const skipToIndex = stepOrder.indexOf(resumeFrom);
+        return stepOrder.indexOf(step) < skipToIndex;
+    }
+    it('fresh pipeline (plan) skips nothing', () => {
+        for (const step of stepOrder) {
+            expect(shouldSkip(step, 'plan')).toBe(false);
+        }
+    });
+    it('resuming at "implement" skips only plan', () => {
+        expect(shouldSkip('plan', 'implement')).toBe(true);
+        expect(shouldSkip('implement', 'implement')).toBe(false);
+        expect(shouldSkip('test', 'implement')).toBe(false);
+    });
+    it('resuming at "review" skips plan, implement, test', () => {
+        expect(shouldSkip('plan', 'review')).toBe(true);
+        expect(shouldSkip('implement', 'review')).toBe(true);
+        expect(shouldSkip('test', 'review')).toBe(true);
+        expect(shouldSkip('review', 'review')).toBe(false);
+        expect(shouldSkip('commit', 'review')).toBe(false);
+        expect(shouldSkip('merge', 'review')).toBe(false);
+    });
+    it('resuming at "merge" skips everything before merge', () => {
+        for (const step of stepOrder.slice(0, -1)) {
+            expect(shouldSkip(step, 'merge')).toBe(true);
+        }
+        expect(shouldSkip('merge', 'merge')).toBe(false);
+    });
+    it('steps not in stepOrder return -1 index (treated as "skip nothing")', () => {
+        // 'done' and 'failed' are not in stepOrder, so indexOf returns -1
+        // This means skipToIndex = -1, and all steps have index >= 0, so nothing is skipped
+        // unless the step itself is also not in the list
+        const skipToIndex = stepOrder.indexOf('done');
+        expect(skipToIndex).toBe(-1);
+    });
+});
+// ─── Test extractIssueFromBranch pattern ───
+describe('extractIssueFromBranch pattern', () => {
+    // Mirrors the actual implementation: branch.match(/#?(\d+)/)
+    function extractIssueFromBranch(branch) {
+        const match = branch.match(/#?(\d+)/);
+        return match ? parseInt(match[1], 10) : null;
+    }
+    it('extracts from "feat/#42-auth"', () => {
+        expect(extractIssueFromBranch('feat/#42-auth')).toBe(42);
+    });
+    it('extracts from "feat/42-auth"', () => {
+        expect(extractIssueFromBranch('feat/42-auth')).toBe(42);
+    });
+    it('returns null for "feat/add-login"', () => {
+        expect(extractIssueFromBranch('feat/add-login')).toBeNull();
+    });
+    it('extracts first number from "feat/#42-fix-issue-99"', () => {
+        expect(extractIssueFromBranch('feat/#42-fix-issue-99')).toBe(42);
+    });
+    it('handles plain number branches like "42-auth"', () => {
+        expect(extractIssueFromBranch('42-auth')).toBe(42);
+    });
+});
+// ─── Test recovered pipeline identification pattern ───
+describe('recovered pipeline identification', () => {
+    it('identifies recovered pipelines by workerId === -1', () => {
+        const state = emptyState(1);
+        state.pipelines['#42'] = {
+            taskId: '#42',
+            workerId: -1,
+            worktreePath: '/wt/feat-42',
+            step: 'review',
+            architectPlan: null,
+            apiContract: null,
+            reviewFindings: null,
+            testingSection: null,
+            reviewCycles: 0,
+            ciFixes: 0,
+            buildFixes: 0,
+            assignedAgent: null,
+            prState: null,
+        };
+        state.pipelines['p1-1'] = {
+            taskId: 'p1-1',
+            workerId: 0,
+            worktreePath: '/wt/feat-p1-1',
+            step: 'implement',
+            architectPlan: null,
+            apiContract: null,
+            reviewFindings: null,
+            testingSection: null,
+            reviewCycles: 0,
+            ciFixes: 0,
+            buildFixes: 0,
+            assignedAgent: null,
+            prState: null,
+        };
+        const recoveredIds = Object.keys(state.pipelines).filter(id => {
+            const p = state.pipelines[id];
+            return p.workerId === -1 && p.step !== 'done' && p.step !== 'failed';
+        });
+        expect(recoveredIds).toEqual(['#42']);
+    });
+    it('excludes done and failed pipelines from recovery', () => {
+        const state = emptyState(1);
+        state.pipelines['#50'] = {
+            taskId: '#50',
+            workerId: -1,
+            worktreePath: '/wt/feat-50',
+            step: 'done',
+            architectPlan: null,
+            apiContract: null,
+            reviewFindings: null,
+            testingSection: null,
+            reviewCycles: 0,
+            ciFixes: 0,
+            buildFixes: 0,
+            assignedAgent: null,
+            prState: null,
+        };
+        const recoveredIds = Object.keys(state.pipelines).filter(id => {
+            const p = state.pipelines[id];
+            return p.workerId === -1 && p.step !== 'done' && p.step !== 'failed';
+        });
+        expect(recoveredIds).toHaveLength(0);
+    });
+});

package/dist/scheduler/recovery.spec.js

@@ -0,0 +1,121 @@
+// ─── Recovery & git workflow tests ───
+// Tests for diagnoseStep, extractIssueFromBranch, getOpenMRs,
+// closeRecoveredIssue, and shouldSkip pipeline resume logic.
+//
+// Pure function tests — no mocks needed.
+// @ts-ignore bun:test
+import { describe, it, expect } from 'bun:test';
+import { diagnoseStep, extractIssueFromBranch, getOpenMRs, } from './loop.mjs';
+// ─── diagnoseStep ───
+// Note: diagnoseStep calls getPRStatus which calls execFileSync.
+// For unit tests we test the logic indirectly — the function falls back
+// to 'review' when getPRStatus throws (which happens when not in a real repo).
+describe('diagnoseStep', () => {
+    it('returns "review" when CI platform is "none"', () => {
+        expect(diagnoseStep('/nonexistent', 'feat/42-auth', 'none')).toBe('review');
+    });
+    it('returns "review" when getPRStatus throws (no PR/no repo)', () => {
+        // /nonexistent is not a repo, so getPRStatus will throw
+        expect(diagnoseStep('/nonexistent', 'feat/42-auth', 'github')).toBe('review');
+    });
+    it('returns "review" for gitlab when no PR exists', () => {
+        expect(diagnoseStep('/nonexistent', 'feat/42-auth', 'gitlab')).toBe('review');
+    });
+});
+// ─── extractIssueFromBranch ───
+describe('extractIssueFromBranch', () => {
+    it('extracts number from "feat/#94-description"', () => {
+        expect(extractIssueFromBranch('feat/#94-user-auth')).toBe(94);
+    });
+    it('extracts number from "feat/94-description"', () => {
+        expect(extractIssueFromBranch('feat/94-add-login')).toBe(94);
+    });
+    it('returns null for branches without numbers', () => {
+        expect(extractIssueFromBranch('feat/add-login-page')).toBeNull();
+    });
+    it('extracts first number from branch with multiple numbers', () => {
+        expect(extractIssueFromBranch('feat/#42-fix-issue-99')).toBe(42);
+    });
+    it('extracts number from simple format', () => {
+        expect(extractIssueFromBranch('#7')).toBe(7);
+    });
+    it('returns null for empty string', () => {
+        expect(extractIssueFromBranch('')).toBeNull();
+    });
+});
+// ─── getOpenMRs ───
+describe('getOpenMRs', () => {
+    it('returns empty array when CLI not available', () => {
+        // /nonexistent is not a repo, so CLI will fail
+        expect(getOpenMRs('/nonexistent', 'github')).toEqual([]);
+    });
+    it('returns empty array for gitlab when CLI not available', () => {
+        expect(getOpenMRs('/nonexistent', 'gitlab')).toEqual([]);
+    });
+});
+// ─── shouldSkip pipeline resume (unit test of the pattern) ───
+describe('shouldSkip pipeline resume', () => {
+    // Replicate the exact shouldSkip logic from runTaskPipeline
+    const stepOrder = ['plan', 'implement', 'test', 'review', 'rework', 'commit', 'pr-create', 'pr-watch', 'merge'];
+    function shouldSkip(step, resumeStep) {
+        const skipToIndex = stepOrder.indexOf(resumeStep);
+        return stepOrder.indexOf(step) < skipToIndex;
+    }
+    it('pipeline at "review" skips plan, implement, test', () => {
+        expect(shouldSkip('plan', 'review')).toBe(true);
+        expect(shouldSkip('implement', 'review')).toBe(true);
+        expect(shouldSkip('test', 'review')).toBe(true);
+        expect(shouldSkip('review', 'review')).toBe(false);
+        expect(shouldSkip('commit', 'review')).toBe(false);
+    });
+    it('pipeline at "rework" skips plan through review', () => {
+        expect(shouldSkip('plan', 'rework')).toBe(true);
+        expect(shouldSkip('implement', 'rework')).toBe(true);
+        expect(shouldSkip('test', 'rework')).toBe(true);
+        expect(shouldSkip('review', 'rework')).toBe(true);
+        expect(shouldSkip('rework', 'rework')).toBe(false);
+    });
+    it('pipeline at "merge" skips everything before merge', () => {
+        expect(shouldSkip('plan', 'merge')).toBe(true);
+        expect(shouldSkip('commit', 'merge')).toBe(true);
+        expect(shouldSkip('pr-watch', 'merge')).toBe(true);
+        expect(shouldSkip('merge', 'merge')).toBe(false);
+    });
+    it('pipeline at "plan" skips nothing (fresh)', () => {
+        expect(shouldSkip('plan', 'plan')).toBe(false);
+        expect(shouldSkip('implement', 'plan')).toBe(false);
+        expect(shouldSkip('review', 'plan')).toBe(false);
+    });
+    it('pipeline at "pr-watch" skips through pr-create', () => {
+        expect(shouldSkip('pr-create', 'pr-watch')).toBe(true);
+        expect(shouldSkip('pr-watch', 'pr-watch')).toBe(false);
+        expect(shouldSkip('merge', 'pr-watch')).toBe(false);
+    });
+    it('pipeline at "commit" skips through rework', () => {
+        expect(shouldSkip('rework', 'commit')).toBe(true);
+        expect(shouldSkip('commit', 'commit')).toBe(false);
+    });
+    it('step not in stepOrder is treated as before all steps (indexOf=-1)', () => {
+        // 'done' is not in stepOrder, indexOf returns -1, which is < any skipToIndex
+        expect(shouldSkip('done', 'review')).toBe(true);
+        // But if resumeStep is 'plan' (index 0), -1 < 0 is true
+        expect(shouldSkip('done', 'plan')).toBe(true);
+    });
+});
+// ─── Recovered pipeline identification ───
+describe('recovered pipeline identification', () => {
+    it('workerId=-1 identifies recovered pipelines', () => {
+        const pipelines = {
+            '#1': { workerId: -1, step: 'review' },
+            '#2': { workerId: 0, step: 'implement' },
+            '#3': { workerId: -1, step: 'done' },
+            '#4': { workerId: -1, step: 'failed' },
+            '#5': { workerId: -1, step: 'rework' },
+        };
+        const recoveredIds = Object.keys(pipelines).filter(id => {
+            const p = pipelines[id];
+            return p.workerId === -1 && p.step !== 'done' && p.step !== 'failed';
+        });
+        expect(recoveredIds).toEqual(['#1', '#5']);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-workspace",
-  "version": "2.3.11",
+  "version": "2.3.13",
   "author": "",
   "repository": {
     "type": "git",