create-claude-workspace 2.3.15 → 2.3.17

package/dist/scheduler/loop.mjs

@@ -193,8 +193,55 @@ export async function runIteration(deps) {
     if (queued > 0) {
         logger.info(`Starting ${tasksToRun.length} tasks, ${queued} queued (waiting for workers)`);
     }
-    // Process recovered pipelines first (from recovery phase)
+    // ─── Phase A: Check active PR watches (non-blocking) ───
     let workDone = false;
+    const prWatchIds = Object.keys(state.pipelines).filter(id => state.pipelines[id].step === 'pr-watch');
+    for (const taskId of prWatchIds) {
+        const pipeline = state.pipelines[taskId];
+        const result = await checkPRWatch(taskId, pipeline, projectDir, agents, deps);
+        if (result === 'merged') {
+            let branch;
+            try {
+                branch = getCurrentBranch(pipeline.worktreePath);
+            }
+            catch {
+                branch = taskId;
+            }
+            logger.info(`[${taskId}] PR merged via platform`);
+            appendEvent(projectDir, createEvent('pr_merged', { taskId }));
+            syncMain(projectDir);
+            cleanupWorktree(projectDir, pipeline.worktreePath, branch);
+            deleteBranchRemote(projectDir, branch);
+            pipeline.step = 'done';
+            clearSession(state, taskId);
+            state.completedTasks.push(taskId);
+            delete state.pipelines[taskId];
+            if (state.taskMode === 'platform') {
+                const ciPlat = detectCIPlatform(projectDir);
+                if (ciPlat !== 'none') {
+                    const issueNum = extractIssueNumber(taskId);
+                    if (issueNum)
+                        updateIssueStatus(projectDir, ciPlat, issueNum, 'done');
+                }
+            }
+            appendEvent(projectDir, createEvent('task_completed', { taskId }));
+            workDone = true;
+        }
+        else if (result === 'failed') {
+            logger.error(`[${taskId}] PR failed — skipping task`);
+            pipeline.step = 'failed';
+            state.skippedTasks.push(taskId);
+            delete state.pipelines[taskId];
+            workDone = true;
+        }
+        else if (result === 'rework') {
+            // CI failed or comments — agent was spawned to fix, push done, back to watching
+            workDone = true;
+        }
+        // result === 'waiting' → still polling, do nothing
+        writeState(projectDir, state);
+    }
+    // ─── Phase B: Process recovered pipelines (from recovery phase) ───
     const recoveredIds = Object.keys(state.pipelines).filter(id => {
         const p = state.pipelines[id];
         return p.workerId === -1 && p.step !== 'done' && p.step !== 'failed';
@@ -227,7 +274,11 @@ export async function runIteration(deps) {
         try {
             const success = await runTaskPipeline(task, slot.id, agents, deps);
             workDone = true;
-            if (success) {
+            // If pipeline is in pr-watch, it's still active — don't mark done yet
+            if (state.pipelines[task.id]?.step === 'pr-watch') {
+                // PR watch is non-blocking, handled in Phase A next iteration
+            }
+            else if (success) {
                 task.status = 'done';
                 state.completedTasks.push(task.id);
                 if (state.taskMode === 'platform') {
@@ -265,7 +316,11 @@ export async function runIteration(deps) {
         try {
             const success = await runTaskPipeline(task, slot.id, agents, deps);
             workDone = true;
-            if (success) {
+            // If pipeline is in pr-watch, it's still active — don't mark done yet
+            if (state.pipelines[task.id]?.step === 'pr-watch') {
+                // PR watch is non-blocking, handled in Phase A next iteration
+            }
+            else if (success) {
                 task.status = 'done';
                 state.completedTasks.push(task.id);
                 if (state.taskMode === 'platform') {
@@ -541,24 +596,13 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                     pipeline.prState = { prNumber: prInfo.number, url: prInfo.url, issueNumber: issueNum };
                     logger.info(`[${task.id}] PR created: ${prInfo.url}`);
                     appendEvent(projectDir, createEvent('pr_created', { taskId: task.id, detail: prInfo.url }));
-                    // STEP 7: Poll PR status — CI, comments, mergeable
+                    // STEP 7: PR created — hand off to non-blocking PR watch
+                    // The main loop checks pr-watch pipelines each iteration
                     pipeline.step = 'pr-watch';
                     appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'pr-watch' }));
-                    const merged = await pollAndMergePR(task, pipeline, slug, ciPlatform, projectDir, worktreePath, agents, deps);
-                    if (merged) {
-                        logger.info(`[${task.id}] PR merged via platform`);
-                        appendEvent(projectDir, createEvent('pr_merged', { taskId: task.id }));
-                        // Sync main to get the merge commit
-                        syncMain(projectDir);
-                        cleanupWorktree(projectDir, worktreePath, slug);
-                        deleteBranchRemote(projectDir, slug);
-                        pipeline.step = 'done';
-                        clearSession(state, task.id);
-                        delete state.pipelines[task.id];
-                        return true;
-                    }
-                    // Fallback to local merge
-                    logger.warn(`[${task.id}] Platform merge failed — falling back to local merge`);
+                    logger.info(`[${task.id}] PR watching — releasing worker for other tasks`);
+                    writeState(projectDir, state);
+                    return true; // Task not failed, PR watch continues in main loop
                 }
                 catch (err) {
                     logger.warn(`[${task.id}] PR creation failed: ${err.message} — falling back to local merge`);
@@ -902,13 +946,114 @@ function loadTasksJson(path) {
 // ─── PR polling and merge ───
 const PR_POLL_INTERVAL = 15_000;
 const PR_MAX_POLL_TIME = 30 * 60_000;
+async function checkPRWatch(taskId, pipeline, projectDir, agents, deps) {
+    const { pool, logger, state, onMessage, onSpawnStart, onSpawnEnd } = deps;
+    const ciPlatform = detectCIPlatform(projectDir);
+    if (ciPlatform === 'none' || !pipeline.prState)
+        return 'failed';
+    const branch = getCurrentBranch(pipeline.worktreePath);
+    try {
+        const prStatus = getPRStatus(projectDir, ciPlatform, branch);
+        if (prStatus.status === 'merged')
+            return 'merged';
+        if (prStatus.status === 'closed')
+            return 'failed';
+        // Ready to merge
+        if (prStatus.mergeable) {
+            logger.info(`[${taskId}] PR mergeable — merging`);
+            const merged = mergePR(projectDir, ciPlatform, prStatus.number);
+            return merged ? 'merged' : 'failed';
+        }
+        // CI pending — keep waiting
+        if (prStatus.ciStatus === 'pending' || prStatus.ciStatus === 'not-found') {
+            logger.info(`[${taskId}] CI: ${prStatus.ciStatus} — waiting`);
+            return 'waiting';
+        }
+        // CI passed but not mergeable — waiting for approval
+        if (prStatus.ciStatus === 'passed' && !prStatus.mergeable) {
+            logger.info(`[${taskId}] CI passed, not mergeable — waiting`);
+            return 'waiting';
+        }
+        // CI failed — delegate fix to implementing agent
+        if (prStatus.ciStatus === 'failed') {
+            if (pipeline.ciFixes >= MAX_CI_FIXES) {
+                logger.error(`[${taskId}] CI fix limit (${MAX_CI_FIXES}) reached`);
+                return 'failed';
+            }
+            pipeline.ciFixes++;
+            logger.warn(`[${taskId}] CI failed — delegating to agent (${pipeline.ciFixes}/${MAX_CI_FIXES})`);
+            const slot = pool.idleSlot();
+            if (!slot) {
+                logger.info(`[${taskId}] No idle worker for CI fix — will retry next iteration`);
+                pipeline.ciFixes--; // Don't count this attempt
+                return 'waiting';
+            }
+            const logs = fetchFailureLogs(branch, ciPlatform === 'github' ? 'github' : 'gitlab', projectDir);
+            // Create a minimal task for agent spawning
+            const task = {
+                id: taskId, title: `Fix CI for ${taskId}`, phase: state.currentPhase,
+                type: 'fullstack', complexity: 'S', dependsOn: [], issueMarker: taskId,
+                kitUpgrade: false, lineNumber: 0, status: 'in-progress', changelog: 'fixed',
+            };
+            const fixResult = await spawnAgent(pool, slot.id, {
+                agent: pipeline.assignedAgent ?? undefined,
+                cwd: pipeline.worktreePath,
+                prompt: buildCIFixPrompt({ task, worktreePath: pipeline.worktreePath, projectDir }, logs ?? 'No CI logs available'),
+                model: getAgentModel(pipeline.assignedAgent, agents, task),
+            }, state, taskId, logger, onMessage, onSpawnStart, onSpawnEnd);
+            if (fixResult.success) {
+                const sha = commitInWorktree(pipeline.worktreePath, `fix: CI failure for ${taskId}`);
+                if (sha) {
+                    forcePushWorktree(pipeline.worktreePath);
+                    logger.info(`[${taskId}] Fix pushed — will check CI next iteration`);
+                    return 'rework';
+                }
+            }
+            return 'waiting'; // Agent didn't produce fix, retry next iteration
+        }
+        // Unresolved PR comments
+        const comments = getPRComments(projectDir, ciPlatform, prStatus.number);
+        const unresolved = comments.filter(c => !c.resolved);
+        if (unresolved.length > 0) {
+            const slot = pool.idleSlot();
+            if (!slot)
+                return 'waiting';
+            logger.info(`[${taskId}] ${unresolved.length} PR comments — delegating to agent`);
+            const commentText = unresolved
+                .map(c => `${c.path ?? 'general'}${c.line ? `:${c.line}` : ''} — ${c.author}: ${c.body}`)
+                .join('\n\n');
+            const task = {
+                id: taskId, title: `Address PR comments for ${taskId}`, phase: state.currentPhase,
+                type: 'fullstack', complexity: 'S', dependsOn: [], issueMarker: taskId,
+                kitUpgrade: false, lineNumber: 0, status: 'in-progress', changelog: 'fixed',
+            };
+            const result = await spawnAgent(pool, slot.id, {
+                agent: pipeline.assignedAgent ?? undefined,
+                cwd: pipeline.worktreePath,
+                prompt: buildPRCommentPrompt({ task, worktreePath: pipeline.worktreePath, projectDir }, commentText),
+                model: getAgentModel(pipeline.assignedAgent, agents, task),
+            }, state, taskId, logger, onMessage, onSpawnStart, onSpawnEnd);
+            if (result.success) {
+                const sha = commitInWorktree(pipeline.worktreePath, 'fix: address PR comments');
+                if (sha) {
+                    forcePushWorktree(pipeline.worktreePath);
+                    appendEvent(projectDir, createEvent('pr_comment_resolved', { taskId, detail: `${unresolved.length} comments` }));
+                    return 'rework';
+                }
+            }
+            return 'waiting';
+        }
+        return 'waiting';
+    }
+    catch (err) {
+        logger.error(`[${taskId}] PR watch error: ${err.message?.split('\n')[0]}`);
+        return 'waiting'; // Don't fail on transient errors
+    }
+}
+// ─── Legacy blocking PR poll (kept for local merge fallback) ───
 async function pollAndMergePR(task, pipeline, branch, platform, projectDir, worktreePath, agents, deps) {
     const { pool, logger, state, onMessage, onSpawnStart, onSpawnEnd } = deps;
     const startTime = Date.now();
-    let lastSeenCIStatus = 'none'; // Track CI transitions to detect stale status
-    // Initial wait — give CI time to pick up the new push
-    logger.info(`[${task.id}] Waiting for CI pipeline to start...`);
-    await sleep(PR_POLL_INTERVAL);
     while (Date.now() - startTime < PR_MAX_POLL_TIME) {
         const prStatus = getPRStatus(projectDir, platform, branch);
         if (prStatus.status === 'merged')
@@ -918,37 +1063,22 @@ async function pollAndMergePR(task, pipeline, branch, platform, projectDir, work
         // Ready to merge — CI passed and mergeable
         if (prStatus.mergeable) {
             logger.info(`[${task.id}] PR mergeable — merging`);
-            const merged = mergePR(projectDir, platform, prStatus.number);
-            return merged;
+            return mergePR(projectDir, platform, prStatus.number);
         }
-        // CI still running or not started — wait
+        // CI still running or not started — poll
         if (prStatus.ciStatus === 'pending' || prStatus.ciStatus === 'not-found') {
-            if (prStatus.ciStatus !== lastSeenCIStatus) {
-                logger.info(`[${task.id}] CI: ${prStatus.ciStatus} — waiting...`);
-                lastSeenCIStatus = prStatus.ciStatus;
-            }
+            logger.info(`[${task.id}] CI: ${prStatus.ciStatus} — polling...`);
             await sleep(PR_POLL_INTERVAL);
             continue;
         }
-        // CI passed but not mergeable (needs approval, merge checks, etc.)
+        // CI passed but not mergeable (needs approval, merge checks, etc.) — poll
         if (prStatus.ciStatus === 'passed' && !prStatus.mergeable) {
-            if (lastSeenCIStatus !== 'passed-not-mergeable') {
-                logger.info(`[${task.id}] CI passed but not mergeable — waiting for approval or checks`);
-                lastSeenCIStatus = 'passed-not-mergeable';
-            }
+            logger.info(`[${task.id}] CI passed, not yet mergeable — polling...`);
             await sleep(PR_POLL_INTERVAL);
             continue;
         }
         // CI failed — delegate to implementing agent to fix
         if (prStatus.ciStatus === 'failed') {
-            // Avoid re-fixing if we just pushed and the old pipeline result is stale
-            if (lastSeenCIStatus === 'fix-pushed') {
-                // We just pushed a fix — wait for new pipeline to start
-                logger.info(`[${task.id}] Waiting for new CI pipeline after fix push...`);
-                lastSeenCIStatus = 'pending-after-fix';
-                await sleep(PR_POLL_INTERVAL * 2); // Extra wait for new pipeline
-                continue;
-            }
             if (pipeline.ciFixes >= MAX_CI_FIXES) {
                 logger.error(`[${task.id}] CI fix limit (${MAX_CI_FIXES}) reached — giving up`);
                 return false;
@@ -966,13 +1096,13 @@ async function pollAndMergePR(task, pipeline, branch, platform, projectDir, work
                 const sha = commitInWorktree(worktreePath, `fix: CI failure for ${task.title}`);
                 if (sha) {
                     forcePushWorktree(worktreePath);
-                    lastSeenCIStatus = 'fix-pushed';
-                    logger.info(`[${task.id}] Fix pushed — waiting for new CI pipeline`);
-                    await sleep(PR_POLL_INTERVAL * 2); // Wait for new pipeline to start
+                    logger.info(`[${task.id}] Fix pushed — polling for new CI pipeline`);
+                    // Poll until CI status changes from 'failed' (= new pipeline picked up)
+                    await waitForCIRefresh(task.id, projectDir, platform, branch, logger);
                     continue;
                 }
             }
-            // Fix didn't produce changes or failed — wait and retry
+            // Fix didn't produce changes — poll and let next iteration re-evaluate
             await sleep(PR_POLL_INTERVAL);
             continue;
         }
@@ -994,8 +1124,9 @@ async function pollAndMergePR(task, pipeline, branch, platform, projectDir, work
                 const sha = commitInWorktree(worktreePath, 'fix: address PR review comments');
                 if (sha) {
                     forcePushWorktree(worktreePath);
-                    lastSeenCIStatus = 'fix-pushed';
                     appendEvent(projectDir, createEvent('pr_comment_resolved', { taskId: task.id, detail: `${unresolved.length} comments` }));
+                    await waitForCIRefresh(task.id, projectDir, platform, branch, logger);
+                    continue;
                 }
             }
             await sleep(PR_POLL_INTERVAL);
@@ -1006,6 +1137,24 @@ async function pollAndMergePR(task, pipeline, branch, platform, projectDir, work
     logger.warn(`[${task.id}] PR poll timeout (${PR_MAX_POLL_TIME / 60_000}min)`);
     return false;
 }
+/** Poll until CI status is no longer the previous 'failed' (= new pipeline started) */
+async function waitForCIRefresh(taskId, projectDir, platform, branch, logger) {
+    const maxWait = 5 * 60_000; // 5 min max to wait for new pipeline
+    const start = Date.now();
+    while (Date.now() - start < maxWait) {
+        await sleep(PR_POLL_INTERVAL);
+        try {
+            const status = getPRStatus(projectDir, platform, branch);
+            if (status.ciStatus !== 'failed') {
+                logger.info(`[${taskId}] New CI pipeline detected: ${status.ciStatus}`);
+                return;
+            }
+            logger.info(`[${taskId}] CI still shows previous failure — polling...`);
+        }
+        catch { /* ignore */ }
+    }
+    logger.warn(`[${taskId}] Timed out waiting for new CI pipeline`);
+}
 function buildPRBody(task, pipeline) {
     const lines = [
         `## Summary`,

package/package.json

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