steroids-cli 0.9.41 → 0.9.43

package/dist/runners/wakeup.js

@@ -24,6 +24,10 @@ Object.defineProperty(exports, "hasActiveParallelSessionForProject", { enumerabl
 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 projects_js_2 = require("./projects.js");
+const ping_js_1 = require("../providers/ping.js");
+// In-memory mutex to prevent concurrent wakeup cycles in the same process
+let isWakeupRunning = false;
 /**
  * Main wake-up function
  * Called by cron every minute to ensure runners are healthy
@@ -37,216 +41,275 @@ async function wakeup(options = {}) {
         if (!quiet)
             console.log(msg);
     };
-    // Record wakeup invocation time (even for dry runs)
-    if (!dryRun) {
-        (0, wakeup_timing_js_1.recordWakeupTime)();
+    if (isWakeupRunning) {
+        log('Wakeup cycle already running (in-memory lock), skipping.');
+        return [{ action: 'skipped', reason: 'Wakeup cycle already running' }];
     }
-    // Step 1: Clean up stale runners first
-    const global = (0, global_db_js_1.openGlobalDatabase)();
+    isWakeupRunning = true;
     try {
+        if (!(0, global_db_js_1.getDaemonActiveStatus)()) {
+            log('Daemon paused (is_active=false), skipping wakeup logic.');
+            return [{ action: 'skipped', reason: 'Daemon is paused' }];
+        }
+        // Record wakeup invocation time (even for dry runs)
+        if (!dryRun) {
+            (0, wakeup_timing_js_1.recordWakeupTime)();
+        }
+        // Step 1: Clean up stale runners first
+        const global = (0, global_db_js_1.openGlobalDatabase)();
         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) {
-                        if (runner.pid) {
-                            (0, wakeup_runner_js_1.killProcess)(runner.pid);
-                        }
-                        global.db.prepare(`UPDATE workstreams
+            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) {
+                            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);
+                            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,
+                    });
                 }
-                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
+            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)`);
+                if (releasedLeases > 0) {
+                    log(`Released ${releasedLeases} expired workstream lease(s)`);
+                }
             }
-        }
-        catch {
-            // ignore lease cleanup 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)();
+            catch {
+                // ignore lease cleanup issues in wakeup
             }
-        }
-        // Step 3: Get all registered projects from global registry
-        const registeredProjects = (0, projects_js_1.getRegisteredProjects)(false); // enabled only
-        if (registeredProjects.length === 0) {
-            log('No registered projects found');
-            log('Run "steroids projects add <path>" to register a project');
-            results.push({
-                action: 'none',
-                reason: 'No registered projects',
-                pendingTasks: 0,
-            });
-            return results;
-        }
-        log(`Checking ${registeredProjects.length} registered project(s)...`);
-        // Step 4: Check each project and start runners as needed
-        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`);
+            // 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
+            if (registeredProjects.length === 0) {
+                log('No registered projects found');
+                log('Run "steroids projects add <path>" to register a project');
                 results.push({
                     action: 'none',
-                    reason: 'Directory not found',
-                    projectPath: project.path,
+                    reason: 'No registered projects',
+                    pendingTasks: 0,
                 });
-                continue;
+                return results;
             }
-            // 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}`);
+            log(`Checking ${registeredProjects.length} registered project(s)...`);
+            // Step 4: Check each project and start runners as needed
+            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;
                 }
-            }
-            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);
+                // 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 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}`);
+                    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}`);
                     }
-                    // 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}`);
+                }
+                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)`);
+                        }
                     }
-                    if (skippedRecoveryDueToSafetyLimit && !quiet) {
-                        log(`Skipping auto-recovery in ${project.path}: safety limit hit (maxIncidentsPerHour)`);
+                    finally {
+                        closeProjectDb();
                     }
                 }
-                finally {
-                    closeProjectDb();
+                catch {
+                    // If sanitise/recovery can't run (DB missing/corrupt), we still proceed with runner checks.
                 }
-            }
-            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);
-            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()}`);
+                // 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 if project is hibernating
+                if (project.hibernating_until) {
+                    const untilMs = new Date(project.hibernating_until).getTime();
+                    if (Date.now() < untilMs) {
+                        log(`Skipping ${project.path}: Project is hibernating (tier ${project.hibernation_tier}) until ${project.hibernating_until}`);
                         results.push({
-                            action: dryRun ? 'would_start' : 'none',
-                            reason,
+                            action: 'skipped',
+                            reason: `Hibernating until ${project.hibernating_until}`,
                             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()}`);
+                    // Hibernation timer expired, execute lightweight ping
+                    log(`Hibernation timer expired for ${project.path}. Executing lightweight ping...`);
+                    let pingSuccess = false;
+                    if (!dryRun) {
+                        // We use the orchestrator provider to ping, as it's the general "health" proxy
+                        const orchestratorProvider = projectConfig.ai?.orchestrator?.provider;
+                        const orchestratorModel = projectConfig.ai?.orchestrator?.model;
+                        if (orchestratorProvider && orchestratorModel) {
+                            pingSuccess = await (0, ping_js_1.pingProvider)(orchestratorProvider, orchestratorModel);
+                        }
+                    }
+                    else {
+                        pingSuccess = true;
+                    }
+                    if (pingSuccess) {
+                        log(`Ping successful for ${project.path}. Clearing hibernation state.`);
+                        if (!dryRun)
+                            (0, projects_js_2.clearProjectHibernation)(project.path);
+                    }
+                    else {
+                        // Ping failed, extend hibernation
+                        const nextTier = (project.hibernation_tier ?? 1) + 1;
+                        const backoffMinutes = 30; // 30 minutes for tier 2+
+                        const newUntilISO = new Date(Date.now() + (backoffMinutes * 60 * 1000)).toISOString();
+                        log(`Ping failed for ${project.path}. Extending hibernation to tier ${nextTier} until ${newUntilISO}.`);
+                        if (!dryRun) {
+                            const { setProjectHibernation } = await import('./projects.js');
+                            setProjectHibernation(project.path, nextTier, newUntilISO);
+                        }
                         results.push({
-                            action: 'would_start',
-                            reason,
+                            action: 'skipped',
+                            reason: `Ping failed, extended hibernation until ${newUntilISO}`,
                             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
+                }
+                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,
@@ -256,34 +319,34 @@ async function wakeup(options = {}) {
                    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
+                            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';
                     }
-                    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
+                    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);
+                            .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;
                                 }
-                                global.db.prepare(`UPDATE workstreams
+                                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'),
@@ -291,14 +354,14 @@ async function wakeup(options = {}) {
                        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;
+                                    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
+                        else if (sessionRunners.length < configuredMaxClones) {
+                            const throttled = global.db
+                                .prepare(`SELECT id
                  FROM workstreams
                  WHERE session_id = ?
                    AND status = 'running'
@@ -307,79 +370,79 @@ async function wakeup(options = {}) {
                    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
+                                .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;
+                                    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);
+                    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';
+                            }
                         }
-                        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 {
+                        if (wouldScaleDown > 0) {
+                            retrySummary += `, would scale down ${wouldScaleDown} idle runner(s) to maxClones=${configuredMaxClones}`;
                         }
-                        else {
-                            retrySummary = ', session state reconciled';
+                        if (wouldResume > 0) {
+                            retrySummary += `, would resume ${wouldResume} throttled workstream(s)`;
                         }
                     }
-                }
-                else {
-                    if (wouldScaleDown > 0) {
-                        retrySummary += `, would scale down ${wouldScaleDown} idle runner(s) to maxClones=${configuredMaxClones}`;
+                    if (!skipForParallelSession) {
+                        log(`Reconciled stale parallel session for ${project.path}; proceeding with startup`);
                     }
-                    if (wouldResume > 0) {
-                        retrySummary += `, would resume ${wouldResume} throttled workstream(s)`;
+                    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;
                     }
                 }
-                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
+                // 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
@@ -387,113 +450,117 @@ async function wakeup(options = {}) {
              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,
-                        });
+                    .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;
                     }
-                    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,
-                        });
-                    }
+                }
+                // 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';
+                    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); failed to start runner` : 'Failed to start runner',
+                        projectPath: project.path,
+                        recoveredActions,
+                        skippedRecoveryDueToSafetyLimit,
+                        deletedInvocationLogs,
+                        sanitisedActions,
+                    });
+                }
             }
-            // 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';
-                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 {
+            // If no specific results, add a summary
+            if (results.length === 0) {
                 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,
+                    reason: 'No action needed',
                 });
             }
+            return results;
         }
-        // If no specific results, add a summary
-        if (results.length === 0) {
-            results.push({
-                action: 'none',
-                reason: 'No action needed',
-            });
+        finally {
+            global.close();
         }
-        return results;
     }
     finally {
-        global.close();
+        isWakeupRunning = false;
     }
 }
 /**