create-claude-workspace 2.3.18 → 2.3.19

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/loop.mjs

@@ -8,8 +8,8 @@ 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';
@@ -200,13 +200,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 +222,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') {
@@ -368,8 +363,8 @@ async function runTaskPipeline(task, workerId, agents, deps) {
     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 +373,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
         taskId: task.id,
         workerId,
         worktreePath,
+        branchSlug: slug,
         step: 'plan',
         architectPlan: null,
         apiContract: null,
@@ -388,6 +384,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
         buildFixes: 0,
         assignedAgent: null,
         prState: null,
+        approvalWaitingSince: null,
     };
     pipeline.workerId = workerId;
     state.pipelines[task.id] = pipeline;
@@ -563,6 +560,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 +590,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,
@@ -789,6 +797,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 +808,7 @@ export async function recoverOrphanedWorktrees(projectDir, state, logger, _deps)
                 buildFixes: 0,
                 assignedAgent: null,
                 prState: null,
+                approvalWaitingSince: null,
             };
         }
         catch (err) {
@@ -809,6 +819,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 +968,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 +995,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 +1011,7 @@ export function recoverOpenMRs(projectDir, platform, state, logger) {
                     buildFixes: 0,
                     assignedAgent: null,
                     prState: { prNumber: mr.number, url: '', issueNumber: issueNum },
+                    approvalWaitingSince: null,
                 };
             }
             catch (err) {
@@ -951,33 +1066,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, 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++;
@@ -1063,7 +1310,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 +1427,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/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/orchestrator.md

@@ -870,6 +870,71 @@ 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}`
 
+## DISCOVERED ISSUES Protocol
+
+Agents encounter problems outside their current scope during work. This protocol gives them a structured way to report issues without breaking their flow, and ensures the orchestrator processes every report.
+
+### Agent-side: How agents report issues
+
+Every agent (architect, implementer, reviewer, test-engineer) MAY include a `## DISCOVERED ISSUES` section at the END of their response. Format:
+
+```
+## DISCOVERED ISSUES
+
+### [NON-BLOCKER] Title describing the problem
+- **Scope**: which agent should handle this (e.g., `deployment-engineer`, `backend-ts-architect`)
+- **Type**: frontend | backend | fullstack | devops
+- **Complexity**: S | M
+- **Description**: What is broken, where, and what the fix should look like
+- **Evidence**: error message, file:line, warning output
+
+### [BLOCKER] Title describing the blocking problem
+- **Scope**: which agent should handle this
+- **Type**: frontend | backend | fullstack | devops
+- **Complexity**: S | M
+- **Description**: What is broken and why it blocks the current task
+- **Evidence**: error message, file:line, warning output
+- **Impact**: What cannot proceed until this is resolved
+```
+
+**Agent rules:**
+- **In-scope problem** → fix it directly, do NOT add to DISCOVERED ISSUES (it's your job)
+- **Out-of-scope, non-blocking** → add as `[NON-BLOCKER]`, then **continue and deliver your task**
+- **Out-of-scope, blocking** → add as `[BLOCKER]`, finish what you can, then return. The orchestrator will handle delegation
+- **Warnings count** — treat project warnings as issues unless they originate from inside a third-party package's own source code. Misconfiguration or misuse of a third-party tool is a project problem.
+- **"Third-party issue" is narrow** — only valid when the bug is in the third-party package's source code itself
+- **Never dismiss** — if you see a problem, either fix it or report it. "Pre-existing" and "not in scope" are not valid reasons to ignore a problem.
+
+### Orchestrator-side: Processing DISCOVERED ISSUES
+
+**After EVERY agent delegation** (STEP 2, 3, 4, 5, 6, 7, 8), scan the agent's response for a `## DISCOVERED ISSUES` section. If present:
+
+#### NON-BLOCKER items → create tasks, continue current workflow
+1. **Local mode**: Add each item to TODO.md in the CURRENT phase (after the current task). Format:
+   ```
+   - [ ] **[Title from DISCOVERED ISSUES]** — [Description]. Discovered during #[current-task-id] (Complexity: [S|M], Type: [type])
+   ```
+2. **Platform mode**: Delegate to `devops-integrator`: "Create issues for these discovered problems: [list items]. Label: `status::todo`, `discovered`. Milestone: current phase. Do NOT perform git operations."
+3. **Continue with the current task** — non-blockers do NOT interrupt the workflow.
+
+#### BLOCKER items → resolve before continuing
+1. **Assess if truly blocking**: Can the current task still be completed without resolving this? If the agent completed their deliverable despite reporting `[BLOCKER]`, reclassify as `[NON-BLOCKER]` and process accordingly.
+2. **If blocking and in another agent's scope**: Delegate to the appropriate agent IMMEDIATELY (before continuing the current step). Include the evidence and description from the DISCOVERED ISSUES entry. This is an interruption to the current workflow — resume the current step after the blocker is resolved.
+3. **If blocking and unfixable now** (requires human action, external dependency, missing credentials): Mark the current task as `[~]` SKIPPED with reason referencing the blocker. Create the task for the blocker issue. Move to next task.
+4. **Max 1 blocker delegation per step** — if resolving a blocker reveals another blocker, skip the current task and create tasks for both blockers.
+
+#### Deduplication
+Before creating a task from a discovered issue:
+- Check TODO.md / platform issues for existing tasks with similar title or description
+- Check if the issue was already reported in a previous iteration (grep TODO.md for keywords)
+- Skip duplicates — do NOT create redundant tasks
+
+### Including the protocol in delegation prompts
+
+**Add this paragraph to ALL agent delegation prompts** (STEP 2, 3, 4, 6 — all Agent tool calls to specialist agents):
+
+> "If you encounter any problems, warnings, or broken infrastructure outside the scope of this task, include a `## DISCOVERED ISSUES` section at the end of your response. Use `[NON-BLOCKER]` for issues that don't prevent you from completing this task, `[BLOCKER]` for issues that do. Format: title, scope (which agent), type (frontend/backend/fullstack/devops), complexity (S/M), description, evidence. Do not dismiss issues as pre-existing — report everything you find."
+
 ## When Stuck
 
 NEVER stay stuck. Escalation order:

package/package.json

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