steroids-cli 0.12.5 → 0.12.7

package/dist/runners/wakeup.js

@@ -3,62 +3,22 @@
  * Cron wake-up command for restarting stale/dead runners
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasActiveParallelSessionForProject = exports.hasActiveRunnerForProject = exports.getLastWakeupTime = void 0;
+exports.checkWakeupNeeded = exports.hasActiveParallelSessionForProject = exports.hasActiveRunnerForProject = exports.getLastWakeupTime = void 0;
 exports.wakeup = wakeup;
-exports.checkWakeupNeeded = checkWakeupNeeded;
-const node_fs_1 = require("node:fs");
-const lock_js_1 = require("./lock.js");
 const global_db_js_1 = require("./global-db.js");
-const heartbeat_js_1 = require("./heartbeat.js");
 const projects_js_1 = require("./projects.js");
-const connection_js_1 = require("../database/connection.js");
-const loader_js_1 = require("../config/loader.js");
-const stuck_task_recovery_js_1 = require("../health/stuck-task-recovery.js");
-const invocation_logs_js_1 = require("../cleanup/invocation-logs.js");
-// Import from helper files
-const wakeup_sanitise_js_1 = require("./wakeup-sanitise.js");
-const wakeup_reconcile_js_1 = require("./wakeup-reconcile.js");
 const wakeup_checks_js_1 = require("./wakeup-checks.js");
 Object.defineProperty(exports, "hasActiveRunnerForProject", { enumerable: true, get: function () { return wakeup_checks_js_1.hasActiveRunnerForProject; } });
 Object.defineProperty(exports, "hasActiveParallelSessionForProject", { enumerable: true, get: function () { return wakeup_checks_js_1.hasActiveParallelSessionForProject; } });
-const wakeup_runner_js_1 = require("./wakeup-runner.js");
 const wakeup_timing_js_1 = require("./wakeup-timing.js");
 Object.defineProperty(exports, "getLastWakeupTime", { enumerable: true, get: function () { return wakeup_timing_js_1.getLastWakeupTime; } });
+const wakeup_global_cleanup_js_1 = require("./wakeup-global-cleanup.js");
+const wakeup_project_js_1 = require("./wakeup-project.js");
+const wakeup_needed_js_1 = require("./wakeup-needed.js");
+Object.defineProperty(exports, "checkWakeupNeeded", { enumerable: true, get: function () { return wakeup_needed_js_1.checkWakeupNeeded; } });
+const system_pressure_js_1 = require("./system-pressure.js");
 // In-memory mutex to prevent concurrent wakeup cycles in the same process
 let isWakeupRunning = false;
-async function waitForRunnerRegistration(globalDb, projectPath, parallelMode, timeoutMs = 8000) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        if (parallelMode) {
-            const parallelRunner = globalDb
-                .prepare(`SELECT 1
-           FROM runners r
-           JOIN parallel_sessions ps ON ps.id = r.parallel_session_id
-           WHERE ps.project_path = ?
-             AND r.status != 'stopped'
-             AND r.heartbeat_at > datetime('now', '-5 minutes')
-           LIMIT 1`)
-                .get(projectPath);
-            if (parallelRunner !== undefined)
-                return true;
-        }
-        else {
-            const standaloneRunner = globalDb
-                .prepare(`SELECT 1
-           FROM runners
-           WHERE project_path = ?
-             AND parallel_session_id IS NULL
-             AND status != 'stopped'
-             AND heartbeat_at > datetime('now', '-5 minutes')
-           LIMIT 1`)
-                .get(projectPath);
-            if (standaloneRunner !== undefined)
-                return true;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 250));
-    }
-    return false;
-}
 /**
  * Main wake-up function
  * Called by cron every minute to ensure runners are healthy
@@ -86,107 +46,13 @@ async function wakeup(options = {}) {
         if (!dryRun) {
             (0, wakeup_timing_js_1.recordWakeupTime)();
         }
-        // Step 1: Clean up stale runners first
         return (0, global_db_js_1.withGlobalDatabase)(async (globalDb) => {
-            const global = { db: globalDb };
-            try {
-                const staleRunners = (0, heartbeat_js_1.findStaleRunners)(global.db);
-                if (staleRunners.length > 0) {
-                    log(`Found ${staleRunners.length} stale runner(s), cleaning up...`);
-                    if (!dryRun) {
-                        for (const runner of staleRunners) {
-                            // Clean up in-flight task state before removing runner row.
-                            // Process is definitively dead (stale heartbeat), so the lock is deleted
-                            // immediately — unlike the SIGTERM case where the lock is left in place
-                            // to prevent double-execution from a still-alive process.
-                            //
-                            // project_path is the canonical project path for both standalone and
-                            // parallel workstream runners (findStaleRunners JOIN-resolves clone paths
-                            // via parallel_sessions.project_path).
-                            if (runner.current_task_id && runner.project_path) {
-                                try {
-                                    const { db: projectDb, close: closeProjectDb } = (0, connection_js_1.openDatabase)(runner.project_path);
-                                    try {
-                                        const nowMs = Date.now();
-                                        projectDb.prepare(`UPDATE task_invocations
-                     SET status = 'failed', success = 0, timed_out = 0, exit_code = 1,
-                         completed_at_ms = ?, duration_ms = ?,
-                         error = COALESCE(error, 'Runner process died (stale heartbeat).')
-                     WHERE task_id = ? AND status = 'running'`).run(nowMs, 0, runner.current_task_id);
-                                        // Reset coder-phase tasks (in_progress → pending).
-                                        // Leave review-status tasks at 'review' — task selection includes
-                                        // review tasks, so the next runner will re-run the reviewer directly
-                                        // without unnecessarily re-executing the coder phase.
-                                        projectDb.prepare(`UPDATE tasks SET status = 'pending', updated_at = datetime('now')
-                     WHERE id = ? AND status = 'in_progress'`).run(runner.current_task_id);
-                                        projectDb.prepare(`DELETE FROM task_locks WHERE task_id = ?`).run(runner.current_task_id);
-                                    }
-                                    finally {
-                                        closeProjectDb();
-                                    }
-                                }
-                                catch {
-                                    // Project DB errors must not block runner row cleanup.
-                                }
-                            }
-                            if (runner.pid) {
-                                (0, wakeup_runner_js_1.killProcess)(runner.pid);
-                            }
-                            global.db.prepare(`UPDATE workstreams
-               SET runner_id = NULL,
-                   lease_expires_at = datetime('now')
-               WHERE runner_id = ?`).run(runner.id);
-                            global.db.prepare('DELETE FROM runners WHERE id = ?').run(runner.id);
-                        }
-                    }
-                    results.push({
-                        action: 'cleaned',
-                        reason: `Cleaned ${staleRunners.length} stale runner(s)`,
-                        staleRunners: staleRunners.length,
-                    });
-                }
-            }
-            catch {
-                // ignore global DB issues; wakeup will still attempt per-project checks
-            }
-            try {
-                const releasedLeases = global.db.prepare(`UPDATE workstreams
-         SET runner_id = NULL,
-             lease_expires_at = NULL
-         WHERE status = 'running'
-           AND lease_expires_at IS NOT NULL
-           AND lease_expires_at <= datetime('now')`).run().changes;
-                if (releasedLeases > 0) {
-                    log(`Released ${releasedLeases} expired workstream lease(s)`);
-                }
-            }
-            catch {
-                // ignore lease cleanup issues in wakeup
-            }
-            // Step 1b: Reconcile stale workspace pool slots and merge locks
-            try {
-                const { reconcileStaleWorkspaces } = await import('../workspace/reconcile.js');
-                const reconcileResult = reconcileStaleWorkspaces(global.db);
-                if (reconcileResult.resetSlots > 0 || reconcileResult.deletedLocks > 0) {
-                    log(`Workspace pool reconciliation: reset ${reconcileResult.resetSlots} slot(s), ` +
-                        `deleted ${reconcileResult.deletedLocks} stale lock(s)`);
-                    // Return associated tasks to pending in their project DBs
-                    // (deferred — the next loop iteration will pick them up as pending)
-                }
-            }
-            catch {
-                // ignore workspace pool reconciliation issues in wakeup
-            }
-            // Step 2: Clean zombie lock if present
-            const lockStatus = (0, lock_js_1.checkLockStatus)();
-            if (lockStatus.isZombie && lockStatus.pid) {
-                log(`Found zombie lock (PID: ${lockStatus.pid}), cleaning...`);
-                if (!dryRun) {
-                    (0, lock_js_1.removeLock)();
-                }
-            }
-            // Step 3: Get all registered projects from global registry
-            const registeredProjects = (0, projects_js_1.getRegisteredProjects)(false); // enabled only
+            results.push(...(await (0, wakeup_global_cleanup_js_1.performWakeupGlobalMaintenance)({
+                globalDb,
+                dryRun,
+                log,
+            })));
+            const registeredProjects = (0, projects_js_1.getRegisteredProjects)(false);
             if (registeredProjects.length === 0) {
                 log('No registered projects found');
                 log('Run "steroids projects add <path>" to register a project');
@@ -198,427 +64,21 @@ async function wakeup(options = {}) {
                 return results;
             }
             log(`Checking ${registeredProjects.length} registered project(s)...`);
-            // Step 4: Check each project and start runners as needed
+            // Skip spawning new runners if system is under memory/disk pressure
+            const pressure = (0, system_pressure_js_1.checkSystemPressure)();
+            if (!pressure.ok) {
+                log(`System pressure: ${pressure.reason} — skipping runner spawns`);
+                results.push({ action: 'skipped', reason: `System pressure: ${pressure.reason}` });
+                return results;
+            }
             for (const project of registeredProjects) {
-                // Skip if project directory doesn't exist
-                if (!(0, node_fs_1.existsSync)(project.path)) {
-                    log(`Skipping ${project.path}: directory not found`);
-                    results.push({
-                        action: 'none',
-                        reason: 'Directory not found',
-                        projectPath: project.path,
-                    });
-                    continue;
-                }
-                // Phase 6 (live monitoring): best-effort retention cleanup of invocation activity logs.
-                // This is safe to run even if the project has no pending tasks.
-                let deletedInvocationLogs = 0;
-                try {
-                    const cleanup = (0, invocation_logs_js_1.cleanupInvocationLogs)(project.path, { retentionDays: 7, dryRun });
-                    deletedInvocationLogs = cleanup.deletedFiles;
-                    if (cleanup.deletedFiles > 0 && !quiet) {
-                        log(`Cleaned ${cleanup.deletedFiles} old invocation log(s) in ${project.path}`);
-                    }
-                }
-                catch {
-                    // Ignore cleanup errors; wakeup must remain robust.
-                }
-                let recoveredActions = 0;
-                let skippedRecoveryDueToSafetyLimit = false;
-                let sanitisedActions = 0;
-                try {
-                    const { db: projectDb, close: closeProjectDb } = (0, connection_js_1.openDatabase)(project.path);
-                    try {
-                        const sanitiseSummary = (0, wakeup_sanitise_js_1.runPeriodicSanitiseForProject)(global.db, projectDb, project.path, dryRun);
-                        sanitisedActions = (0, wakeup_sanitise_js_1.sanitisedActionCount)(sanitiseSummary);
-                        if (sanitisedActions > 0 && !quiet) {
-                            log(`Sanitised ${sanitisedActions} stale item(s) in ${project.path}`);
-                        }
-                        // Step 4a: Recover stuck tasks (best-effort) before deciding whether to (re)start a runner.
-                        // This is what unblocks orphaned/infinite-hang scenarios without manual intervention.
-                        const config = (0, loader_js_1.loadConfig)(project.path);
-                        const recovery = await (0, stuck_task_recovery_js_1.recoverStuckTasks)({
-                            projectPath: project.path,
-                            projectDb,
-                            globalDb: global.db,
-                            config,
-                            dryRun,
-                        });
-                        recoveredActions = recovery.actions.length;
-                        skippedRecoveryDueToSafetyLimit = recovery.skippedDueToSafetyLimit;
-                        if (recoveredActions > 0 && !quiet) {
-                            log(`Recovered ${recoveredActions} stuck item(s) in ${project.path}`);
-                        }
-                        if (skippedRecoveryDueToSafetyLimit && !quiet) {
-                            log(`Skipping auto-recovery in ${project.path}: safety limit hit (maxIncidentsPerHour)`);
-                        }
-                    }
-                    finally {
-                        closeProjectDb();
-                    }
-                }
-                catch {
-                    // If sanitise/recovery can't run (DB missing/corrupt), we still proceed with runner checks.
-                }
-                // Check for pending work after sanitise/recovery
-                const hasWork = await (0, wakeup_checks_js_1.projectHasPendingWork)(project.path);
-                if (!hasWork) {
-                    const noWorkReason = sanitisedActions > 0
-                        ? `No pending tasks after sanitise (${sanitisedActions} action(s))`
-                        : 'No pending tasks';
-                    log(`Skipping ${project.path}: ${noWorkReason.toLowerCase()}`);
-                    results.push({
-                        action: 'none',
-                        reason: noWorkReason,
-                        projectPath: project.path,
-                        recoveredActions,
-                        skippedRecoveryDueToSafetyLimit,
-                        deletedInvocationLogs,
-                        sanitisedActions,
-                    });
-                    continue;
-                }
-                const projectConfig = (0, loader_js_1.loadConfig)(project.path);
-                // Check global provider backoffs
-                const coderProvider = projectConfig.ai?.coder?.provider;
-                const reviewerProvider = projectConfig.ai?.reviewer?.provider;
-                const providersToCheck = [coderProvider, reviewerProvider].filter(Boolean);
-                let isBackedOff = false;
-                let backedOffProvider = '';
-                let remainingMs = 0;
-                for (const provider of providersToCheck) {
-                    const ms = (0, global_db_js_1.getProviderBackoffRemainingMs)(provider);
-                    if (ms > 0) {
-                        isBackedOff = true;
-                        backedOffProvider = provider;
-                        remainingMs = ms;
-                        break;
-                    }
-                }
-                if (isBackedOff) {
-                    const remainingMinutes = Math.ceil(remainingMs / 60000);
-                    log(`Skipping ${project.path}: Provider '${backedOffProvider}' is in backoff for ${remainingMinutes}m`);
-                    results.push({
-                        action: 'skipped',
-                        reason: `Provider '${backedOffProvider}' backed off for ${remainingMinutes}m`,
-                        projectPath: project.path,
-                    });
-                    continue;
-                }
-                const parallelEnabled = projectConfig.runners?.parallel?.enabled === true;
-                const configuredMaxClonesRaw = Number(projectConfig.runners?.parallel?.maxClones);
-                const configuredMaxClones = Number.isFinite(configuredMaxClonesRaw) && configuredMaxClonesRaw > 0
-                    ? configuredMaxClonesRaw
-                    : 3;
-                // Skip projects currently executing a parallel session before attempting recovery/startup.
-                // This prevents parallel runners from being interfered with by a cron-managed runner.
-                if ((0, wakeup_checks_js_1.hasActiveParallelSessionForProject)(project.path)) {
-                    let retrySummary = '';
-                    let skipForParallelSession = true;
-                    let scaledDown = 0;
-                    let resumed = 0;
-                    let wouldScaleDown = 0;
-                    let wouldResume = 0;
-                    const activeSessions = global.db
-                        .prepare(`SELECT id
-             FROM parallel_sessions
-             WHERE project_path = ?
-               AND status NOT IN ('completed', 'failed', 'aborted', 'blocked_validation', 'blocked_recovery')`)
-                        .all(project.path);
-                    // Config-aware mode reconciliation (parallel -> single):
-                    // if parallel is disabled, convert only when the active parallel runners
-                    // are idle to avoid interrupting in-flight tasks.
-                    if (!parallelEnabled && activeSessions.length > 0) {
-                        const sessionRunners = activeSessions.flatMap((session) => global.db
-                            .prepare(`SELECT id, pid, status, current_task_id
-                 FROM runners
-                 WHERE parallel_session_id = ?
-                   AND status != 'stopped'
-                   AND heartbeat_at > datetime('now', '-5 minutes')`)
-                            .all(session.id));
-                        const hasBusyRunner = sessionRunners.some((runner) => (runner.status ?? '').toLowerCase() !== 'idle' || !!runner.current_task_id);
-                        if (hasBusyRunner) {
-                            const reason = 'Parallel->single mode switch pending (active workstream runner busy)';
-                            log(`Skipping ${project.path}: ${reason.toLowerCase()}`);
-                            results.push({
-                                action: dryRun ? 'would_start' : 'none',
-                                reason,
-                                projectPath: project.path,
-                                deletedInvocationLogs,
-                            });
-                            continue;
-                        }
-                        if (dryRun) {
-                            const reason = 'Would recycle idle parallel session to apply single-runner mode';
-                            log(`Would reconcile ${project.path}: ${reason.toLowerCase()}`);
-                            results.push({
-                                action: 'would_start',
-                                reason,
-                                projectPath: project.path,
-                                deletedInvocationLogs,
-                            });
-                            continue;
-                        }
-                        for (const runner of sessionRunners) {
-                            if (runner.pid)
-                                (0, wakeup_runner_js_1.killProcess)(runner.pid);
-                            global.db.prepare('DELETE FROM runners WHERE id = ?').run(runner.id);
-                        }
-                        for (const session of activeSessions) {
-                            global.db.prepare(`UPDATE workstreams
-               SET status = 'aborted',
-                   runner_id = NULL,
-                   lease_expires_at = NULL,
-                   next_retry_at = NULL,
-                   last_reconcile_action = 'mode_switch_to_single',
-                   last_reconciled_at = datetime('now'),
-                   completed_at = COALESCE(completed_at, datetime('now'))
-               WHERE session_id = ?
-                 AND status NOT IN ('completed', 'failed', 'aborted')`).run(session.id);
-                            global.db.prepare(`UPDATE parallel_sessions
-               SET status = 'aborted',
-                   completed_at = COALESCE(completed_at, datetime('now'))
-               WHERE id = ?`).run(session.id);
-                        }
-                        skipForParallelSession = false;
-                        retrySummary = ', recycled idle parallel session to apply single-runner mode';
-                    }
-                    for (const session of activeSessions) {
-                        const sessionRunners = global.db
-                            .prepare(`SELECT id, pid, status, current_task_id
-               FROM runners
-               WHERE parallel_session_id = ?
-                 AND status != 'stopped'
-                 AND heartbeat_at > datetime('now', '-5 minutes')
-               ORDER BY started_at DESC, heartbeat_at DESC`)
-                            .all(session.id);
-                        if (sessionRunners.length > configuredMaxClones) {
-                            const idleCandidate = sessionRunners.find((r) => (r.status ?? '').toLowerCase() === 'idle' && !r.current_task_id);
-                            if (idleCandidate) {
-                                if (dryRun) {
-                                    wouldScaleDown += 1;
-                                }
-                                else {
-                                    if (idleCandidate.pid) {
-                                        (0, wakeup_runner_js_1.killProcess)(idleCandidate.pid);
-                                    }
-                                    global.db.prepare(`UPDATE workstreams
-                   SET runner_id = NULL,
-                       lease_expires_at = datetime('now', '+5 minutes'),
-                       next_retry_at = datetime('now', '+5 minutes'),
-                       last_reconcile_action = 'concurrency_throttle',
-                       last_reconciled_at = datetime('now')
-                   WHERE session_id = ?
-                     AND runner_id = ?`).run(session.id, idleCandidate.id);
-                                    global.db.prepare('DELETE FROM runners WHERE id = ?').run(idleCandidate.id);
-                                    scaledDown += 1;
-                                }
-                            }
-                        }
-                        else if (sessionRunners.length < configuredMaxClones) {
-                            const throttled = global.db
-                                .prepare(`SELECT id
-                 FROM workstreams
-                 WHERE session_id = ?
-                   AND status = 'running'
-                   AND runner_id IS NULL
-                   AND next_retry_at > datetime('now')
-                   AND last_reconcile_action = 'concurrency_throttle'
-                 ORDER BY last_reconciled_at ASC
-                 LIMIT 1`)
-                                .get(session.id);
-                            if (throttled) {
-                                if (dryRun) {
-                                    wouldResume += 1;
-                                }
-                                else {
-                                    global.db.prepare(`UPDATE workstreams
-                   SET lease_expires_at = datetime('now'),
-                       next_retry_at = datetime('now'),
-                       last_reconcile_action = 'concurrency_resume',
-                       last_reconciled_at = datetime('now')
-                   WHERE id = ?`).run(throttled.id);
-                                    resumed += 1;
-                                }
-                            }
-                        }
-                    }
-                    if (!dryRun) {
-                        const recovery = (0, wakeup_reconcile_js_1.reconcileParallelSessionRecovery)(global.db, project.path);
-                        if (recovery.workstreamsToRestart.length > 0) {
-                            for (const ws of recovery.workstreamsToRestart) {
-                                (0, wakeup_runner_js_1.restartWorkstreamRunner)(ws);
-                            }
-                            retrySummary += `, restarted ${recovery.workstreamsToRestart.length} workstream runner(s)`;
-                        }
-                        if (recovery.blockedWorkstreams > 0) {
-                            retrySummary += `, blocked ${recovery.blockedWorkstreams} workstream(s)`;
-                        }
-                        if (scaledDown > 0) {
-                            retrySummary += `, scaled down ${scaledDown} idle runner(s) to maxClones=${configuredMaxClones}`;
-                        }
-                        if (resumed > 0) {
-                            retrySummary += `, resumed ${resumed} throttled workstream(s)`;
-                        }
-                        // Re-check activity after recovery. If reconciliation cleared stale
-                        // session state for this project, continue to normal startup logic.
-                        if (!(0, wakeup_checks_js_1.hasActiveParallelSessionForProject)(project.path)) {
-                            skipForParallelSession = false;
-                            if (retrySummary.length > 0) {
-                                retrySummary += ', session state reconciled';
-                            }
-                            else {
-                                retrySummary = ', session state reconciled';
-                            }
-                        }
-                    }
-                    else {
-                        if (wouldScaleDown > 0) {
-                            retrySummary += `, would scale down ${wouldScaleDown} idle runner(s) to maxClones=${configuredMaxClones}`;
-                        }
-                        if (wouldResume > 0) {
-                            retrySummary += `, would resume ${wouldResume} throttled workstream(s)`;
-                        }
-                    }
-                    if (!skipForParallelSession) {
-                        log(`Reconciled stale parallel session for ${project.path}; proceeding with startup`);
-                    }
-                    else {
-                        log(`Skipping ${project.path}: active parallel session in progress${retrySummary}`);
-                        results.push({
-                            action: 'none',
-                            reason: `Parallel session already running${retrySummary}`,
-                            projectPath: project.path,
-                            deletedInvocationLogs,
-                        });
-                        continue;
-                    }
-                }
-                // Config-aware mode reconciliation:
-                // if parallel is enabled but an idle standalone runner is active, recycle it
-                // so wakeup applies current parallel settings without manual restart.
-                const activeStandaloneRunner = global.db
-                    .prepare(`SELECT id, pid, status, current_task_id
-           FROM runners
-           WHERE project_path = ?
-             AND parallel_session_id IS NULL
-             AND status != 'stopped'
-             AND heartbeat_at > datetime('now', '-5 minutes')
-           ORDER BY heartbeat_at DESC
-           LIMIT 1`)
-                    .get(project.path);
-                if (activeStandaloneRunner && parallelEnabled) {
-                    const isIdle = (activeStandaloneRunner.status ?? '').toLowerCase() === 'idle' && !activeStandaloneRunner.current_task_id;
-                    if (isIdle) {
-                        if (dryRun) {
-                            log(`Would recycle idle standalone runner for ${project.path} to apply parallel mode`);
-                            results.push({
-                                action: 'would_start',
-                                reason: 'Would restart idle runner to apply parallel mode',
-                                projectPath: project.path,
-                                deletedInvocationLogs,
-                            });
-                            continue;
-                        }
-                        if (activeStandaloneRunner.pid) {
-                            (0, wakeup_runner_js_1.killProcess)(activeStandaloneRunner.pid);
-                        }
-                        global.db.prepare('DELETE FROM runners WHERE id = ?').run(activeStandaloneRunner.id);
-                        const restartResult = (0, wakeup_runner_js_1.startRunner)(project.path);
-                        if (restartResult) {
-                            results.push({
-                                action: 'restarted',
-                                reason: 'Restarted idle runner to apply parallel mode',
-                                pid: restartResult.pid,
-                                projectPath: project.path,
-                                deletedInvocationLogs,
-                            });
-                        }
-                        else {
-                            results.push({
-                                action: 'none',
-                                reason: 'Failed to restart idle runner for parallel mode',
-                                projectPath: project.path,
-                                deletedInvocationLogs,
-                            });
-                        }
-                        continue;
-                    }
-                }
-                // Skip if project already has an active runner (after recovery, which may have killed/removed it).
-                if ((0, wakeup_checks_js_1.hasActiveRunnerForProject)(project.path)) {
-                    log(`Skipping ${project.path}: runner already active`);
-                    results.push({
-                        action: 'none',
-                        reason: recoveredActions > 0
-                            ? `Runner already active (recovered ${recoveredActions} stuck item(s))`
-                            : 'Runner already active',
-                        projectPath: project.path,
-                        recoveredActions,
-                        skippedRecoveryDueToSafetyLimit,
-                        deletedInvocationLogs,
-                        sanitisedActions,
-                    });
-                    continue;
-                }
-                // Start runner for this project
-                const willParallel = parallelEnabled;
-                log(`Starting ${willParallel ? 'parallel session' : 'runner'} for: ${project.path}`);
-                if (dryRun) {
-                    results.push({
-                        action: 'would_start',
-                        reason: recoveredActions > 0 ? `Recovered ${recoveredActions} stuck item(s); would start runner (dry-run)` : `Would start runner (dry-run)`,
-                        projectPath: project.path,
-                        recoveredActions,
-                        skippedRecoveryDueToSafetyLimit,
-                        deletedInvocationLogs,
-                        sanitisedActions,
-                    });
-                    continue;
-                }
-                const startResult = (0, wakeup_runner_js_1.startRunner)(project.path);
-                if (startResult) {
-                    const mode = startResult.parallel ? 'parallel session' : 'runner';
-                    const registered = await waitForRunnerRegistration(global.db, project.path, startResult.parallel === true);
-                    if (registered) {
-                        results.push({
-                            action: 'started',
-                            reason: recoveredActions > 0 ? `Recovered ${recoveredActions} stuck item(s); started ${mode}` : `Started ${mode}`,
-                            pid: startResult.pid,
-                            projectPath: project.path,
-                            recoveredActions,
-                            skippedRecoveryDueToSafetyLimit,
-                            deletedInvocationLogs,
-                            sanitisedActions,
-                        });
-                    }
-                    else {
-                        results.push({
-                            action: 'none',
-                            reason: recoveredActions > 0
-                                ? `Recovered ${recoveredActions} stuck item(s); ${mode} failed to register`
-                                : `${mode} failed to register`,
-                            projectPath: project.path,
-                            recoveredActions,
-                            skippedRecoveryDueToSafetyLimit,
-                            deletedInvocationLogs,
-                            sanitisedActions,
-                        });
-                    }
-                }
-                else {
-                    results.push({
-                        action: 'none',
-                        reason: recoveredActions > 0 ? `Recovered ${recoveredActions} stuck item(s); failed to start runner` : 'Failed to start runner',
-                        projectPath: project.path,
-                        recoveredActions,
-                        skippedRecoveryDueToSafetyLimit,
-                        deletedInvocationLogs,
-                        sanitisedActions,
-                    });
-                }
+                results.push(await (0, wakeup_project_js_1.processWakeupProject)({
+                    globalDb,
+                    projectPath: project.path,
+                    dryRun,
+                    log,
+                }));
             }
-            // If no specific results, add a summary
             if (results.length === 0) {
                 results.push({
                     action: 'none',
@@ -632,40 +92,4 @@ async function wakeup(options = {}) {
         isWakeupRunning = false;
     }
 }
-/**
- * Check if wake-up is needed without taking action
- */
-async function checkWakeupNeeded() {
-    const lockStatus = (0, lock_js_1.checkLockStatus)();
-    if (lockStatus.locked && lockStatus.pid) {
-        return (0, global_db_js_1.withGlobalDatabase)(async (db) => {
-            const staleRunners = (0, heartbeat_js_1.findStaleRunners)(db);
-            if (staleRunners.length > 0) {
-                return {
-                    needed: true,
-                    reason: `${staleRunners.length} stale runner(s) need cleanup`,
-                };
-            }
-            return { needed: false, reason: 'Runner is healthy' };
-        });
-    }
-    if (lockStatus.isZombie) {
-        return { needed: true, reason: 'Zombie lock needs cleanup' };
-    }
-    // Check registered projects
-    const registeredProjects = (0, projects_js_1.getRegisteredProjects)(false);
-    let projectsWithWork = 0;
-    for (const project of registeredProjects) {
-        if ((0, node_fs_1.existsSync)(project.path) && (await (0, wakeup_checks_js_1.projectHasPendingWork)(project.path))) {
-            projectsWithWork++;
-        }
-    }
-    if (projectsWithWork > 0) {
-        return {
-            needed: true,
-            reason: `${projectsWithWork} project(s) have pending tasks`,
-        };
-    }
-    return { needed: false, reason: 'No pending tasks' };
-}
 //# sourceMappingURL=wakeup.js.map