create-claude-workspace 2.3.33 → 2.3.35

package/dist/scheduler/index.mjs

@@ -434,13 +434,14 @@ export async function runScheduler(opts) {
             if (!workDone) {
                 if (state.taskMode === 'interactive') {
                     // Interactive mode: wait for user input (no external polling)
-                    logger.info('Waiting for input...');
+                    tui.setIdle(true);
                     while (!stopping) {
                         const pending = readInbox(opts.projectDir);
                         if (pending.length > 0 || discoveredIssueStore.peek().length > 0)
                             break;
                         await sleep(500, stoppingRef);
                     }
+                    tui.setIdle(false);
                 }
                 else {
                     // No work → idle polling (platform/local)

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/dist/scheduler/ui/tui.mjs

@@ -52,7 +52,7 @@ export class TUI {
         this.state = {
             iteration: 0, maxIter: 0, loopStart: Date.now(), iterStart: 0,
             tools: 0, tokensIn: 0, tokensOut: 0, agents: [], taskName: '',
-            tasksDone: 0, tasksTotal: 0, paused: false, inputBuf: '',
+            tasksDone: 0, tasksTotal: 0, paused: false, idle: false, inputBuf: '',
             pendingInputs: [],
         };
         if (this.interactive) {
@@ -157,13 +157,13 @@ export class TUI {
     isPaused() { return this.state.paused; }
     addPendingInput(text) {
         this.state.pendingInputs.push(text);
-        this.log(`  ${ANSI_COLORS.gray}${ts()}${RESET}  ${ANSI_COLORS.magenta}▲${RESET}  ${ANSI_COLORS.white}Queued:${RESET} ${text}`);
+        this.log(`  ${ANSI_COLORS.gray}${ts()}${RESET}  ${ANSI_COLORS.magenta}${BOLD}▶ USER${RESET}  ${ANSI_COLORS.white}${text}${RESET}  ${ANSI_COLORS.gray}[queued #${this.state.pendingInputs.length}]${RESET}`, `  ${ts()}  ▶ USER  ${text}  [queued #${this.state.pendingInputs.length}]`);
         this.renderStatusBar();
     }
     consumePendingInput() {
         const item = this.state.pendingInputs.shift();
         if (item) {
-            this.log(`  ${ANSI_COLORS.gray}${ts()}${RESET}  ${ANSI_COLORS.green}▼${RESET}  ${ANSI_COLORS.white}Processing:${RESET} ${item}`);
+            this.log(`  ${ANSI_COLORS.gray}${ts()}${RESET}  ${ANSI_COLORS.green}${BOLD}▶ START${RESET}  ${ANSI_COLORS.white}${item}${RESET}`, `  ${ts()}  ▶ START  ${item}`);
             this.renderStatusBar();
         }
         return item;
@@ -194,24 +194,36 @@ export class TUI {
             lines.push(` ${ANSI_COLORS.gray}› type to send input${RESET}`);
         }
         // Line 3: Status bar (stats)
-        const elapsed = fmtDur(Date.now() - s.loopStart);
-        const iterTime = s.iterStart ? fmtDur(Date.now() - s.iterStart) : '—';
-        const pct = s.maxIter > 0 ? Math.round((s.iteration / s.maxIter) * 100) : 0;
-        const filled = Math.round((pct / 100) * 8);
-        const bar = `${ANSI_COLORS.green}${'\u2588'.repeat(filled)}${ANSI_COLORS.gray}${'\u2591'.repeat(8 - filled)}${RESET}`;
-        const tok = fmtTok(s.tokensIn + s.tokensOut);
-        const cur = s.agents.length > 0 ? s.agents[s.agents.length - 1] : '';
-        let stats = `\x1b[7m ${elapsed} | Iter ${s.iteration}/${s.maxIter} \x1b[27m ${bar} \x1b[7m ${iterTime} | ${ANSI_COLORS.cyan}${s.tools}${RESET}\x1b[7m tools | ${ANSI_COLORS.yellow}${tok}${RESET}\x1b[7m tok`;
-        if (cur) {
-            const col = ANSI_COLORS[agentColor(cur)] || '';
-            stats += ` | ${col}${BOLD}${cur}${RESET}\x1b[7m`;
+        if (s.idle) {
+            // Idle: static bar, no running timers
+            let stats = `\x1b[7m ${ANSI_COLORS.gray}IDLE${RESET}\x1b[7m — waiting for input`;
+            if (s.pendingInputs.length > 0)
+                stats += ` | ${ANSI_COLORS.magenta}${s.pendingInputs.length} queued${RESET}\x1b[7m`;
+            if (s.paused)
+                stats += ` | ${ANSI_COLORS.yellow}⏸ PAUSED${RESET}\x1b[7m`;
+            stats += ` ${RESET}`;
+            lines.push(stats);
+        }
+        else {
+            const elapsed = fmtDur(Date.now() - s.loopStart);
+            const iterTime = s.iterStart ? fmtDur(Date.now() - s.iterStart) : '—';
+            const pct = s.maxIter > 0 ? Math.round((s.iteration / s.maxIter) * 100) : 0;
+            const filled = Math.round((pct / 100) * 8);
+            const bar = `${ANSI_COLORS.green}${'\u2588'.repeat(filled)}${ANSI_COLORS.gray}${'\u2591'.repeat(8 - filled)}${RESET}`;
+            const tok = fmtTok(s.tokensIn + s.tokensOut);
+            const cur = s.agents.length > 0 ? s.agents[s.agents.length - 1] : '';
+            let stats = `\x1b[7m ${elapsed} | Iter ${s.iteration}/${s.maxIter} \x1b[27m ${bar} \x1b[7m ${iterTime} | ${ANSI_COLORS.cyan}${s.tools}${RESET}\x1b[7m tools | ${ANSI_COLORS.yellow}${tok}${RESET}\x1b[7m tok`;
+            if (cur) {
+                const col = ANSI_COLORS[agentColor(cur)] || '';
+                stats += ` | ${col}${BOLD}${cur}${RESET}\x1b[7m`;
+            }
+            if (s.taskName)
+                stats += ` | ${ANSI_COLORS.cyan}${statusTrunc(s.taskName, 30)}${RESET}\x1b[7m`;
+            if (s.paused)
+                stats += ` | ${ANSI_COLORS.yellow}⏸ PAUSED${RESET}\x1b[7m`;
+            stats += ` ${RESET}`;
+            lines.push(stats);
         }
-        if (s.taskName)
-            stats += ` | ${ANSI_COLORS.cyan}${statusTrunc(s.taskName, 30)}${RESET}\x1b[7m`;
-        if (s.paused)
-            stats += ` | ${ANSI_COLORS.yellow}⏸ PAUSED${RESET}\x1b[7m`;
-        stats += ` ${RESET}`;
-        lines.push(stats);
         return lines;
     }
     /** Plain-text version for testing / non-ANSI contexts. */
@@ -224,21 +236,31 @@ export class TUI {
             lines.push(` [${s.pendingInputs.length} queued] ${items}${more}`);
         }
         lines.push(s.inputBuf ? ` › ${s.inputBuf}` : ' › type to send input');
-        const elapsed = fmtDur(Date.now() - s.loopStart);
-        const iterTime = s.iterStart ? fmtDur(Date.now() - s.iterStart) : '—';
-        const pct = s.maxIter > 0 ? Math.round((s.iteration / s.maxIter) * 100) : 0;
-        const filled = Math.round((pct / 100) * 8);
-        const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(8 - filled);
-        const tok = fmtTok(s.tokensIn + s.tokensOut);
-        const cur = s.agents.length > 0 ? s.agents[s.agents.length - 1] : '';
-        let stats = ` ${elapsed} | Iter ${s.iteration}/${s.maxIter} ${bar} | ${iterTime} | ${s.tools} tools | ${tok} tok`;
-        if (cur)
-            stats += ` | ${cur}`;
-        if (s.taskName)
-            stats += ` | ${statusTrunc(s.taskName, 30)}`;
-        if (s.paused)
-            stats += ' | PAUSED';
-        lines.push(stats);
+        if (s.idle) {
+            let stats = ' IDLE — waiting for input';
+            if (s.pendingInputs.length > 0)
+                stats += ` | ${s.pendingInputs.length} queued`;
+            if (s.paused)
+                stats += ' | PAUSED';
+            lines.push(stats);
+        }
+        else {
+            const elapsed = fmtDur(Date.now() - s.loopStart);
+            const iterTime = s.iterStart ? fmtDur(Date.now() - s.iterStart) : '—';
+            const pct = s.maxIter > 0 ? Math.round((s.iteration / s.maxIter) * 100) : 0;
+            const filled = Math.round((pct / 100) * 8);
+            const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(8 - filled);
+            const tok = fmtTok(s.tokensIn + s.tokensOut);
+            const cur = s.agents.length > 0 ? s.agents[s.agents.length - 1] : '';
+            let stats = ` ${elapsed} | Iter ${s.iteration}/${s.maxIter} ${bar} | ${iterTime} | ${s.tools} tools | ${tok} tok`;
+            if (cur)
+                stats += ` | ${cur}`;
+            if (s.taskName)
+                stats += ` | ${statusTrunc(s.taskName, 30)}`;
+            if (s.paused)
+                stats += ' | PAUSED';
+            lines.push(stats);
+        }
         return lines;
     }
     clearStatusArea() {
@@ -321,6 +343,10 @@ export class TUI {
         this.log(`  ${BOLD}━━━ Iteration ${i}/${max}  ${pct}%  │ ${elapsed} elapsed ━━━${RESET}`);
         this.log('');
     }
+    setIdle(idle) {
+        this.state.idle = idle;
+        this.renderStatusBar();
+    }
     setTask(name, done, total) {
         this.state.taskName = name;
         this.state.tasksDone = done;

package/package.json

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