create-claude-workspace 2.3.34 → 2.3.35

package/dist/scheduler/loop.mjs

@@ -159,62 +159,11 @@ export async function runIteration(deps) {
             task.status = 'skipped';
         }
     }
-    // Check project completion
-    if (isProjectComplete(tasks)) {
-        logger.info('All tasks complete.');
-        return false;
-    }
-    // Scan agents
+    // Scan agents (needed by Phase A/B/C)
     const agents = scanAgents(projectDir);
-    // Build dependency graph
-    const graph = buildGraph(tasks);
-    const cycle = graph.findCycle();
-    if (cycle) {
-        logger.error(`Dependency cycle detected: ${cycle.join(' → ')}`);
-        return false;
-    }
-    // Get runnable tasks
-    const runnable = graph.runnable();
-    if (runnable.length === 0) {
-        logger.info('No runnable tasks (all blocked by dependencies)');
-        return false;
-    }
-    // Check for phase transition
-    const currentPhase = state.currentPhase;
-    if (isPhaseComplete(tasks, currentPhase)) {
-        const next = getNextPhase(tasks);
-        if (next !== null && next !== currentPhase) {
-            logger.info(`Phase ${currentPhase} complete → advancing to Phase ${next}`);
-            state.currentPhase = next;
-            // Release for completed phase
-            const phaseTasks = tasks.filter(t => t.phase === currentPhase && t.status === 'done');
-            if (phaseTasks.length > 0) {
-                const release = createRelease(projectDir, phaseTasks, currentPhase);
-                if (release) {
-                    logger.info(`Release ${release.version} created for Phase ${currentPhase}`);
-                    appendEvent(projectDir, createEvent('release', { detail: release.version }));
-                }
-            }
-            appendEvent(projectDir, createEvent('phase_transition', { detail: `Phase ${currentPhase} → ${next}` }));
-            writeState(projectDir, state);
-        }
-    }
-    // Get parallel batches
-    const batches = getParallelBatches(runnable);
-    if (batches.length === 0)
-        return false;
-    const batch = batches[0];
-    const availableSlots = opts.concurrency - pool.activeCount();
-    const tasksToRun = batch.slice(0, availableSlots);
-    const queued = batch.length - tasksToRun.length;
-    if (tasksToRun.length === 0) {
-        logger.info(`All ${opts.concurrency} workers busy. ${batch.length} tasks queued.`);
-        return false;
-    }
-    if (queued > 0) {
-        logger.info(`Starting ${tasksToRun.length} tasks, ${queued} queued (waiting for workers)`);
-    }
     // ─── Phase A: Check active PR watches (non-blocking) ───
+    // Must run BEFORE runnable/completion checks — active pipelines need servicing
+    // even when no new tasks are available (especially in interactive mode).
     let workDone = false;
     const prWatchIds = Object.keys(state.pipelines).filter(id => state.pipelines[id].step === 'pr-watch');
     for (const taskId of prWatchIds) {
@@ -320,7 +269,56 @@ export async function runIteration(deps) {
         }
         writeState(projectDir, state);
     }
-    // Process new tasks through the pipeline
+    // ─── Phase C: Pick and run new tasks ───
+    // Determine runnable tasks (skip if no tasks to evaluate)
+    let tasksToRun = [];
+    if (tasks.length > 0 && !isProjectComplete(tasks)) {
+        const graph = buildGraph(tasks);
+        const cycle = graph.findCycle();
+        if (cycle) {
+            logger.error(`Dependency cycle detected: ${cycle.join(' → ')}`);
+        }
+        else {
+            const runnable = graph.runnable();
+            // Phase transition check
+            const currentPhase = state.currentPhase;
+            if (isPhaseComplete(tasks, currentPhase)) {
+                const next = getNextPhase(tasks);
+                if (next !== null && next !== currentPhase) {
+                    logger.info(`Phase ${currentPhase} complete → advancing to Phase ${next}`);
+                    state.currentPhase = next;
+                    const phaseTasks = tasks.filter(t => t.phase === currentPhase && t.status === 'done');
+                    if (phaseTasks.length > 0) {
+                        const release = createRelease(projectDir, phaseTasks, currentPhase);
+                        if (release) {
+                            logger.info(`Release ${release.version} created for Phase ${currentPhase}`);
+                            appendEvent(projectDir, createEvent('release', { detail: release.version }));
+                        }
+                    }
+                    appendEvent(projectDir, createEvent('phase_transition', { detail: `Phase ${currentPhase} → ${next}` }));
+                    writeState(projectDir, state);
+                }
+            }
+            const batches = getParallelBatches(runnable);
+            if (batches.length > 0) {
+                const batch = batches[0];
+                const availableSlots = opts.concurrency - pool.activeCount();
+                tasksToRun = batch.slice(0, availableSlots);
+                const queued = batch.length - tasksToRun.length;
+                if (tasksToRun.length === 0) {
+                    logger.info(`All ${opts.concurrency} workers busy. ${batch.length} tasks queued.`);
+                }
+                else if (queued > 0) {
+                    logger.info(`Starting ${tasksToRun.length} tasks, ${queued} queued (waiting for workers)`);
+                }
+            }
+        }
+    }
+    else if (tasks.length > 0) {
+        logger.info('All tasks complete.');
+    }
+    // Also consider active pipelines as "work in progress" (don't report idle)
+    const hasActivePipelines = Object.keys(state.pipelines).length > 0;
     for (const task of tasksToRun) {
         // Skip if already handled as recovered pipeline
         if (state.pipelines[task.id])
@@ -375,7 +373,8 @@ export async function runIteration(deps) {
     }
     state.iteration++;
     writeState(projectDir, state);
-    return workDone;
+    // Active pipelines (e.g. pr-watch) count as work even if no new tasks ran
+    return workDone || hasActivePipelines;
 }
 // ─── Pipeline execution ───
 async function runTaskPipeline(task, workerId, agents, deps) {
@@ -651,7 +650,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                     }),
                     model: getAgentModel(reviewRouting.agent, agents, task),
                 }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd, mcpServers);
-                if (reviewResult.output.includes('**PASS**') || reviewResult.output.includes('PASS')) {
+                if (isReviewPass(reviewResult.output)) {
                     reviewPassed = true;
                 }
                 else {
@@ -813,6 +812,21 @@ async function runTaskPipeline(task, workerId, agents, deps) {
     }
 }
 // ─── Helpers ───
+/**
+ * Detect whether a review output indicates PASS.
+ * Explicit "PASS" keyword OR structured review with no CRITICAL/WARN findings.
+ */
+function isReviewPass(output) {
+    if (/\bPASS\b/.test(output))
+        return true;
+    // Structured review: has GREEN section + CRITICAL/WARN are empty ("None", "None.", "N/A", or just whitespace after header)
+    const hasGreen = /###\s*GREEN/i.test(output);
+    const criticalEmpty = /###\s*CRITICAL\s*\n+(?:None\.?|N\/A|—|\s*\n)/i.test(output);
+    const warnEmpty = /###\s*WARN\s*\n+(?:None\.?|N\/A|—|\s*\n)/i.test(output);
+    if (hasGreen && criticalEmpty && warnEmpty)
+        return true;
+    return false;
+}
 async function spawnAgent(pool, slotId, opts, state, taskId, logger, onMessage, onSpawnStart, onSpawnEnd, mcpServers) {
     const agentName = opts.agent ?? 'claude';
     onSpawnStart?.(agentName);

package/package.json

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