@litmers/cursorflow-orchestrator 0.1.18 → 0.1.26

package/dist/cli/resume.js

@@ -42,34 +42,40 @@ const logger = __importStar(require("../utils/logger"));
 const config_1 = require("../utils/config");
 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]
-
-Resume interrupted or failed lanes.
-
-Options:
-  <lane>                 Lane name to resume (single lane mode)
-  --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)
-  --max-concurrent <n>   Max lanes to run in parallel (default: 3)
-  --clean                Clean up existing worktree before resuming
-  --restart              Restart from the first task (index 0)
-  --skip-doctor          Skip environment/branch checks (not recommended)
-  --help, -h             Show help
-
-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 --all --restart          # Restart all incomplete lanes from task 0
-  cursorflow resume --all --max-concurrent 2 # Resume with max 2 parallel lanes
+    console.log(`
+Usage: cursorflow resume [lane] [options]
+
+Resume interrupted or failed lanes.
+
+Options:
+  <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)
+  --max-concurrent <n>   Max lanes to run in parallel (default: 3)
+  --clean                Clean up existing worktree before resuming
+  --restart              Restart from the first task (index 0)
+  --skip-doctor          Skip environment/branch checks (not recommended)
+  --no-git               Disable Git operations (must match original run)
+  --executor <type>      Override executor (default: cursor-agent)
+  --help, -h             Show help
+
+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
   `);
 }
 function parseArgs(args) {
     const runDirIdx = args.indexOf('--run-dir');
     const maxConcurrentIdx = args.indexOf('--max-concurrent');
+    const executorIdx = args.indexOf('--executor');
     return {
         lane: args.find(a => !a.startsWith('--')) || null,
         runDir: runDirIdx >= 0 ? args[runDirIdx + 1] || null : null,
@@ -80,20 +86,22 @@ function parseArgs(args) {
         status: args.includes('--status'),
         maxConcurrent: maxConcurrentIdx >= 0 ? parseInt(args[maxConcurrentIdx + 1] || '3') : 3,
         help: args.includes('--help') || args.includes('-h'),
+        noGit: args.includes('--no-git'),
+        executor: executorIdx >= 0 ? args[executorIdx + 1] || null : null,
     };
 }
 /**
  * Find the latest run directory
  */
 function findLatestRunDir(logsDir) {
-    const runsDir = path.join(logsDir, 'runs');
+    const runsDir = (0, path_1.safeJoin)(logsDir, 'runs');
     if (!fs.existsSync(runsDir))
         return null;
     const runs = fs.readdirSync(runsDir)
         .filter(d => d.startsWith('run-'))
         .sort()
         .reverse();
-    return runs.length > 0 ? path.join(runsDir, runs[0]) : null;
+    return runs.length > 0 ? (0, path_1.safeJoin)(runsDir, runs[0]) : null;
 }
 /**
  * Status indicator colors
@@ -109,25 +117,156 @@ const STATUS_COLORS = {
     unknown: '\x1b[90m', // gray
 };
 const RESET = '\x1b[0m';
+/**
+ * Check if a process is alive by its PID
+ */
+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`);
+            }
+        }
+    }
+    // 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
  */
 function getAllLaneStatuses(runDir) {
-    const lanesDir = path.join(runDir, 'lanes');
+    const lanesDir = (0, path_1.safeJoin)(runDir, 'lanes');
     if (!fs.existsSync(lanesDir)) {
         return [];
     }
     const lanes = fs.readdirSync(lanesDir)
-        .filter(f => fs.statSync(path.join(lanesDir, f)).isDirectory())
+        .filter(f => fs.statSync((0, path_1.safeJoin)(lanesDir, f)).isDirectory())
         .map(name => {
-        const dir = path.join(lanesDir, name);
-        const statePath = path.join(dir, 'state.json');
+        const dir = (0, path_1.safeJoin)(lanesDir, name);
+        const statePath = (0, path_1.safeJoin)(dir, 'state.json');
         const state = fs.existsSync(statePath) ? (0, state_1.loadState)(statePath) : null;
-        // Determine if lane needs resume
-        const needsResume = state ? (state.status === 'failed' ||
-            state.status === 'paused' ||
-            state.status === 'running' || // If process crashed mid-run
-            (state.status === 'pending' && state.currentTaskIndex > 0)) : false;
+        // Determine if lane needs resume: everything that is not completed
+        const needsResume = state ? (state.status !== 'completed') : true;
         const isCompleted = state?.status === 'completed';
         const dependsOn = state?.dependsOn || [];
         return { name, dir, state, needsResume, dependsOn, isCompleted };
@@ -229,7 +368,7 @@ function printAllLaneStatus(runDir) {
     return { total: lanes.length, completed: completedCount, needsResume: needsResumeCount };
 }
 /**
- * Resume a single lane and return the child process
+ * Resume a single lane and return the child process and its log manager
  */
 function spawnLaneResume(laneName, laneDir, state, options) {
     const runnerPath = require.resolve('../core/runner');
@@ -240,11 +379,46 @@ function spawnLaneResume(laneName, laneDir, state, options) {
         '--run-dir', laneDir,
         '--start-index', String(startIndex),
     ];
+    if (state.worktreeDir) {
+        runnerArgs.push('--worktree-dir', state.worktreeDir);
+    }
+    if (options.noGit) {
+        runnerArgs.push('--no-git');
+    }
+    // Explicitly pass pipeline branch if available (either from state or override)
+    const branch = options.pipelineBranch || state.pipelineBranch;
+    if (branch) {
+        runnerArgs.push('--pipeline-branch', branch);
+    }
+    // Pass executor if provided
+    if (options.executor) {
+        runnerArgs.push('--executor', options.executor);
+    }
+    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: 'inherit',
+        stdio: ['ignore', 'pipe', 'pipe'],
         env: process.env,
     });
-    return child;
+    if (child.stdout) {
+        child.stdout.on('data', (data) => {
+            logManager.writeStdout(data);
+        });
+    }
+    if (child.stderr) {
+        child.stderr.on('data', (data) => {
+            logManager.writeStderr(data);
+        });
+    }
+    child.on('exit', () => {
+        logManager.close();
+    });
+    return { child, logManager };
 }
 /**
  * Wait for a child process to exit
@@ -262,14 +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);
-    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 = [];
@@ -292,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)({
@@ -322,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);
@@ -340,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;
@@ -362,17 +511,19 @@ async function resumeAllLanes(runDir, options) {
             pending.delete(lane.name);
             const depsInfo = lane.dependsOn.length > 0 ? ` (after: ${lane.dependsOn.join(', ')})` : '';
             logger.info(`Starting: ${lane.name} (task ${lane.state.currentTaskIndex}/${lane.state.totalTasks})${depsInfo}`);
-            const child = spawnLaneResume(lane.name, lane.dir, lane.state, {
+            const { child } = spawnLaneResume(lane.name, lane.dir, lane.state, {
                 restart: options.restart,
+                noGit: options.noGit,
+                executor: options.executor,
+                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`);
@@ -382,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);
@@ -392,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) {
@@ -422,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);
@@ -430,104 +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,
-        });
-        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 = path.join(runDir, 'lanes', options.lane);
-    const statePath = path.join(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