create-claude-workspace 2.3.10 → 2.3.12

package/dist/scheduler/git/manager.mjs

@@ -55,13 +55,16 @@ export function listOrphanedWorktrees(projectDir, knownWorktrees) {
     return actual.filter(p => !knownSet.has(normalizePath(resolve(p))));
 }
 // ─── Commit operations ───
-export function commitInWorktree(worktreePath, message) {
+export function commitInWorktree(worktreePath, message, skipHooks = false) {
     git(['add', '-A'], worktreePath);
     // Check if there's anything to commit
     const status = git(['status', '--porcelain'], worktreePath);
     if (!status)
         return '';
-    git(['commit', '-m', message], worktreePath);
+    const args = ['commit', '-m', message];
+    if (skipHooks)
+        args.push('--no-verify');
+    git(args, worktreePath);
     return git(['rev-parse', 'HEAD'], worktreePath);
 }
 export function getChangedFiles(worktreePath) {

package/dist/scheduler/loop.mjs

@@ -1,13 +1,14 @@
 // ─── Main orchestration loop: pipeline state machine ───
 // Picks tasks, assigns to workers, advances through plan→implement→test→review→commit→merge.
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
 import { resolve } from 'node:path';
 import { parseTodoMd, updateTaskCheckbox } from './tasks/parser.mjs';
 import { fetchOpenIssues, issueToTask, updateIssueStatus } from './tasks/issue-source.mjs';
 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, 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';
@@ -63,7 +64,7 @@ export async function runIteration(deps) {
         if (hasUncommittedChanges(projectDir)) {
             logger.warn('Uncommitted changes on main — auto-committing before starting work');
             try {
-                commitInWorktree(projectDir, 'chore: auto-commit uncommitted changes before scheduler start');
+                commitInWorktree(projectDir, 'chore: auto-commit uncommitted changes before scheduler start', true);
                 logger.info('Uncommitted changes committed on main');
             }
             catch (err) {
@@ -192,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;
@@ -245,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,
@@ -265,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') {
@@ -590,176 +691,195 @@ 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.
+ */
+async function recoverOrphanedWorktrees(projectDir, state, logger, _deps) {
     const knownPaths = Object.values(state.pipelines).map(p => p.worktreePath);
     const orphans = listOrphanedWorktrees(projectDir, knownPaths);
-    if (orphans.length === 0)
+    const ciPlatform = detectCIPlatform(projectDir);
+    if (orphans.length === 0 && ciPlatform === 'none') {
+        logger.info('[recovery] No orphaned worktrees or open MRs');
         return;
-    logger.info(`Found ${orphans.length} orphaned worktree(s) — attempting recovery`);
+    }
+    if (orphans.length > 0) {
+        logger.info(`[recovery] Found ${orphans.length} orphaned worktree(s)`);
+    }
+    // Phase 1: Orphaned worktrees → re-inject into pipelines
     for (const worktreePath of orphans) {
         try {
             const branch = getCurrentBranch(worktreePath);
             const alreadyMerged = isBranchMerged(projectDir, branch);
             if (alreadyMerged) {
-                // Already merged — just clean up
-                logger.info(`[recovery] ${branch} already merged — cleaning up worktree`);
+                logger.info(`[recovery] ${branch} already merged — cleaning up`);
                 cleanupWorktree(projectDir, worktreePath, branch);
                 deleteBranchRemote(projectDir, branch);
                 closeRecoveredIssue(projectDir, branch, logger);
                 continue;
             }
-            // Check if worktree has commits ahead of main
             const hasChanges = hasUncommittedChanges(worktreePath);
             const changedFromMain = getChangedFiles(worktreePath);
             const hasCommits = changedFromMain.length > 0;
             if (!hasCommits && !hasChanges) {
-                // No work done — clean up empty worktree
                 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) {
-                // Uncommitted changes — commit them first
                 logger.info(`[recovery] ${branch} has uncommitted changes — committing`);
-                commitInWorktree(worktreePath, `wip: auto-commit from recovery`);
-            }
-            // Try to merge
-            logger.info(`[recovery] ${branch} has unmerged commits — attempting merge`);
-            // Clean dirty main before merge
-            // Clean main: abort any in-progress merge/rebase, stash uncommitted changes
-            const stashed = cleanMainForMerge(projectDir);
-            syncMain(projectDir);
-            // Try PR flow first if remote exists
-            const ciPlatform = detectCIPlatform(projectDir);
-            if (ciPlatform !== 'none') {
-                const pushed = pushWorktree(worktreePath);
-                if (pushed) {
-                    try {
-                        const mainBranch = getMainBranch(projectDir);
-                        const prInfo = createPR({
-                            cwd: projectDir,
-                            platform: ciPlatform,
-                            branch,
-                            baseBranch: mainBranch,
-                            title: `feat: ${branch} (recovered)`,
-                            body: `Auto-recovered from orphaned worktree.\n\nThis PR was created by the scheduler to complete a previously interrupted task.`,
-                        });
-                        logger.info(`[recovery] PR created for ${branch}: ${prInfo.url}`);
-                        // Try to merge immediately if possible
-                        const status = getPRStatus(projectDir, ciPlatform, branch);
-                        if (status.mergeable) {
-                            mergePR(projectDir, ciPlatform, status.number);
-                            logger.info(`[recovery] ${branch} merged via platform`);
-                            syncMain(projectDir);
-                            cleanupWorktree(projectDir, worktreePath, branch);
-                            deleteBranchRemote(projectDir, branch);
-                            closeRecoveredIssue(projectDir, branch, logger);
-                            if (stashed)
-                                popStash(projectDir);
-                            continue;
-                        }
-                        // PR created but not yet mergeable — leave it for next iteration
-                        logger.info(`[recovery] PR for ${branch} not yet mergeable — will retry`);
-                        if (stashed)
-                            popStash(projectDir);
-                        continue;
-                    }
-                    catch (err) {
-                        logger.warn(`[recovery] PR creation failed for ${branch}: ${err.message} — trying local merge`);
-                    }
-                }
+                commitInWorktree(worktreePath, 'wip: auto-commit from recovery', true);
             }
-            // Local merge fallback
-            const mergeResult = mergeToMain(projectDir, branch);
-            if (mergeResult.success) {
-                logger.info(`[recovery] ${branch} merged locally (${mergeResult.sha?.slice(0, 7)})`);
-                appendEvent(projectDir, createEvent('merge_completed', { detail: `recovery: ${branch}` }));
-                closeRecoveredIssue(projectDir, branch, logger);
+            // 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 process ${worktreePath}: ${err.message}`);
+        }
+    }
+    // Phase 2: Open MRs/PRs without local worktrees
+    if (ciPlatform !== 'none') {
+        recoverOpenMRs(projectDir, ciPlatform, state, logger);
+    }
+}
+/** Diagnose which pipeline step a recovered worktree should resume from */
+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
             }
-            else if (mergeResult.conflict) {
-                // mergeToMain already aborted the merge internally
-                // Delegate conflict resolution to orchestrator AI
-                logger.info(`[recovery] ${branch} has merge conflicts — delegating to AI`);
-                let resolved = false;
-                try {
-                    const conflictDecision = await deps.orchestrator.handleMergeConflict(branch, mergeResult.conflictFiles ?? []);
-                    if (conflictDecision.action === 'resolve') {
-                        // Spawn agent to resolve conflicts in the worktree via rebase
-                        logger.info(`[recovery] Spawning agent to resolve conflicts in ${branch}`);
-                        const conflictPrompt = [
-                            `You are in a worktree for branch "${branch}".`,
-                            `Rebase this branch onto main and resolve all merge conflicts.`,
-                            ``,
-                            `Steps:`,
-                            `1. Run: git rebase main`,
-                            `2. For each conflict, read the conflicting files and resolve them sensibly`,
-                            `3. After resolving each file: git add <file>`,
-                            `4. Continue rebase: git rebase --continue`,
-                            `5. Repeat until rebase is complete`,
-                            ``,
-                            `Conflicting files: ${(mergeResult.conflictFiles ?? []).join(', ') || 'unknown'}`,
-                            ``,
-                            `Important: preserve the intent of both sides. When in doubt, prefer the feature branch changes.`,
-                        ].join('\n');
-                        const slot = deps.pool.idleSlot();
-                        if (slot) {
-                            await deps.pool.spawn(slot.id, {
-                                cwd: worktreePath,
-                                prompt: conflictPrompt,
-                                model: 'claude-sonnet-4-6',
-                                onMessage: deps.onMessage,
-                            });
-                            // Retry merge after agent resolved conflicts
-                            const retryResult = mergeToMain(projectDir, branch);
-                            if (retryResult.success) {
-                                logger.info(`[recovery] ${branch} merged after AI conflict resolution`);
-                                appendEvent(projectDir, createEvent('merge_completed', { detail: `recovery-ai-resolve: ${branch}` }));
-                                resolved = true;
-                            }
-                        }
-                    }
-                    else if (conflictDecision.action === 'rebase') {
-                        const rebaseResult = rebaseOnMain(worktreePath, projectDir);
-                        if (rebaseResult.success) {
-                            const retryResult = mergeToMain(projectDir, branch);
-                            if (retryResult.success) {
-                                logger.info(`[recovery] ${branch} merged after rebase`);
-                                resolved = true;
-                            }
-                        }
-                    }
-                    // action === 'skip' → resolved stays false
-                }
-                catch (err) {
-                    logger.warn(`[recovery] AI conflict resolution failed for ${branch}: ${err.message}`);
-                    abortMerge(projectDir);
-                }
-                if (!resolved) {
-                    logger.error(`[recovery] ${branch} has unresolvable conflicts — skipping`);
-                    abortMerge(projectDir);
-                    if (stashed)
-                        popStash(projectDir);
-                    continue;
-                }
+            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 */
+function recoverOpenMRs(projectDir, platform, state, logger) {
+    try {
+        const openMRs = getOpenMRs(projectDir, platform);
+        if (openMRs.length === 0)
+            return;
+        // Collect branches that already have worktrees or pipelines
+        const handledBranches = new Set();
+        for (const wt of listWorktrees(projectDir)) {
+            try {
+                handledBranches.add(getCurrentBranch(wt));
             }
-            else {
-                logger.error(`[recovery] ${branch} merge failed: ${mergeResult.error} — skipping`);
-                abortMerge(projectDir);
-                if (stashed)
-                    popStash(projectDir);
+            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 (handledBranches.has(mr.branch))
+                continue;
+            const prStatus = getPRStatus(projectDir, platform, mr.branch);
+            if (prStatus.status === 'merged') {
+                logger.info(`[recovery] MR !${mr.number} already merged — closing issue`);
+                closeRecoveredIssue(projectDir, mr.branch, logger);
                 continue;
             }
-            // Post-merge cleanup: worktree + local branch + remote branch + close issue
-            cleanupWorktree(projectDir, worktreePath, branch);
-            deleteBranchRemote(projectDir, branch);
-            closeRecoveredIssue(projectDir, branch, logger);
-            if (stashed)
-                popStash(projectDir);
+            // 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 },
+                };
+            }
+            catch (err) {
+                logger.warn(`[recovery] Failed to create worktree for MR !${mr.number}: ${err.message?.split('\n')[0]}`);
+            }
         }
-        catch (err) {
-            logger.error(`[recovery] Failed to recover ${worktreePath}: ${err.message}`);
+    }
+    catch (err) {
+        logger.warn(`[recovery] MR scan failed: ${err.message?.split('\n')[0]}`);
+    }
+}
+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();
+            const prs = JSON.parse(output);
+            return prs.map(p => ({ number: p.number, branch: p.headRefName }));
+        }
+        else {
+            const output = execFileSync('glab', ['mr', 'list', '--output', 'json'], { cwd: projectDir, encoding: 'utf-8', stdio: 'pipe', timeout: 30_000 }).trim();
+            const mrs = JSON.parse(output);
+            return mrs.map(m => ({ number: m.iid, branch: m.source_branch }));
         }
     }
+    catch {
+        return [];
+    }
 }
 function loadTasksJson(path) {
     const content = readFileSync(path, 'utf-8');

package/package.json

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