create-claude-workspace 2.3.18 → 2.3.20

package/README.md

@@ -65,6 +65,15 @@ Write to `.claude/scheduler/inbox.json` while the scheduler is running:
 
 The scheduler reads the inbox every iteration and processes messages immediately.
 
+#### Proactive problem resolution
+
+Agents never dismiss problems as "pre-existing." The scheduler injects a `report_issue` MCP tool into every agent. When an agent discovers an out-of-scope problem:
+
+- **Non-blocker**: calls `report_issue(severity: 'non-blocker')` and continues working
+- **Blocker**: calls `report_issue(severity: 'blocker')`, wraps up, and returns
+
+The scheduler records the issue locally (`discovered.ndjson`) and creates a platform issue (GitHub/GitLab) if available. Discovered issues enter the task queue on the next iteration.
+
 ### npx Options
 
 ```bash

package/dist/scheduler/agents/worker-pool.mjs

@@ -42,6 +42,8 @@ export class WorkerPool {
             queryOptions.agent = opts.agent;
         if (opts.model)
             queryOptions.model = opts.model;
+        if (opts.mcpServers)
+            queryOptions.mcpServers = opts.mcpServers;
         if (opts.resume) {
             queryOptions.resume = opts.resume;
         }

package/dist/scheduler/git/issue-creator.mjs

@@ -0,0 +1,54 @@
+// ─── Platform issue creation (GitHub/GitLab) ───
+// Creates issues on the remote platform for discovered problems.
+// Non-fatal — returns null on failure (local record always exists).
+import { execFileSync } from 'node:child_process';
+const CLI_TIMEOUT = 30_000;
+function run(cmd, args, cwd) {
+    return execFileSync(cmd, args, { cwd, timeout: CLI_TIMEOUT, stdio: 'pipe', encoding: 'utf-8' }).trim();
+}
+/**
+ * Create an issue on the remote platform.
+ * Returns the created issue info, or null if creation failed (non-fatal).
+ */
+export function createPlatformIssue(cwd, platform, opts) {
+    try {
+        if (platform === 'github')
+            return createGitHubIssue(cwd, opts);
+        return createGitLabIssue(cwd, opts);
+    }
+    catch {
+        return null;
+    }
+}
+function createGitHubIssue(cwd, opts) {
+    const args = ['issue', 'create', '--title', opts.title, '--body', opts.body];
+    for (const label of opts.labels) {
+        args.push('--label', label);
+    }
+    if (opts.milestone)
+        args.push('--milestone', opts.milestone);
+    const output = run('gh', args, cwd);
+    // gh issue create prints the URL: https://github.com/owner/repo/issues/42
+    const urlMatch = output.match(/https:\/\/github\.com\/[^/]+\/[^/]+\/issues\/(\d+)/);
+    if (!urlMatch)
+        return null;
+    return { number: parseInt(urlMatch[1], 10), url: urlMatch[0] };
+}
+function createGitLabIssue(cwd, opts) {
+    const args = ['issue', 'create', '--title', opts.title, '--description', opts.body];
+    if (opts.labels.length > 0) {
+        args.push('--label', opts.labels.join(','));
+    }
+    if (opts.milestone)
+        args.push('--milestone', opts.milestone);
+    const output = run('glab', args, cwd);
+    // glab outputs: Creating issue... or the URL
+    const urlMatch = output.match(/https:\/\/gitlab\.[^/]+\/[^/]+\/[^/]+\/-\/issues\/(\d+)/);
+    if (urlMatch)
+        return { number: parseInt(urlMatch[1], 10), url: urlMatch[0] };
+    // Fallback: look for issue number in output like "#42" or "issue #42"
+    const numMatch = output.match(/#(\d+)/);
+    if (numMatch)
+        return { number: parseInt(numMatch[1], 10), url: output };
+    return null;
+}

package/dist/scheduler/git/manager.mjs

@@ -15,7 +15,21 @@ export function createWorktree(projectDir, branchSlug, baseBranch) {
     if (existsSync(worktreePath)) {
         return worktreePath;
     }
-    git(['worktree', 'add', worktreePath, '-b', branchSlug, base], projectDir);
+    // If the branch already exists (locally or from remote), check it out instead of creating
+    if (branchExists(projectDir, branchSlug)) {
+        git(['worktree', 'add', worktreePath, branchSlug], projectDir);
+    }
+    else {
+        // Try fetching from remote in case it exists only on origin
+        try {
+            git(['fetch', 'origin', branchSlug], projectDir, PUSH_TIMEOUT);
+            git(['worktree', 'add', worktreePath, '-b', branchSlug, `origin/${branchSlug}`], projectDir);
+        }
+        catch {
+            // Branch doesn't exist anywhere — create new from base
+            git(['worktree', 'add', worktreePath, '-b', branchSlug, base], projectDir);
+        }
+    }
     return worktreePath;
 }
 export function cleanupWorktree(projectDir, worktreePath, branch) {
@@ -216,6 +230,120 @@ export function isBranchMerged(projectDir, branch) {
         return false;
     }
 }
+// ─── Branch cleanup ───
+/**
+ * Find and clean up local branches that are fully merged into main
+ * and have no associated worktree. Also removes their remote counterparts.
+ * Returns the list of cleaned branch names.
+ */
+export function cleanMergedBranches(projectDir) {
+    const main = getMainBranch(projectDir);
+    const cleaned = [];
+    // Get all local branches except main
+    let branches;
+    try {
+        const output = git(['branch', '--format', '%(refname:short)'], projectDir);
+        branches = output.split('\n').filter(b => b && b !== main);
+    }
+    catch {
+        return [];
+    }
+    // Get worktree branches to avoid cleaning active worktrees
+    const worktreeBranches = new Set();
+    try {
+        const wtOutput = git(['worktree', 'list', '--porcelain'], projectDir);
+        for (const line of wtOutput.split('\n')) {
+            if (line.startsWith('branch refs/heads/')) {
+                worktreeBranches.add(line.replace('branch refs/heads/', '').trim());
+            }
+        }
+    }
+    catch { /* ignore */ }
+    for (const branch of branches) {
+        if (worktreeBranches.has(branch))
+            continue;
+        if (isBranchMerged(projectDir, branch)) {
+            // Delete local branch
+            try {
+                git(['branch', '-d', branch], projectDir);
+            }
+            catch {
+                try {
+                    git(['branch', '-D', branch], projectDir);
+                }
+                catch {
+                    continue;
+                }
+            }
+            // Delete remote branch (best-effort)
+            deleteBranchRemote(projectDir, branch);
+            cleaned.push(branch);
+        }
+    }
+    return cleaned;
+}
+/**
+ * Clean up remote-tracking branches whose upstream has been deleted.
+ * Equivalent to `git fetch --prune`.
+ */
+export function pruneRemoteBranches(projectDir) {
+    try {
+        git(['fetch', '--prune'], projectDir, PUSH_TIMEOUT);
+    }
+    catch { /* best-effort */ }
+}
+/**
+ * Find local branches that are NOT merged into main, NOT in any worktree,
+ * and NOT the main branch itself. These are potentially abandoned/orphaned
+ * work that needs AI analysis to decide what to do with them.
+ */
+export function findStaleUnmergedBranches(projectDir) {
+    const main = getMainBranch(projectDir);
+    const stale = [];
+    let branches;
+    try {
+        const output = git(['branch', '--format', '%(refname:short)'], projectDir);
+        branches = output.split('\n').filter(b => b && b !== main);
+    }
+    catch {
+        return [];
+    }
+    // Get worktree branches to exclude
+    const worktreeBranches = new Set();
+    try {
+        const wtOutput = git(['worktree', 'list', '--porcelain'], projectDir);
+        for (const line of wtOutput.split('\n')) {
+            if (line.startsWith('branch refs/heads/')) {
+                worktreeBranches.add(line.replace('branch refs/heads/', '').trim());
+            }
+        }
+    }
+    catch { /* ignore */ }
+    for (const branch of branches) {
+        if (worktreeBranches.has(branch))
+            continue;
+        if (isBranchMerged(projectDir, branch))
+            continue;
+        // Get commit info
+        try {
+            const aheadOutput = git(['rev-list', '--count', `${main}..${branch}`], projectDir);
+            const commitsAhead = parseInt(aheadOutput, 10) || 0;
+            if (commitsAhead === 0)
+                continue; // No actual changes
+            const logOutput = git(['log', '-1', '--format=%s|||%aI', branch], projectDir);
+            const [lastCommitMsg, lastCommitDate] = logOutput.split('|||');
+            let hasRemote = false;
+            try {
+                git(['rev-parse', '--verify', `origin/${branch}`], projectDir);
+                hasRemote = true;
+            }
+            catch { /* no remote */ }
+            stale.push({ name: branch, commitsAhead, lastCommitMsg: lastCommitMsg ?? '', lastCommitDate: lastCommitDate ?? '', hasRemote });
+        }
+        catch { /* skip branches that can't be inspected */ }
+    }
+    return stale;
+}
 // ─── Git identity ───
 export function hasGitIdentity(projectDir) {
     try {

package/dist/scheduler/git/pr-manager.mjs

@@ -188,7 +188,6 @@ function getGitLabMRComments(cwd, mrIid) {
         return [];
     }
 }
-// ─── Merge PR ───
 export function mergePR(cwd, platform, prNumber, method = 'merge') {
     try {
         if (platform === 'github') {
@@ -201,10 +200,10 @@ export function mergePR(cwd, platform, prNumber, method = 'merge') {
                 args.push('--squash');
             run('glab', args, cwd, WRITE_TIMEOUT);
         }
-        return true;
+        return { success: true };
     }
-    catch {
-        return false;
+    catch (err) {
+        return { success: false, error: err.message?.split('\n')[0] };
     }
 }
 // ─── Issue label management ───

package/dist/scheduler/index.mjs

@@ -14,6 +14,7 @@ import { runIteration } from './loop.mjs';
 import { checkAuth } from './agents/health-checker.mjs';
 import { pollForNewWork } from './util/idle-poll.mjs';
 import { TUI } from './ui/tui.mjs';
+import { DiscoveredIssueStore } from './tools/report-issue.mjs';
 // ─── Args ───
 export function parseSchedulerArgs(argv) {
     const opts = { ...SCHEDULER_DEFAULTS };
@@ -281,6 +282,8 @@ export async function runScheduler(opts) {
     const onMessage = (msg) => tui.handleMessage(msg);
     const onSpawnStart = (name) => tui.pushAgent(name);
     const onSpawnEnd = () => tui.popAgent();
+    // Discovered issue store (shared across all agent spawns)
+    const discoveredIssueStore = new DiscoveredIssueStore();
     // Orchestrator client
     const orchestrator = new OrchestratorClient({
         pool,
@@ -317,6 +320,7 @@ export async function runScheduler(opts) {
                 state,
                 opts,
                 logger,
+                discoveredIssueStore,
                 onMessage,
                 onSpawnStart,
                 onSpawnEnd,

package/dist/scheduler/loop.mjs

@@ -8,13 +8,15 @@ 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, deleteBranchRemote, } from './git/manager.mjs';
-import { createPR, getPRStatus, getPRComments, mergePR } from './git/pr-manager.mjs';
+import { createWorktree, commitInWorktree, getChangedFiles, cleanupWorktree, mergeToMain, syncMain, pushWorktree, forcePushWorktree, rebaseOnMain, cleanMainForMerge, popStash, getMainBranch, listWorktrees, listOrphanedWorktrees, isBranchMerged, getCurrentBranch, hasUncommittedChanges, deleteBranchRemote, cleanMergedBranches, pruneRemoteBranches, findStaleUnmergedBranches, } from './git/manager.mjs';
+import { createPR, getPRStatus, getPRComments, mergePR, closePR } from './git/pr-manager.mjs';
 import { scanAgents } from './agents/health-checker.mjs';
 import { detectCIPlatform, fetchFailureLogs } from './git/ci-watcher.mjs';
 import { createRelease } from './git/release.mjs';
 import { processInbox, addTaskMessageToTask } from './tasks/inbox.mjs';
 import { buildPlanPrompt, buildImplementPrompt, buildQAPrompt, buildReviewPrompt, buildReworkPrompt, buildCIFixPrompt, buildPRCommentPrompt, } from './agents/prompt-builder.mjs';
+import { discoveredIssueToTask } from './tools/report-issue.mjs';
+import { createSchedulerToolServer } from './tools/scheduler-tools.mjs';
 const MAX_REVIEW_CYCLES = 5;
 const MAX_BUILD_FIXES = 3;
 const MAX_CI_FIXES = 3;
@@ -28,15 +30,16 @@ export async function runIteration(deps) {
     // Rotate log if needed
     rotateLog(projectDir);
     // Process inbox — immediate, non-blocking
+    const inboxTasks = [];
     const inboxMessages = processInbox(projectDir);
     for (const msg of inboxMessages) {
         if (msg.type === 'add-task') {
             const addMsg = msg;
             const nextId = `inbox-${Date.now()}`;
             const newTask = addTaskMessageToTask(addMsg, state.currentPhase, nextId);
+            inboxTasks.push(newTask);
             logger.info(`[inbox] New task: ${newTask.title}`);
             appendEvent(projectDir, createEvent('task_started', { taskId: nextId, detail: `inbox: ${newTask.title}` }));
-            // Task will be picked up when we load tasks below
         }
         else if (msg.type === 'message') {
             const freeMsg = msg;
@@ -129,6 +132,18 @@ export async function runIteration(deps) {
             }
         }
     }
+    // Merge inbox tasks into loaded tasks
+    if (inboxTasks.length > 0) {
+        tasks.push(...inboxTasks);
+    }
+    // Drain discovered issues from agent report_issue tool calls (previous iteration)
+    const discovered = deps.discoveredIssueStore.drain();
+    for (const issue of discovered) {
+        const task = discoveredIssueToTask(issue, state.currentPhase);
+        tasks.push(task);
+        logger.info(`[discovered] ${issue.severity}: ${issue.title} (reported by ${issue.reportedBy})`);
+        appendEvent(projectDir, createEvent('issue_discovered', { taskId: task.id, detail: `${issue.severity}: ${issue.title}` }));
+    }
     // Reconcile task status with scheduler state (handles restart without --resume)
     for (const task of tasks) {
         if (state.completedTasks.includes(task.id) && task.status !== 'done') {
@@ -200,13 +215,7 @@ export async function runIteration(deps) {
         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;
-            }
+            const branch = pipeline.branchSlug;
             logger.info(`[${taskId}] PR merged via platform`);
             appendEvent(projectDir, createEvent('pr_merged', { taskId }));
             syncMain(projectDir);
@@ -228,10 +237,11 @@ export async function runIteration(deps) {
             workDone = true;
         }
         else if (result === 'failed') {
-            logger.error(`[${taskId}] PR failed — skipping task`);
+            logger.error(`[${taskId}] PR failed — all recovery strategies exhausted, skipping task`);
             pipeline.step = 'failed';
             state.skippedTasks.push(taskId);
             delete state.pipelines[taskId];
+            appendEvent(projectDir, createEvent('task_skipped', { taskId, detail: 'PR merge failed after all recovery attempts' }));
             workDone = true;
         }
         else if (result === 'rework') {
@@ -266,6 +276,7 @@ export async function runIteration(deps) {
                 issueMarker: taskId,
                 kitUpgrade: false,
                 lineNumber: 0,
+                source: 'todo',
                 status: 'in-progress',
                 changelog: 'changed',
             };
@@ -364,12 +375,16 @@ 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 per-pipeline MCP server with scheduler tools (report_issue, etc.)
+    const ciPlatform = detectCIPlatform(projectDir);
+    const mcpServer = createSchedulerToolServer(deps.discoveredIssueStore, task.id, projectDir, ciPlatform === 'none' ? 'none' : ciPlatform);
+    const mcpServers = { 'scheduler-tools': mcpServer };
     // 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));
+    const slug = existing?.branchSlug ?? taskToSlug(task);
+    const worktreePath = existing?.worktreePath ?? createWorktree(projectDir, slug);
     if (!existing) {
         logger.info(`[${task.id}] Worktree created: ${taskToSlug(task)}`);
     }
@@ -378,6 +393,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
         taskId: task.id,
         workerId,
         worktreePath,
+        branchSlug: slug,
         step: 'plan',
         architectPlan: null,
         apiContract: null,
@@ -388,6 +404,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
         buildFixes: 0,
         assignedAgent: null,
         prState: null,
+        approvalWaitingSince: null,
     };
     pipeline.workerId = workerId;
     state.pipelines[task.id] = pipeline;
@@ -417,7 +434,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                 cwd: worktreePath,
                 prompt: buildPlanPrompt({ task, worktreePath, projectDir }),
                 model: getAgentModel(pipeline.assignedAgent, agents, task),
-            }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
+            }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd, mcpServers);
             if (!planResult.success) {
                 logger.error(`[${task.id}] Planning failed: ${planResult.error}`);
                 return false;
@@ -445,7 +462,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                     apiContract: pipeline.apiContract ?? undefined,
                 }),
                 model: getAgentModel(implAgent, agents, task),
-            }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
+            }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd, mcpServers);
             if (!implResult.success) {
                 logger.error(`[${task.id}] Implementation failed: ${implResult.error}`);
                 return false;
@@ -464,7 +481,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                     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(pipeline.assignedAgent, agents, task),
-            }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
+            }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd, mcpServers);
         }
         // STEP 3: QA (E2E tests, integration tests, acceptance criteria verification)
         // Only for tasks that need it — skip for pure refactoring, config changes, etc.
@@ -483,7 +500,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                         testingSection: pipeline.testingSection ?? undefined,
                     }),
                     model: getAgentModel(qaRouting.agent, agents, task),
-                }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
+                }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd, mcpServers);
                 if (!qaResult.success) {
                     pipeline.buildFixes++;
                     if (pipeline.buildFixes >= MAX_BUILD_FIXES) {
@@ -516,7 +533,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                         testingSection: pipeline.testingSection ?? undefined,
                     }),
                     model: getAgentModel(reviewRouting.agent, agents, task),
-                }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
+                }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd, mcpServers);
                 if (reviewResult.output.includes('**PASS**') || reviewResult.output.includes('PASS')) {
                     reviewPassed = true;
                 }
@@ -538,7 +555,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                                 reviewFindings: pipeline.reviewFindings,
                             }),
                             model: getAgentModel(pipeline.assignedAgent, agents, task),
-                        }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
+                        }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd, mcpServers);
                         pipeline.step = 're-review';
                     }
                 }
@@ -563,6 +580,17 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                 logger.warn(`[${task.id}] Nothing to commit`);
             }
         } // end if !shouldSkip('commit')
+        // If branch has no changes vs main, there's nothing to push/merge — skip to done
+        const changedFromMain = getChangedFiles(worktreePath);
+        if (changedFromMain.length === 0) {
+            logger.warn(`[${task.id}] Branch has no changes vs main — nothing to merge`);
+            cleanupWorktree(projectDir, worktreePath, slug);
+            deleteBranchRemote(projectDir, slug);
+            pipeline.step = 'done';
+            clearSession(state, task.id);
+            delete state.pipelines[task.id];
+            return true; // Not a failure, just nothing to do
+        }
         const commitMsg = `feat: ${task.title}${task.issueMarker ? ` (${task.issueMarker})` : ''}`;
         // STEP 6: Push + PR/MR flow
         const ciPlatform = detectCIPlatform(projectDir);
@@ -582,7 +610,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                 pipeline.step = 'pr-create';
                 appendEvent(projectDir, createEvent('step_changed', { taskId: task.id, step: 'pr-create' }));
                 const issueNum = extractIssueNumber(task.issueMarker);
-                const mainBranch = getCurrentBranchFromProject(projectDir);
+                const mainBranch = getMainBranch(projectDir);
                 try {
                     const prInfo = createPR({
                         cwd: projectDir,
@@ -668,7 +696,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
     }
 }
 // ─── Helpers ───
-async function spawnAgent(pool, slotId, opts, state, taskId, logger, onMessage, onSpawnStart, onSpawnEnd) {
+async function spawnAgent(pool, slotId, opts, state, taskId, logger, onMessage, onSpawnStart, onSpawnEnd, mcpServers) {
     const agentName = opts.agent ?? 'claude';
     onSpawnStart?.(agentName);
     // Check for existing session (resume on crash)
@@ -677,6 +705,7 @@ async function spawnAgent(pool, slotId, opts, state, taskId, logger, onMessage,
         ...opts,
         resume: existingSession ?? undefined,
         onMessage,
+        mcpServers,
     });
     onSpawnEnd?.();
     // Record session for crash recovery
@@ -789,6 +818,7 @@ export async function recoverOrphanedWorktrees(projectDir, state, logger, _deps)
                 taskId,
                 workerId: -1, // Will be assigned when picked up
                 worktreePath,
+                branchSlug: branch,
                 step,
                 architectPlan: null,
                 apiContract: null,
@@ -799,6 +829,7 @@ export async function recoverOrphanedWorktrees(projectDir, state, logger, _deps)
                 buildFixes: 0,
                 assignedAgent: null,
                 prState: null,
+                approvalWaitingSince: null,
             };
         }
         catch (err) {
@@ -809,6 +840,104 @@ export async function recoverOrphanedWorktrees(projectDir, state, logger, _deps)
     if (ciPlatform !== 'none') {
         recoverOpenMRs(projectDir, ciPlatform, state, logger);
     }
+    // Phase 3: Clean up merged branches (local + remote) and prune stale remote refs
+    pruneRemoteBranches(projectDir);
+    const cleaned = cleanMergedBranches(projectDir);
+    if (cleaned.length > 0) {
+        logger.info(`[recovery] Cleaned ${cleaned.length} merged branch(es): ${cleaned.join(', ')}`);
+    }
+    // Phase 4: Analyze stale unmerged branches (no worktree, no MR, not merged)
+    // These need AI to decide: re-inject, delete, or ignore
+    await analyzeStaleUnmergedBranches(projectDir, state, logger, _deps);
+}
+/**
+ * Phase 4: Find branches with unmerged commits that have no worktree and no open MR.
+ * Ask orchestrator AI to decide what to do with each one.
+ */
+async function analyzeStaleUnmergedBranches(projectDir, state, logger, deps) {
+    const staleBranches = findStaleUnmergedBranches(projectDir);
+    if (staleBranches.length === 0)
+        return;
+    // Exclude branches already in pipelines
+    const pipelineBranches = new Set(Object.values(state.pipelines).map(p => p.branchSlug));
+    const unhandled = staleBranches.filter(b => !pipelineBranches.has(b.name));
+    if (unhandled.length === 0)
+        return;
+    logger.info(`[recovery] Found ${unhandled.length} stale unmerged branch(es) — consulting orchestrator`);
+    const branchSummary = unhandled.map(b => `- ${b.name}: ${b.commitsAhead} commit(s) ahead, last: "${b.lastCommitMsg}" (${b.lastCommitDate})${b.hasRemote ? ' [has remote]' : ' [local only]'}`).join('\n');
+    try {
+        const result = await deps.orchestrator.consult([
+            'The following git branches have unmerged commits but no active worktree or open MR.',
+            'For each branch, decide the action:',
+            '',
+            branchSummary,
+            '',
+            'Respond with a JSON array of objects: { "branch": "name", "action": "reinject" | "delete" | "ignore", "reason": "..." }',
+            '- "reinject": branch has valuable work that should be completed — create worktree and resume pipeline',
+            '- "delete": branch is abandoned/superseded/duplicate — safe to remove',
+            '- "ignore": leave it alone for now (e.g. user may be working on it manually)',
+        ].join('\n'));
+        // Parse AI decision
+        const jsonMatch = result.output.match(/\[[\s\S]*\]/);
+        if (!jsonMatch) {
+            logger.warn('[recovery] Orchestrator did not return valid JSON for stale branches');
+            return;
+        }
+        const decisions = JSON.parse(jsonMatch[0]);
+        for (const d of decisions) {
+            const branchInfo = unhandled.find(b => b.name === d.branch);
+            if (!branchInfo)
+                continue;
+            if (d.action === 'delete') {
+                logger.info(`[recovery] Deleting stale branch "${d.branch}": ${d.reason}`);
+                try {
+                    execFileSync('git', ['branch', '-D', d.branch], { cwd: projectDir, stdio: 'pipe', timeout: 10_000 });
+                }
+                catch { /* ignore */ }
+                deleteBranchRemote(projectDir, d.branch);
+            }
+            else if (d.action === 'reinject') {
+                logger.info(`[recovery] Re-injecting stale branch "${d.branch}": ${d.reason}`);
+                const issueNum = extractIssueFromBranch(d.branch);
+                const taskId = issueNum ? `#${issueNum}` : d.branch;
+                if (state.completedTasks.includes(taskId) || state.skippedTasks.includes(taskId)) {
+                    logger.info(`[recovery] Task ${taskId} already completed/skipped — skipping re-injection`);
+                    continue;
+                }
+                try {
+                    const worktreePath = createWorktree(projectDir, d.branch);
+                    const step = diagnoseStep(projectDir, d.branch, detectCIPlatform(projectDir));
+                    state.pipelines[taskId] = {
+                        taskId,
+                        workerId: -1,
+                        worktreePath,
+                        branchSlug: d.branch,
+                        step,
+                        architectPlan: null,
+                        apiContract: null,
+                        reviewFindings: null,
+                        testingSection: null,
+                        reviewCycles: 0,
+                        ciFixes: 0,
+                        buildFixes: 0,
+                        assignedAgent: null,
+                        prState: null,
+                        approvalWaitingSince: null,
+                    };
+                    logger.info(`[recovery] Branch "${d.branch}" re-injected at step "${step}"`);
+                }
+                catch (err) {
+                    logger.warn(`[recovery] Failed to re-inject "${d.branch}": ${err.message?.split('\n')[0]}`);
+                }
+            }
+            else {
+                logger.info(`[recovery] Ignoring stale branch "${d.branch}": ${d.reason}`);
+            }
+        }
+    }
+    catch (err) {
+        logger.warn(`[recovery] Stale branch analysis failed: ${err.message?.split('\n')[0]}`);
+    }
 }
 /** Diagnose which pipeline step a recovered worktree should resume from */
 export function diagnoseStep(projectDir, branch, ciPlatform) {
@@ -860,7 +989,13 @@ export function recoverOpenMRs(projectDir, platform, state, logger) {
                 continue;
             const prStatus = getPRStatus(projectDir, platform, mr.branch);
             if (prStatus.status === 'merged') {
-                logger.info(`[recovery] MR !${mr.number} already merged — closing issue`);
+                logger.info(`[recovery] MR !${mr.number} already merged — cleaning up branch + closing issue`);
+                // Clean up local branch if it exists (no worktree, but branch may linger)
+                try {
+                    execFileSync('git', ['branch', '-d', mr.branch], { cwd: projectDir, stdio: 'pipe', timeout: 10_000 });
+                }
+                catch { /* may not exist */ }
+                deleteBranchRemote(projectDir, mr.branch);
                 closeRecoveredIssue(projectDir, mr.branch, logger);
                 continue;
             }
@@ -881,12 +1016,12 @@ export function recoverOpenMRs(projectDir, platform, state, logger) {
                 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,
+                    branchSlug: mr.branch,
                     step,
                     architectPlan: null,
                     apiContract: null,
@@ -897,6 +1032,7 @@ export function recoverOpenMRs(projectDir, platform, state, logger) {
                     buildFixes: 0,
                     assignedAgent: null,
                     prState: { prNumber: mr.number, url: '', issueNumber: issueNum },
+                    approvalWaitingSince: null,
                 };
             }
             catch (err) {
@@ -937,6 +1073,7 @@ function loadTasksJson(path) {
             issueMarker: t.issueMarker ?? null,
             kitUpgrade: t.kitUpgrade ?? false,
             lineNumber: t.lineNumber ?? 0,
+            source: t.source ?? 'todo',
             changelog: t.changelog ?? 'added',
         })));
     }
@@ -951,33 +1088,165 @@ async function checkPRWatch(taskId, pipeline, projectDir, agents, deps) {
     const ciPlatform = detectCIPlatform(projectDir);
     if (ciPlatform === 'none' || !pipeline.prState)
         return 'failed';
-    const branch = getCurrentBranch(pipeline.worktreePath);
+    const branch = pipeline.branchSlug;
     try {
         const prStatus = getPRStatus(projectDir, ciPlatform, branch);
         if (prStatus.status === 'merged')
             return 'merged';
-        if (prStatus.status === 'closed')
+        // PR was closed (not merged) — try local merge as fallback before giving up
+        if (prStatus.status === 'closed') {
+            logger.warn(`[${taskId}] PR was closed without merging — attempting local merge fallback`);
+            syncMain(projectDir);
+            const stashed = cleanMainForMerge(projectDir);
+            const localMerge = mergeToMain(projectDir, pipeline.branchSlug);
+            if (localMerge.success) {
+                logger.info(`[${taskId}] Local merge succeeded after closed PR (${localMerge.sha?.slice(0, 7)})`);
+                if (stashed)
+                    popStash(projectDir);
+                return 'merged';
+            }
+            if (stashed)
+                popStash(projectDir);
+            logger.error(`[${taskId}] Local merge also failed after closed PR: ${localMerge.error}`);
             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';
+            const mergeResult = mergePR(projectDir, ciPlatform, prStatus.number);
+            if (mergeResult.success)
+                return 'merged';
+            // Platform merge failed — diagnose and try to recover
+            logger.warn(`[${taskId}] Platform merge failed: ${mergeResult.error} — attempting recovery`);
+            // Step 1: Try rebase onto main and force-push
+            const rebaseResult = rebaseOnMain(pipeline.worktreePath, projectDir);
+            if (rebaseResult.success) {
+                logger.info(`[${taskId}] Rebased successfully — force-pushing`);
+                forcePushWorktree(pipeline.worktreePath);
+                return 'rework'; // Will re-check PR status next iteration
+            }
+            // Step 2: Rebase failed — delegate conflict resolution to agent
+            logger.warn(`[${taskId}] Rebase conflict — delegating to agent for resolution`);
+            const slot = pool.idleSlot();
+            if (slot) {
+                // Sync main and get conflict info
+                syncMain(projectDir);
+                const conflictFiles = rebaseResult.error ?? 'unknown conflict';
+                const task = {
+                    id: taskId, title: `Resolve merge conflict for ${taskId}`, phase: state.currentPhase,
+                    type: 'fullstack', complexity: 'S', dependsOn: [], issueMarker: taskId,
+                    kitUpgrade: false, lineNumber: 0, source: 'todo', status: 'in-progress', changelog: 'fixed',
+                };
+                // Fetch the main branch into the worktree so agent can see what changed
+                try {
+                    execFileSync('git', ['fetch', 'origin', getMainBranch(projectDir)], { cwd: pipeline.worktreePath, timeout: 60_000, stdio: 'pipe' });
+                }
+                catch { /* best-effort */ }
+                const fixResult = await spawnAgent(pool, slot.id, {
+                    agent: pipeline.assignedAgent ?? undefined,
+                    cwd: pipeline.worktreePath,
+                    prompt: [
+                        `The branch "${pipeline.branchSlug}" has merge conflicts with main that must be resolved.`,
+                        `Conflict info: ${conflictFiles}`,
+                        '',
+                        'Steps:',
+                        `1. Run: git rebase origin/${getMainBranch(projectDir)}`,
+                        '2. Resolve ALL conflicts in the reported files',
+                        '3. Stage resolved files with: git add <file>',
+                        '4. Continue rebase with: git rebase --continue',
+                        '5. If rebase is too complex, abort with: git rebase --abort, then merge main into the branch instead',
+                        '',
+                        'Do NOT commit separately — the rebase/merge handles commits.',
+                    ].join('\n'),
+                    model: getAgentModel(pipeline.assignedAgent, agents, task),
+                }, state, taskId, logger, onMessage, onSpawnStart, onSpawnEnd);
+                if (fixResult.success) {
+                    forcePushWorktree(pipeline.worktreePath);
+                    logger.info(`[${taskId}] Agent resolved conflicts — force-pushed, will re-check next iteration`);
+                    return 'rework';
+                }
+                logger.warn(`[${taskId}] Agent failed to resolve conflicts`);
+            }
+            else {
+                logger.info(`[${taskId}] No idle worker for conflict resolution — will retry next iteration`);
+                return 'waiting';
+            }
+            // Step 3: Agent failed — fall back to local merge
+            logger.warn(`[${taskId}] Falling back to local merge`);
+            syncMain(projectDir);
+            const stashed = cleanMainForMerge(projectDir);
+            const localMerge = mergeToMain(projectDir, pipeline.branchSlug);
+            if (localMerge.success) {
+                logger.info(`[${taskId}] Local merge succeeded (${localMerge.sha?.slice(0, 7)}) — closing PR`);
+                if (stashed)
+                    popStash(projectDir);
+                closePR(projectDir, ciPlatform, prStatus.number);
+                return 'merged';
+            }
+            if (stashed)
+                popStash(projectDir);
+            logger.error(`[${taskId}] All merge strategies exhausted: ${localMerge.error}`);
+            return '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
+        // CI canceled — force-push to re-trigger pipeline
+        if (prStatus.ciStatus === 'canceled') {
+            logger.warn(`[${taskId}] CI was canceled — force-pushing to re-trigger pipeline`);
+            forcePushWorktree(pipeline.worktreePath);
+            return 'rework';
+        }
+        // CI passed but not mergeable — waiting for approval (with timeout)
         if (prStatus.ciStatus === 'passed' && !prStatus.mergeable) {
-            logger.info(`[${taskId}] CI passed, not mergeable — waiting`);
-            return 'waiting';
+            if (!pipeline.approvalWaitingSince) {
+                pipeline.approvalWaitingSince = Date.now();
+            }
+            const waitingMs = Date.now() - pipeline.approvalWaitingSince;
+            const APPROVAL_TIMEOUT = 30 * 60_000; // 30 minutes
+            if (waitingMs < APPROVAL_TIMEOUT) {
+                const waitMin = Math.round(waitingMs / 60_000);
+                logger.info(`[${taskId}] CI passed, waiting for approval (${waitMin}min/${APPROVAL_TIMEOUT / 60_000}min)`);
+                return 'waiting';
+            }
+            // Timeout reached — fall back to local merge (solo mode behavior)
+            logger.warn(`[${taskId}] Approval timeout (${APPROVAL_TIMEOUT / 60_000}min) — falling back to local merge`);
+            syncMain(projectDir);
+            const stashed = cleanMainForMerge(projectDir);
+            const localMerge = mergeToMain(projectDir, pipeline.branchSlug);
+            if (localMerge.success) {
+                logger.info(`[${taskId}] Local merge succeeded (${localMerge.sha?.slice(0, 7)}) — closing PR`);
+                if (stashed)
+                    popStash(projectDir);
+                closePR(projectDir, ciPlatform, prStatus.number);
+                return 'merged';
+            }
+            if (stashed)
+                popStash(projectDir);
+            logger.error(`[${taskId}] Local merge failed after approval timeout: ${localMerge.error}`);
+            return 'failed';
         }
+        // Reset approval timer if CI status changed from passed
+        pipeline.approvalWaitingSince = null;
         // 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`);
+                logger.warn(`[${taskId}] CI fix limit (${MAX_CI_FIXES}) reached — falling back to local merge`);
+                syncMain(projectDir);
+                const stashed = cleanMainForMerge(projectDir);
+                const localMerge = mergeToMain(projectDir, pipeline.branchSlug);
+                if (localMerge.success) {
+                    logger.info(`[${taskId}] Local merge succeeded after CI fix limit (${localMerge.sha?.slice(0, 7)}) — closing PR`);
+                    if (stashed)
+                        popStash(projectDir);
+                    closePR(projectDir, ciPlatform, prStatus.number);
+                    return 'merged';
+                }
+                if (stashed)
+                    popStash(projectDir);
+                logger.error(`[${taskId}] Local merge also failed: ${localMerge.error}`);
                 return 'failed';
             }
             pipeline.ciFixes++;
@@ -993,7 +1262,7 @@ async function checkPRWatch(taskId, pipeline, projectDir, agents, deps) {
             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',
+                kitUpgrade: false, lineNumber: 0, source: 'todo', status: 'in-progress', changelog: 'fixed',
             };
             const fixResult = await spawnAgent(pool, slot.id, {
                 agent: pipeline.assignedAgent ?? undefined,
@@ -1025,7 +1294,7 @@ async function checkPRWatch(taskId, pipeline, projectDir, agents, deps) {
             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',
+                kitUpgrade: false, lineNumber: 0, source: 'todo', status: 'in-progress', changelog: 'fixed',
             };
             const result = await spawnAgent(pool, slot.id, {
                 agent: pipeline.assignedAgent ?? undefined,
@@ -1063,7 +1332,7 @@ 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`);
-            return mergePR(projectDir, platform, prStatus.number);
+            return mergePR(projectDir, platform, prStatus.number).success;
         }
         // CI still running or not started — poll
         if (prStatus.ciStatus === 'pending' || prStatus.ciStatus === 'not-found') {
@@ -1180,9 +1449,6 @@ export function extractIssueFromBranch(branch) {
     const match = branch.match(/#?(\d+)/);
     return match ? parseInt(match[1], 10) : null;
 }
-function getCurrentBranchFromProject(projectDir) {
-    return getMainBranch(projectDir);
-}
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }

package/dist/scheduler/tasks/inbox.mjs

@@ -66,6 +66,7 @@ export function addTaskMessageToTask(msg, phase, nextId) {
         issueMarker: null,
         kitUpgrade: false,
         lineNumber: 0,
+        source: 'inbox',
         changelog: 'added',
     };
 }

package/dist/scheduler/tasks/issue-source.mjs

@@ -56,6 +56,7 @@ export function issueToTask(issue, fallbackPhase) {
         issueMarker: `#${issue.issueNumber}`,
         kitUpgrade: issue.labels.some(l => l.toLowerCase().includes('kit-upgrade')),
         lineNumber: 0, // not applicable for platform issues
+        source: 'platform',
         status,
         changelog: inferChangelog(issue.title, issue.labels),
     };

package/dist/scheduler/tasks/parser.mjs

@@ -111,6 +111,7 @@ export function parseTodoMd(content) {
             issueMarker: pendingTask.issueMarker,
             kitUpgrade: meta.kitUpgrade,
             lineNumber: pendingTask.lineNumber,
+            source: 'todo',
             changelog: inferChangelogCategory(title, pendingTask.status),
         });
         pendingTask = null;

package/dist/scheduler/tools/report-issue.mjs

@@ -0,0 +1,94 @@
+// ─── report_issue MCP tool for agents ───
+// Allows agents to report discovered issues outside their current task scope.
+// Handler runs in-process in the scheduler — records locally + creates platform issues.
+import { appendFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { tool } from '@anthropic-ai/claude-agent-sdk';
+import { z } from 'zod/v4';
+import { createPlatformIssue } from '../git/issue-creator.mjs';
+// ─── In-memory store ───
+export class DiscoveredIssueStore {
+    issues = [];
+    add(issue) {
+        this.issues.push(issue);
+    }
+    /** Returns all issues and clears the store. */
+    drain() {
+        return this.issues.splice(0);
+    }
+    /** Read without clearing. */
+    peek() {
+        return this.issues;
+    }
+}
+// ─── Tool definition factory ───
+const DISCOVERED_NDJSON = '.claude/scheduler/discovered.ndjson';
+export function buildReportIssueTool(store, currentTaskId, projectDir, platform) {
+    return tool('report_issue', 'Report a discovered issue outside your current task scope. Use severity "non-blocker" for issues that don\'t prevent your work (then continue normally), or "blocker" for issues that prevent you from completing your task (then wrap up what you can and return).', {
+        title: z.string().describe('Concise issue title'),
+        type: z.enum(['frontend', 'backend', 'fullstack']).describe('Affected layer'),
+        complexity: z.enum(['S', 'M', 'L']).default('M').describe('Estimated complexity'),
+        severity: z.enum(['blocker', 'non-blocker']).describe('Whether this blocks your current task'),
+        description: z.string().describe('What is broken, where, and what the fix should look like'),
+        evidence: z.string().default('').describe('Error messages, file paths, stack traces'),
+    }, async (args) => {
+        const id = `discovered-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        const issue = {
+            id,
+            title: args.title,
+            type: args.type,
+            complexity: args.complexity,
+            severity: args.severity,
+            description: args.description,
+            evidence: args.evidence,
+            reportedBy: currentTaskId,
+            timestamp: Date.now(),
+        };
+        // Record in memory (scheduler drains on next iteration)
+        store.add(issue);
+        // Persist for crash recovery
+        try {
+            const ndjsonPath = resolve(projectDir, DISCOVERED_NDJSON);
+            appendFileSync(ndjsonPath, JSON.stringify(issue) + '\n', 'utf-8');
+        }
+        catch { /* best-effort — in-memory store is primary */ }
+        // Create platform issue if available
+        if (platform !== 'none') {
+            try {
+                const labels = [`discovered`, `type::${args.type}`, `complexity::${args.complexity}`, 'status::todo'];
+                const created = createPlatformIssue(projectDir, platform, {
+                    title: args.title,
+                    body: `**Discovered during:** ${currentTaskId}\n**Severity:** ${args.severity}\n\n${args.description}\n\n**Evidence:**\n\`\`\`\n${args.evidence}\n\`\`\``,
+                    labels,
+                });
+                if (created) {
+                    issue.platformIssue = created;
+                }
+            }
+            catch { /* non-fatal */ }
+        }
+        const platformNote = issue.platformIssue
+            ? ` Platform issue: ${issue.platformIssue.url}`
+            : '';
+        return {
+            content: [{ type: 'text', text: `Issue recorded: ${args.title} (${id}).${platformNote}` }],
+        };
+    });
+}
+// ─── Convert discovered issue to Task ───
+export function discoveredIssueToTask(issue, currentPhase) {
+    return {
+        id: issue.id,
+        title: issue.title,
+        phase: currentPhase,
+        type: issue.type,
+        complexity: issue.complexity,
+        dependsOn: [],
+        issueMarker: issue.platformIssue ? `#${issue.platformIssue.number}` : null,
+        kitUpgrade: false,
+        lineNumber: 0,
+        source: 'discovered',
+        status: 'todo',
+        changelog: 'added',
+    };
+}

package/dist/scheduler/tools/scheduler-tools.mjs

@@ -0,0 +1,17 @@
+// ─── In-process MCP server with scheduler-provided tools ───
+// Creates a per-agent MCP server instance injected into query() options.
+// Each agent gets its own server (currentTaskId differs per spawn).
+import { createSdkMcpServer } from '@anthropic-ai/claude-agent-sdk';
+import { buildReportIssueTool } from './report-issue.mjs';
+/**
+ * Create an in-process MCP server with scheduler tools for a specific agent.
+ * Returns a config that can be passed to query() via options.mcpServers.
+ */
+export function createSchedulerToolServer(store, currentTaskId, projectDir, platform) {
+    const reportIssueTool = buildReportIssueTool(store, currentTaskId, projectDir, platform);
+    return createSdkMcpServer({
+        name: 'scheduler-tools',
+        version: '1.0.0',
+        tools: [reportIssueTool],
+    });
+}

package/dist/scheduler/ui/tui.mjs

@@ -290,8 +290,7 @@ export class TUI {
             return '';
         const cur = this.state.agents[this.state.agents.length - 1];
         const col = ANSI_COLORS[agentColor(cur)] || '';
-        const name = cur.length > 24 ? cur.slice(0, 24) : cur;
-        return `${col}${name.padEnd(25)}${RESET}`;
+        return `${col}${cur}${RESET}  `;
     }
     // ─── Public API ───
     banner() {
@@ -304,10 +303,10 @@ export class TUI {
         }
         this.log('');
     }
-    info(msg) { this.log(`  ${this.prefix()}${ANSI_COLORS.gray}${ts()}${RESET}  ${ANSI_COLORS.blue}ℹ${RESET}  ${msg}`); }
-    warn(msg) { this.log(`  ${this.prefix()}${ANSI_COLORS.gray}${ts()}${RESET}  ${ANSI_COLORS.yellow}⚠  ${msg}${RESET}`); }
-    error(msg) { this.log(`  ${this.prefix()}${ANSI_COLORS.gray}${ts()}${RESET}  ${ANSI_COLORS.red}✗  ${msg}${RESET}`); }
-    success(msg) { this.log(`  ${this.prefix()}${ANSI_COLORS.gray}${ts()}${RESET}  ${ANSI_COLORS.green}✓  ${msg}${RESET}`); }
+    info(msg) { this.log(`  ${ANSI_COLORS.gray}${ts()}${RESET}  ${this.prefix()}${ANSI_COLORS.blue}ℹ${RESET}  ${msg}`); }
+    warn(msg) { this.log(`  ${ANSI_COLORS.gray}${ts()}${RESET}  ${this.prefix()}${ANSI_COLORS.yellow}⚠  ${msg}${RESET}`); }
+    error(msg) { this.log(`  ${ANSI_COLORS.gray}${ts()}${RESET}  ${this.prefix()}${ANSI_COLORS.red}✗  ${msg}${RESET}`); }
+    success(msg) { this.log(`  ${ANSI_COLORS.gray}${ts()}${RESET}  ${this.prefix()}${ANSI_COLORS.green}✓  ${msg}${RESET}`); }
     setIteration(i, max) {
         this.state.iteration = i;
         this.state.maxIter = max;
@@ -363,7 +362,7 @@ export class TUI {
         }
         for (const block of content) {
             if (block.type === 'text' && block.text?.trim()) {
-                this.log(`  ${this.prefix()}${block.text}`, `TEXT: ${block.text}`);
+                this.log(`  ${ANSI_COLORS.gray}${ts()}${RESET}  ${this.prefix()}${block.text}`, `TEXT: ${block.text}`);
             }
             if (block.type === 'tool_use')
                 this.onToolUse(block);
@@ -383,7 +382,7 @@ export class TUI {
             const col = ANSI_COLORS[agentColor(type)] || '';
             // Don't push to agent stack — this is a sub-agent inside the SDK session.
             // Our external spawn lifecycle is managed by onSpawnStart/onSpawnEnd callbacks.
-            this.log(`  ${pre}${time}  ${icon}  ${col}${BOLD}${type}${RESET}${model ? ` ${ANSI_COLORS.gray}(${model})${RESET}` : ''} ${ANSI_COLORS.gray}${desc}${RESET}`, `AGENT: ${type} ${model} — ${desc}`);
+            this.log(`  ${time}  ${pre}${icon}  ${col}${BOLD}${type}${RESET}${model ? ` ${ANSI_COLORS.gray}(${model})${RESET}` : ''} ${ANSI_COLORS.gray}${desc}${RESET}`, `AGENT: ${type} ${model} — ${desc}`);
             return;
         }
         let detail;
@@ -406,7 +405,7 @@ export class TUI {
                 break;
             default: detail = `${ANSI_COLORS.gray}${JSON.stringify(input)}${RESET}`;
         }
-        this.log(`  ${pre}${time}  ${icon}  ${BOLD}${name}${RESET}  ${detail}`, `TOOL: ${name} ${JSON.stringify(input)}`);
+        this.log(`  ${time}  ${pre}${icon}  ${BOLD}${name}${RESET}  ${detail}`, `TOOL: ${name} ${JSON.stringify(input)}`);
     }
     onToolResult(msg) {
         const content = msg.message?.content;
@@ -419,15 +418,16 @@ export class TUI {
             if (!output)
                 continue;
             const pre = this.prefix();
+            const time = `${ANSI_COLORS.gray}${ts()}${RESET}`;
             if (block.is_error) {
-                this.log(`  ${pre}       ${ANSI_COLORS.red}✗ ${output}${RESET}`, `ERROR: ${output}`);
+                this.log(`  ${time}  ${pre}${ANSI_COLORS.red}✗ ${output}${RESET}`, `ERROR: ${output}`);
             }
             else {
                 const lines = output.split('\n');
                 const summary = lines.length > 3
                     ? `${lines.length} lines`
                     : output.replace(/\n/g, ' ').trim();
-                this.log(`  ${pre}       ${ANSI_COLORS.green}✓${RESET} ${DIM}${summary}${RESET}`, `OK: ${summary}`);
+                this.log(`  ${time}  ${pre}${ANSI_COLORS.green}✓${RESET} ${DIM}${summary}${RESET}`, `OK: ${summary}`);
             }
         }
     }
@@ -456,7 +456,7 @@ export class TUI {
             return;
         }
         if (msg.subtype === 'task_progress' && msg.description) {
-            this.log(`  ${this.prefix()}       ${DIM}${msg.description}${RESET}`, `PROGRESS: ${msg.description}`);
+            this.log(`  ${ANSI_COLORS.gray}${ts()}${RESET}  ${this.prefix()}${DIM}${msg.description}${RESET}`, `PROGRESS: ${msg.description}`);
             return;
         }
         if (msg.subtype === 'api_retry') {

package/dist/template/.claude/agents/angular-engineer.md

@@ -561,4 +561,8 @@ When reviewing Angular code, check:
 - @defer for heavy below-fold components
 - Naming: PascalCase components, lib- selectors, kebab-case files
 - i18n: ALL user-facing text has `i18n` attribute (templates) or `$localize` (TS) — no bare text
-- VRT: new pages/routes have corresponding `*.vrt.spec.ts` with 3-viewport coverage (375px, 768px, 1280px), baseline snapshots committed
+- VRT: new pages/routes have corresponding `*.vrt.spec.ts` with 3-viewport coverage (375px, 768px, 1280px), baseline snapshots committed
+
+## Out-of-Scope Issues
+
+If you discover problems outside your current task (broken infrastructure, misconfigurations, deprecated APIs in other code), use the `report_issue` tool to create a tracked issue. Set `severity: 'non-blocker'` and continue your work, or `severity: 'blocker'` if the problem prevents you from completing your task — in that case, finish what you can and return. Never dismiss problems as "pre-existing."

package/dist/template/.claude/agents/backend-ts-architect.md

@@ -136,3 +136,7 @@ When called for **direct implementation**, provide complete production-ready cod
 - Explain architectural decisions and trade-offs
 - Proactively identify potential issues
 - No fluff — every word serves a purpose
+
+## Out-of-Scope Issues
+
+If you discover problems outside your current task (broken infrastructure, misconfigurations, deprecated APIs in other code), use the `report_issue` tool to create a tracked issue. Set `severity: 'non-blocker'` and continue your work, or `severity: 'blocker'` if the problem prevents you from completing your task — in that case, finish what you can and return. Never dismiss problems as "pre-existing."

package/dist/template/.claude/agents/orchestrator.md

@@ -870,6 +870,19 @@ If a merge conflict occurs:
 4. Push: `git push origin HEAD`
 5. Then clean up: `git worktree remove .worktrees/feat/{slug} && git branch -d feat/{slug}`
 
+## Proactive Problem Resolution
+
+All agents have access to a `report_issue` tool provided by the scheduler. When an agent encounters a problem outside its current task scope, it calls this tool to create a tracked issue. The scheduler picks it up on the next iteration and routes it through the normal pipeline.
+
+**Agent behavior:**
+- **In-scope problem** → fix it directly (it's the agent's job)
+- **Out-of-scope, non-blocking** → call `report_issue` with `severity: 'non-blocker'`, then continue working
+- **Out-of-scope, blocking** → call `report_issue` with `severity: 'blocker'`, finish what's possible, then return
+- **Warnings are actionable** — unless they originate from inside a third-party package's own source code
+- **Never dismiss** — "pre-existing" and "not in scope" are not valid reasons to ignore a problem
+
+**Orchestrator does NOT process discovered issues.** The scheduler handles everything — creating tasks from `report_issue` calls, creating platform issues, and routing them to the right agent via the normal task queue. The orchestrator just picks tasks and delegates as usual.
+
 ## When Stuck
 
 NEVER stay stuck. Escalation order:

package/dist/template/.claude/agents/react-engineer.md

@@ -393,3 +393,7 @@ When reviewing React code, check:
 - No unstable nested component definitions (components defined inside render)
 - `React.memo` only on components with measured re-render cost — not as a default
 - VRT: new pages/routes have corresponding `*.vrt.spec.ts` with 3-viewport coverage (375px, 768px, 1280px), baseline snapshots committed
+
+## Out-of-Scope Issues
+
+If you discover problems outside your current task (broken infrastructure, misconfigurations, deprecated APIs in other code), use the `report_issue` tool to create a tracked issue. Set `severity: 'non-blocker'` and continue your work, or `severity: 'blocker'` if the problem prevents you from completing your task — in that case, finish what you can and return. Never dismiss problems as "pre-existing."

package/dist/template/.claude/agents/senior-code-reviewer.md

@@ -195,3 +195,7 @@ What is done well. Correct patterns, clean code, good decisions. Be specific.
 4. **Prioritize impact** — security > correctness > performance > style
 5. **Respect project standards** — align with CLAUDE.md conventions
 6. **Don't offer to fix** — this is not interactive, the user cannot respond
+
+## Out-of-Scope Issues
+
+If you discover problems outside your current task (broken infrastructure, misconfigurations, deprecated APIs in other code), use the `report_issue` tool to create a tracked issue. Set `severity: 'non-blocker'` and continue your work, or `severity: 'blocker'` if the problem prevents you from completing your task — in that case, finish what you can and return. Never dismiss problems as "pre-existing."

package/dist/template/.claude/agents/svelte-engineer.md

@@ -394,3 +394,7 @@ When reviewing Svelte code, check:
 - Callback props for outputs (not `createEventDispatcher` — that's Svelte 4)
 - Resource cleanup in `onDestroy` or `$effect` return for manual subscriptions
 - VRT: new pages/routes have corresponding `*.vrt.spec.ts` with 3-viewport coverage (375px, 768px, 1280px), baseline snapshots committed
+
+## Out-of-Scope Issues
+
+If you discover problems outside your current task (broken infrastructure, misconfigurations, deprecated APIs in other code), use the `report_issue` tool to create a tracked issue. Set `severity: 'non-blocker'` and continue your work, or `severity: 'blocker'` if the problem prevents you from completing your task — in that case, finish what you can and return. Never dismiss problems as "pre-existing."

package/dist/template/.claude/agents/test-engineer.md

@@ -538,3 +538,7 @@ Tests should be easy to write. If they are not, the production code needs refact
 - **No flaky tests** — if a test fails intermittently, fix it or delete it
 - **Test public API** — don't test private methods directly
 - **Pure functions are easy to test** — prefer pure transformations over stateful operations. If a function is hard to test, it likely has too many responsibilities or side effects.
+
+## Out-of-Scope Issues
+
+If you discover problems outside your current task (broken infrastructure, misconfigurations, deprecated APIs in other code), use the `report_issue` tool to create a tracked issue. Set `severity: 'non-blocker'` and continue your work, or `severity: 'blocker'` if the problem prevents you from completing your task — in that case, finish what you can and return. Never dismiss problems as "pre-existing."

package/dist/template/.claude/agents/ui-engineer.md

@@ -144,4 +144,8 @@ When called for **direct implementation**, provide:
 - TypeScript interfaces and types
 - Follow project conventions from CLAUDE.md (App Separation Principle, Onion Architecture layers)
 - Monorepo-compatible solutions for shared functionality
-- When uncertain about approach, ask for clarification before proceeding
+- When uncertain about approach, ask for clarification before proceeding
+
+## Out-of-Scope Issues
+
+If you discover problems outside your current task (broken infrastructure, misconfigurations, deprecated APIs in other code), use the `report_issue` tool to create a tracked issue. Set `severity: 'non-blocker'` and continue your work, or `severity: 'blocker'` if the problem prevents you from completing your task — in that case, finish what you can and return. Never dismiss problems as "pre-existing."

package/dist/template/.claude/agents/vue-engineer.md

@@ -423,3 +423,7 @@ When reviewing Vue code, check:
 - Naming: PascalCase components, `Base` prefix for atoms, `use` prefix for composables
 - i18n: ALL user-facing text goes through `$t()` / `t()` — no bare strings in templates or script
 - VRT: new pages/routes have corresponding `*.vrt.spec.ts` with 3-viewport coverage (375px, 768px, 1280px), baseline snapshots committed
+
+## Out-of-Scope Issues
+
+If you discover problems outside your current task (broken infrastructure, misconfigurations, deprecated APIs in other code), use the `report_issue` tool to create a tracked issue. Set `severity: 'non-blocker'` and continue your work, or `severity: 'blocker'` if the problem prevents you from completing your task — in that case, finish what you can and return. Never dismiss problems as "pre-existing."

package/package.json

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