@litmers/cursorflow-orchestrator 0.1.20 → 0.1.28

package/dist/cli/resume.js

@@ -44,6 +44,7 @@ const state_1 = require("../utils/state");
 const doctor_1 = require("../utils/doctor");
 const path_1 = require("../utils/path");
 const enhanced_logger_1 = require("../utils/enhanced-logger");
+const log_formatter_1 = require("../utils/log-formatter");
 function printHelp() {
     console.log(`
 Usage: cursorflow resume [lane] [options]
@@ -51,7 +52,7 @@ Usage: cursorflow resume [lane] [options]
 Resume interrupted or failed lanes.
 
 Options:
-  <lane>                 Lane name to resume (single lane mode)
+  <lane>                 Lane name or tasks directory to resume
   --all                  Resume ALL incomplete/failed lanes
   --status               Show status of all lanes in the run (no resume)
   --run-dir <path>       Use a specific run directory (default: latest)
@@ -67,8 +68,8 @@ Examples:
   cursorflow resume --status                 # Check status of all lanes
   cursorflow resume --all                    # Resume all incomplete lanes
   cursorflow resume lane-1                   # Resume single lane
+  cursorflow resume _cursorflow/tasks/feat1  # Resume all lanes in directory
   cursorflow resume --all --restart          # Restart all incomplete lanes from task 0
-  cursorflow resume --all --max-concurrent 2 # Resume with max 2 parallel lanes
   `);
 }
 function parseArgs(args) {
@@ -117,79 +118,138 @@ const STATUS_COLORS = {
 };
 const RESET = '\x1b[0m';
 /**
- * Format and print parsed message to console (copied from orchestrator.ts)
+ * Check if a process is alive by its PID
  */
-function handleParsedMessage(laneName, msg) {
-    const ts = new Date(msg.timestamp).toLocaleTimeString('en-US', { hour12: false });
-    const laneLabel = `[${laneName}]`.padEnd(12);
-    let prefix = '';
-    let content = msg.content;
-    switch (msg.type) {
-        case 'user':
-            prefix = `${logger.COLORS.cyan}🧑 USER${logger.COLORS.reset}`;
-            content = content.replace(/\n/g, ' ');
-            break;
-        case 'assistant':
-            prefix = `${logger.COLORS.green}🤖 ASST${logger.COLORS.reset}`;
-            break;
-        case 'tool':
-            prefix = `${logger.COLORS.yellow}🔧 TOOL${logger.COLORS.reset}`;
-            const toolMatch = content.match(/\[Tool: ([^\]]+)\] (.*)/);
-            if (toolMatch) {
-                const [, name, args] = toolMatch;
-                try {
-                    const parsedArgs = JSON.parse(args);
-                    let argStr = '';
-                    if (name === 'read_file' && parsedArgs.target_file)
-                        argStr = parsedArgs.target_file;
-                    else if (name === 'run_terminal_cmd' && parsedArgs.command)
-                        argStr = parsedArgs.command;
-                    else if (name === 'write' && parsedArgs.file_path)
-                        argStr = parsedArgs.file_path;
-                    else if (name === 'search_replace' && parsedArgs.file_path)
-                        argStr = parsedArgs.file_path;
-                    else {
-                        const keys = Object.keys(parsedArgs);
-                        if (keys.length > 0)
-                            argStr = String(parsedArgs[keys[0]]).substring(0, 50);
-                    }
-                    content = `${logger.COLORS.bold}${name}${logger.COLORS.reset}(${argStr})`;
-                }
-                catch {
-                    content = `${logger.COLORS.bold}${name}${logger.COLORS.reset}: ${args}`;
-                }
-            }
-            break;
-        case 'tool_result':
-            prefix = `${logger.COLORS.gray}📄 RESL${logger.COLORS.reset}`;
-            const resMatch = content.match(/\[Tool Result: ([^\]]+)\]/);
-            content = resMatch ? `${resMatch[1]} OK` : 'result';
-            break;
-        case 'result':
-            prefix = `${logger.COLORS.green}✅ DONE${logger.COLORS.reset}`;
-            break;
-        case 'system':
-            prefix = `${logger.COLORS.gray}⚙️  SYS${logger.COLORS.reset}`;
-            break;
-        case 'thinking':
-            prefix = `${logger.COLORS.gray}🤔 THNK${logger.COLORS.reset}`;
-            break;
-    }
-    if (prefix) {
-        const lines = content.split('\n');
-        const tsPrefix = `${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${logger.COLORS.magenta}${laneLabel}${logger.COLORS.reset}`;
-        if (msg.type === 'user' || msg.type === 'assistant' || msg.type === 'result' || msg.type === 'thinking') {
-            const header = `${prefix} ┌${'─'.repeat(60)}`;
-            process.stdout.write(`${tsPrefix} ${header}\n`);
-            for (const line of lines) {
-                process.stdout.write(`${tsPrefix} ${' '.repeat((0, enhanced_logger_1.stripAnsi)(prefix).length)} │ ${line}\n`);
+function isProcessAlive(pid) {
+    try {
+        // On Unix-like systems, sending signal 0 checks if process exists
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check for zombie "running" lanes and fix them
+ * A zombie lane is one that has status "running" but its process is dead
+ */
+function checkAndFixZombieLanes(runDir) {
+    const lanesDir = (0, path_1.safeJoin)(runDir, 'lanes');
+    if (!fs.existsSync(lanesDir)) {
+        return { fixed: [], pofCreated: false };
+    }
+    const fixed = [];
+    const zombieDetails = [];
+    const laneDirs = fs.readdirSync(lanesDir)
+        .filter(f => fs.statSync((0, path_1.safeJoin)(lanesDir, f)).isDirectory());
+    for (const laneName of laneDirs) {
+        const dir = (0, path_1.safeJoin)(lanesDir, laneName);
+        const statePath = (0, path_1.safeJoin)(dir, 'state.json');
+        if (!fs.existsSync(statePath))
+            continue;
+        const state = (0, state_1.loadState)(statePath);
+        if (!state)
+            continue;
+        // Check for zombie: status is "running" but process is dead
+        if (state.status === 'running' && state.pid) {
+            const alive = isProcessAlive(state.pid);
+            if (!alive) {
+                logger.warn(`🧟 Zombie lane detected: ${laneName} (PID ${state.pid} is dead)`);
+                // Update state to failed
+                const updatedState = {
+                    ...state,
+                    status: 'failed',
+                    error: `Process terminated unexpectedly (PID ${state.pid} was running but is now dead)`,
+                    endTime: Date.now(),
+                };
+                (0, state_1.saveState)(statePath, updatedState);
+                fixed.push(laneName);
+                zombieDetails.push({
+                    name: laneName,
+                    pid: state.pid,
+                    taskIndex: state.currentTaskIndex,
+                    totalTasks: state.totalTasks,
+                });
+                logger.info(`  → Status changed to 'failed', ready for resume`);
             }
-            process.stdout.write(`${tsPrefix} ${' '.repeat((0, enhanced_logger_1.stripAnsi)(prefix).length)} └${'─'.repeat(60)}\n`);
         }
-        else {
-            process.stdout.write(`${tsPrefix} ${prefix} ${content}\n`);
+    }
+    // Create POF file if any zombies were found
+    let pofCreated = false;
+    if (zombieDetails.length > 0) {
+        const config = (0, config_1.loadConfig)();
+        const pofDir = (0, config_1.getPofDir)(config);
+        if (!fs.existsSync(pofDir)) {
+            fs.mkdirSync(pofDir, { recursive: true });
+        }
+        const runId = path.basename(runDir);
+        const pofPath = (0, path_1.safeJoin)(pofDir, `pof-${runId}.json`);
+        let existingPof = null;
+        try {
+            existingPof = JSON.parse(fs.readFileSync(pofPath, 'utf-8'));
+        }
+        catch {
+            // Ignore errors (file might not exist)
+        }
+        const pof = {
+            title: 'Run Failure Post-mortem',
+            runId: path.basename(runDir),
+            failureTime: new Date().toISOString(),
+            detectedAt: new Date().toISOString(),
+            summary: `${zombieDetails.length} lane(s) found with dead processes (zombie state)`,
+            rootCause: {
+                type: 'ZOMBIE_PROCESS',
+                description: 'Lane processes were marked as running but the processes are no longer alive',
+                symptoms: [
+                    'Process PIDs no longer exist in the system',
+                    'Lanes were stuck in "running" state',
+                    'No completion or error was recorded before process death',
+                ],
+            },
+            affectedLanes: zombieDetails.map(z => ({
+                name: z.name,
+                status: 'failed (was: running)',
+                task: `[${z.taskIndex + 1}/${z.totalTasks}]`,
+                taskIndex: z.taskIndex,
+                pid: z.pid,
+                reason: 'Process terminated unexpectedly',
+            })),
+            possibleCauses: [
+                'System killed process due to memory pressure (OOM)',
+                'User killed process manually (Ctrl+C, kill command)',
+                'Agent timeout exceeded and process was terminated',
+                'System restart or crash',
+                'Agent hung and watchdog terminated it',
+            ],
+            recovery: {
+                command: `cursorflow resume --all --run-dir ${runDir}`,
+                description: 'Resume all failed lanes from their last checkpoint',
+                alternativeCommand: `cursorflow resume --all --restart --run-dir ${runDir}`,
+                alternativeDescription: 'Restart all failed lanes from the beginning',
+            },
+            // Merge with existing POF if present
+            previousFailures: existingPof ? [existingPof] : undefined,
+        };
+        // Use atomic write: write to temp file then rename
+        const tempPath = `${pofPath}.${Math.random().toString(36).substring(2, 7)}.tmp`;
+        try {
+            fs.writeFileSync(tempPath, JSON.stringify(pof, null, 2), 'utf8');
+            fs.renameSync(tempPath, pofPath);
+            pofCreated = true;
+            logger.info(`📋 POF file created: ${pofPath}`);
+        }
+        catch (err) {
+            // If temp file was created, try to clean it up
+            try {
+                if (fs.existsSync(tempPath))
+                    fs.unlinkSync(tempPath);
+            }
+            catch { /* ignore */ }
+            throw err;
         }
     }
+    return { fixed, pofCreated };
 }
 /**
  * Get all lane statuses from a run directory
@@ -334,50 +394,25 @@ function spawnLaneResume(laneName, laneDir, state, options) {
     if (options.executor) {
         runnerArgs.push('--executor', options.executor);
     }
-    const logManager = (0, enhanced_logger_1.createLogManager)(laneDir, laneName, options.enhancedLogConfig || {}, (msg) => handleParsedMessage(laneName, msg));
+    const logManager = (0, enhanced_logger_1.createLogManager)(laneDir, laneName, options.enhancedLogConfig || {}, (msg) => {
+        const formatted = (0, log_formatter_1.formatMessageForConsole)(msg, {
+            laneLabel: `[${laneName}]`,
+            includeTimestamp: true
+        });
+        process.stdout.write(formatted + '\n');
+    });
     const child = (0, child_process_1.spawn)('node', runnerArgs, {
         stdio: ['ignore', 'pipe', 'pipe'],
         env: process.env,
     });
-    let lineBuffer = '';
     if (child.stdout) {
         child.stdout.on('data', (data) => {
             logManager.writeStdout(data);
-            const str = data.toString();
-            lineBuffer += str;
-            const lines = lineBuffer.split('\n');
-            lineBuffer = lines.pop() || '';
-            for (const line of lines) {
-                const trimmed = line.trim();
-                if (trimmed &&
-                    !trimmed.startsWith('{') &&
-                    !trimmed.startsWith('[') &&
-                    !trimmed.includes('{"type"')) {
-                    process.stdout.write(`${logger.COLORS.gray}[${new Date().toLocaleTimeString('en-US', { hour12: false })}]${logger.COLORS.reset} ${logger.COLORS.magenta}${laneName.padEnd(10)}${logger.COLORS.reset} ${line}\n`);
-                }
-            }
         });
     }
     if (child.stderr) {
         child.stderr.on('data', (data) => {
             logManager.writeStderr(data);
-            const str = data.toString();
-            const lines = str.split('\n');
-            for (const line of lines) {
-                const trimmed = line.trim();
-                if (trimmed) {
-                    const isStatus = trimmed.startsWith('Preparing worktree') ||
-                        trimmed.startsWith('Switched to a new branch') ||
-                        trimmed.startsWith('HEAD is now at') ||
-                        trimmed.includes('actual output');
-                    if (isStatus) {
-                        process.stdout.write(`${logger.COLORS.gray}[${new Date().toLocaleTimeString('en-US', { hour12: false })}]${logger.COLORS.reset} ${logger.COLORS.magenta}${laneName.padEnd(10)}${logger.COLORS.reset} ${trimmed}\n`);
-                    }
-                    else {
-                        process.stderr.write(`${logger.COLORS.red}[${laneName}] ERROR: ${trimmed}${logger.COLORS.reset}\n`);
-                    }
-                }
-            }
         });
     }
     child.on('exit', () => {
@@ -401,19 +436,7 @@ function waitForChild(child) {
 /**
  * Resume multiple lanes with concurrency control and dependency awareness
  */
-async function resumeAllLanes(runDir, options) {
-    const allLanes = getAllLaneStatuses(runDir);
-    const lanesToResume = allLanes.filter(l => l.needsResume && l.state?.tasksFile);
-    const missingTaskInfo = allLanes.filter(l => l.needsResume && !l.state?.tasksFile);
-    if (missingTaskInfo.length > 0) {
-        logger.warn(`Lanes that haven't started yet and have no task info: ${missingTaskInfo.map(l => l.name).join(', ')}`);
-        logger.warn('These lanes cannot be resumed because their original task file paths were not recorded.');
-    }
-    if (lanesToResume.length === 0) {
-        logger.success('All lanes are already completed! Nothing to resume.');
-        return { succeeded: [], failed: [], skipped: [] };
-    }
-    // Check for lanes with unmet dependencies that can never be satisfied
+async function resumeLanes(lanesToResume, allLanes, options) {
     const completedSet = new Set(allLanes.filter(l => l.isCompleted).map(l => l.name));
     const toResumeNames = new Set(lanesToResume.map(l => l.name));
     const skippedLanes = [];
@@ -436,16 +459,9 @@ async function resumeAllLanes(runDir, options) {
     logger.section(`🔁 Resuming ${resolvableLanes.length} Lane(s)`);
     logger.info(`Max concurrent: ${options.maxConcurrent}`);
     logger.info(`Mode: ${options.restart ? 'Restart from beginning' : 'Continue from last task'}`);
-    // Show dependency order
-    const lanesWithDeps = resolvableLanes.filter(l => l.dependsOn.length > 0);
-    if (lanesWithDeps.length > 0) {
-        logger.info(`Dependency-aware: ${lanesWithDeps.length} lane(s) have dependencies`);
-    }
-    console.log('');
     // Run doctor check once if needed (check git status)
     if (!options.skipDoctor) {
         logger.info('Running pre-flight checks...');
-        // Use the first lane's tasksDir for doctor check
         const firstLane = resolvableLanes[0];
         const tasksDir = path.dirname(firstLane.state.tasksFile);
         const report = (0, doctor_1.runDoctor)({
@@ -466,15 +482,10 @@ async function resumeAllLanes(runDir, options) {
     }
     const succeeded = [];
     const failed = [];
-    // Create a mutable set for tracking completed lanes (including those from this session)
     const sessionCompleted = new Set(completedSet);
-    // Queue management with dependency awareness
     const pending = new Set(resolvableLanes.map(l => l.name));
     const active = new Map();
     const laneMap = new Map(resolvableLanes.map(l => [l.name, l]));
-    /**
-     * Find the next lane that can be started (all dependencies met)
-     */
     const findReadyLane = () => {
         for (const laneName of pending) {
             const lane = laneMap.get(laneName);
@@ -484,21 +495,15 @@ async function resumeAllLanes(runDir, options) {
         }
         return null;
     };
-    /**
-     * Process lanes with dependency awareness
-     */
     const processNext = () => {
         while (active.size < options.maxConcurrent) {
             const lane = findReadyLane();
             if (!lane) {
-                // No lane ready to start
                 if (pending.size > 0 && active.size === 0) {
-                    // Deadlock: pending lanes exist but none can start and none are running
                     const pendingList = Array.from(pending).join(', ');
                     logger.error(`Deadlock detected! Lanes waiting: ${pendingList}`);
-                    for (const ln of pending) {
+                    for (const ln of pending)
                         failed.push(ln);
-                    }
                     pending.clear();
                 }
                 break;
@@ -513,13 +518,12 @@ async function resumeAllLanes(runDir, options) {
                 enhancedLogConfig: options.enhancedLogConfig,
             });
             active.set(lane.name, child);
-            // Handle completion
             waitForChild(child).then(code => {
                 active.delete(lane.name);
                 if (code === 0) {
                     logger.success(`✓ ${lane.name} completed`);
                     succeeded.push(lane.name);
-                    sessionCompleted.add(lane.name); // Mark as completed for dependency resolution
+                    sessionCompleted.add(lane.name);
                 }
                 else if (code === 2) {
                     logger.warn(`⚠ ${lane.name} blocked on dependency change`);
@@ -529,7 +533,6 @@ async function resumeAllLanes(runDir, options) {
                     logger.error(`✗ ${lane.name} failed (exit ${code})`);
                     failed.push(lane.name);
                 }
-                // Try to start more lanes now that one completed
                 processNext();
             }).catch(err => {
                 active.delete(lane.name);
@@ -539,26 +542,20 @@ async function resumeAllLanes(runDir, options) {
             });
         }
     };
-    // Start initial batch
     processNext();
-    // Wait for all to complete
     while (active.size > 0 || pending.size > 0) {
         await new Promise(resolve => setTimeout(resolve, 1000));
-        // Check if we can start more (in case completion handlers haven't triggered processNext yet)
         if (active.size < options.maxConcurrent && pending.size > 0) {
             processNext();
         }
     }
-    // Summary
     console.log('');
     logger.section('📊 Resume Summary');
     logger.info(`Succeeded: ${succeeded.length}`);
-    if (failed.length > 0) {
+    if (failed.length > 0)
         logger.error(`Failed: ${failed.length} (${failed.join(', ')})`);
-    }
-    if (skippedLanes.length > 0) {
+    if (skippedLanes.length > 0)
         logger.warn(`Skipped: ${skippedLanes.length} (${skippedLanes.join(', ')})`);
-    }
     return { succeeded, failed, skipped: skippedLanes };
 }
 async function resume(args) {
@@ -569,7 +566,6 @@ async function resume(args) {
     }
     const config = (0, config_1.loadConfig)();
     const logsDir = (0, config_1.getLogsDir)(config);
-    // Find run directory
     let runDir = options.runDir;
     if (!runDir) {
         runDir = findLatestRunDir(logsDir);
@@ -577,110 +573,66 @@ async function resume(args) {
     if (!runDir || !fs.existsSync(runDir)) {
         throw new Error(`Run directory not found: ${runDir || 'latest'}. Have you run any tasks yet?`);
     }
-    // Status mode: just show status and exit
-    if (options.status) {
-        printAllLaneStatus(runDir);
-        return;
-    }
-    // All mode: resume all incomplete lanes
-    if (options.all) {
-        const result = await resumeAllLanes(runDir, {
-            restart: options.restart,
-            maxConcurrent: options.maxConcurrent,
-            skipDoctor: options.skipDoctor,
-            noGit: options.noGit,
-            executor: options.executor,
-            enhancedLogConfig: config.enhancedLogging,
-        });
-        if (result.failed.length > 0) {
-            throw new Error(`${result.failed.length} lane(s) failed to complete`);
+    const allLanes = getAllLaneStatuses(runDir);
+    let lanesToResume = [];
+    // Check if the lane argument is actually a tasks directory
+    if (options.lane && fs.existsSync(options.lane) && fs.statSync(options.lane).isDirectory()) {
+        const tasksDir = path.resolve(options.lane);
+        lanesToResume = allLanes.filter(l => l.needsResume && l.state?.tasksFile && path.resolve(l.state.tasksFile).startsWith(tasksDir));
+        if (lanesToResume.length > 0) {
+            logger.info(`📂 Task directory detected: ${options.lane}`);
+            logger.info(`Resuming ${lanesToResume.length} lane(s) from this directory.`);
+        }
+        else {
+            logger.warn(`No incomplete lanes found using tasks from directory: ${options.lane}`);
+            return;
         }
-        return;
     }
-    // Single lane mode (original behavior)
-    if (!options.lane) {
-        // Show status by default if no lane specified
-        printAllLaneStatus(runDir);
-        console.log('');
-        console.log('Usage: cursorflow resume <lane> [options]');
-        console.log('       cursorflow resume --all           # Resume all incomplete lanes');
-        return;
+    else if (options.all) {
+        lanesToResume = allLanes.filter(l => l.needsResume && l.state?.tasksFile);
     }
-    const laneDir = (0, path_1.safeJoin)(runDir, 'lanes', options.lane);
-    const statePath = (0, path_1.safeJoin)(laneDir, 'state.json');
-    if (!fs.existsSync(statePath)) {
-        throw new Error(`Lane state not found at ${statePath}. Is the lane name correct?`);
+    else if (options.lane) {
+        const lane = allLanes.find(l => l.name === options.lane);
+        if (!lane) {
+            throw new Error(`Lane '${options.lane}' not found in run directory.`);
+        }
+        if (!lane.needsResume) {
+            logger.success(`Lane '${options.lane}' is already completed.`);
+            return;
+        }
+        lanesToResume = [lane];
     }
-    const state = (0, state_1.loadState)(statePath);
-    if (!state) {
-        throw new Error(`Failed to load state from ${statePath}`);
+    // Check for zombie lanes
+    const zombieCheck = checkAndFixZombieLanes(runDir);
+    if (zombieCheck.fixed.length > 0) {
+        logger.section('🔧 Zombie Lane Recovery');
+        logger.info(`Fixed ${zombieCheck.fixed.length} zombie lane(s): ${zombieCheck.fixed.join(', ')}`);
+        console.log('');
     }
-    if (!state.tasksFile || !fs.existsSync(state.tasksFile)) {
-        throw new Error(`Original tasks file not found: ${state.tasksFile}. Resume impossible without task definition.`);
+    if (options.status) {
+        printAllLaneStatus(runDir);
+        return;
     }
-    // Run doctor check before resuming (check branches, etc.)
-    if (!options.skipDoctor) {
-        const tasksDir = path.dirname(state.tasksFile);
-        logger.info('Running pre-flight checks...');
-        const report = (0, doctor_1.runDoctor)({
-            cwd: process.cwd(),
-            tasksDir,
-            includeCursorAgentChecks: false, // Skip agent checks for resume
-        });
-        // Only show blocking errors for resume
-        const blockingIssues = report.issues.filter(i => i.severity === 'error' &&
-            (i.id.startsWith('branch.') || i.id.startsWith('git.')));
-        if (blockingIssues.length > 0) {
-            logger.section('🛑 Pre-resume check found issues');
-            for (const issue of blockingIssues) {
-                logger.error(`${issue.title} (${issue.id})`, '❌');
-                console.log(`   ${issue.message}`);
-                if (issue.details)
-                    console.log(`   Details: ${issue.details}`);
-                if (issue.fixes?.length) {
-                    console.log('   Fix:');
-                    for (const fix of issue.fixes)
-                        console.log(`     - ${fix}`);
-                }
-                console.log('');
-            }
-            throw new Error('Pre-resume checks failed. Use --skip-doctor to bypass (not recommended).');
+    if (lanesToResume.length === 0) {
+        if (options.lane || options.all) {
+            logger.success('No lanes need to be resumed.');
         }
-        // Show warnings but don't block
-        const warnings = report.issues.filter(i => i.severity === 'warn' && i.id.startsWith('branch.'));
-        if (warnings.length > 0) {
-            logger.warn(`${warnings.length} warning(s) found. Run 'cursorflow doctor' for details.`);
+        else {
+            printAllLaneStatus(runDir);
         }
+        return;
     }
-    logger.section(`🔁 Resuming Lane: ${options.lane}`);
-    logger.info(`Run: ${path.basename(runDir)}`);
-    logger.info(`Tasks: ${state.tasksFile}`);
-    logger.info(`Starting from task index: ${options.restart ? 0 : state.currentTaskIndex}`);
-    const { child } = spawnLaneResume(options.lane, laneDir, state, {
+    const result = await resumeLanes(lanesToResume, allLanes, {
         restart: options.restart,
+        maxConcurrent: options.maxConcurrent,
+        skipDoctor: options.skipDoctor,
         noGit: options.noGit,
         executor: options.executor,
         enhancedLogConfig: config.enhancedLogging,
     });
-    logger.info(`Spawning runner process...`);
-    return new Promise((resolve, reject) => {
-        child.on('exit', (code) => {
-            if (code === 0) {
-                logger.success(`Lane ${options.lane} completed successfully`);
-                resolve();
-            }
-            else if (code === 2) {
-                logger.warn(`Lane ${options.lane} blocked on dependency change`);
-                resolve();
-            }
-            else {
-                reject(new Error(`Lane ${options.lane} failed with exit code ${code}`));
-            }
-        });
-        child.on('error', (error) => {
-            reject(new Error(`Failed to start runner: ${error.message}`));
-        });
-    });
+    if (result.failed.length > 0) {
+        throw new Error(`${result.failed.length} lane(s) failed to complete`);
+    }
 }
 module.exports = resume;
 //# sourceMappingURL=resume.js.map