pulseed 0.6.5 → 0.7.0

package/dist/runtime/executor/loop-supervisor.js

@@ -1,690 +0,0 @@
-import { writeFileSync, mkdirSync, renameSync, existsSync, readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { GoalWorker } from './goal-worker.js';
-import { createEnvelope } from '../types/envelope.js';
-import { StateFenceError } from '../../base/utils/errors.js';
-import { getPulseedDirPath } from '../../base/utils/paths.js';
-const DEFAULT_CONFIG = {
-    concurrency: 4,
-    iterationsPerCycle: 5,
-    maxCrashCount: 3,
-    crashBackoffBaseMs: 1000,
-    stateFilePath: join(getPulseedDirPath(), 'supervisor-state.json'),
-    pollIntervalMs: 100,
-    claimLeaseMs: 30_000,
-    leaseRenewIntervalMs: 10_000,
-    runPolicy: 'resident',
-    activeStopGraceMs: 5_000,
-};
-function workerStatusToBackgroundRunStatus(status) {
-    if (status === 'completed' || status === 'finalization')
-        return 'succeeded';
-    if (status === 'stopped')
-        return 'cancelled';
-    return 'failed';
-}
-export class LoopSupervisor {
-    workers = [];
-    activeGoals = new Map();
-    activeBackgroundRuns = new Map();
-    crashCounts = new Map();
-    suspendedGoals = new Set();
-    stoppedGoals = new Set();
-    running = false;
-    pollTimer = null;
-    config;
-    deps;
-    polling = false;
-    currentPoll = null;
-    runningExecutions = [];
-    pendingTimers = new Set();
-    constructor(deps, config) {
-        this.deps = deps;
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    async start(initialGoalIds) {
-        const workerCfg = {
-            iterationsPerCycle: this.config.iterationsPerCycle,
-            maxIterations: this.config.maxIterations,
-            runPolicy: this.config.runPolicy,
-        };
-        for (let i = 0; i < this.config.concurrency; i++) {
-            this.workers.push(new GoalWorker(this.deps.coreLoopFactory(), workerCfg, {
-                onRunStart: () => {
-                    this.persistState();
-                },
-                onRunComplete: async (loopResult, cumulativeIterations) => {
-                    await this.deps.onCycleComplete?.(loopResult.goalId, {
-                        goalId: loopResult.goalId,
-                        status: loopResult.finalStatus,
-                        totalIterations: cumulativeIterations,
-                        durationMs: 0,
-                        error: loopResult.errorMessage,
-                    });
-                    this.persistState();
-                },
-            }));
-        }
-        this.running = true;
-        this.loadState();
-        for (const goalId of initialGoalIds) {
-            this.enqueueGoalActivation(goalId);
-        }
-        this.schedulePoll();
-        this.pollTimer = setInterval(() => {
-            this.schedulePoll();
-        }, this.config.pollIntervalMs);
-    }
-    async shutdown() {
-        this.running = false;
-        if (this.pollTimer) {
-            clearInterval(this.pollTimer);
-            this.pollTimer = null;
-        }
-        for (const timer of this.pendingTimers)
-            clearTimeout(timer);
-        this.pendingTimers.clear();
-        const pollCompleted = await waitForExecutions(this.currentPoll ? [this.currentPoll] : [], this.config.activeStopGraceMs);
-        if (!pollCompleted) {
-            this.deps.logger?.warn('Supervisor shutdown returned before active poll settled', {
-                timeoutMs: this.config.activeStopGraceMs,
-            });
-        }
-        const activeExecutions = [...this.runningExecutions];
-        if (activeExecutions.length > 0) {
-            this.deps.logger?.warn('Aborting active goal executions during supervisor shutdown', {
-                activeCount: activeExecutions.length,
-                goalIds: activeExecutions.map((execution) => execution.goalId),
-            });
-            for (const execution of activeExecutions) {
-                execution.controller.abort(new Error('operator stop requested'));
-            }
-        }
-        const completed = await waitForExecutions(activeExecutions.map((execution) => execution.promise), this.config.activeStopGraceMs);
-        if (!completed) {
-            this.deps.logger?.warn('Supervisor shutdown returned before active executions settled', {
-                activeCount: this.runningExecutions.length,
-                timeoutMs: this.config.activeStopGraceMs,
-            });
-        }
-        this.persistState();
-    }
-    getState() {
-        return {
-            workers: this.workers.map(w => {
-                const backgroundRun = this.activeBackgroundRuns.get(w.id);
-                return {
-                    workerId: w.id,
-                    goalId: w.getCurrentGoalId(),
-                    startedAt: w.getStartedAt(),
-                    iterations: w.getIterations(),
-                    ...(backgroundRun
-                        ? {
-                            backgroundRunId: backgroundRun.backgroundRunId,
-                            sessionId: backgroundRun.sessionId,
-                            parentSessionId: backgroundRun.parentSessionId,
-                        }
-                        : {}),
-                };
-            }),
-            crashCounts: Object.fromEntries(this.crashCounts),
-            suspendedGoals: [...this.suspendedGoals],
-            updatedAt: Date.now(),
-        };
-    }
-    replaceIdleWorkers(coreLoopFactory) {
-        if (this.activeGoals.size > 0 || this.workers.some((worker) => !worker.isIdle())) {
-            return;
-        }
-        const workerCfg = {
-            iterationsPerCycle: this.config.iterationsPerCycle,
-            maxIterations: this.config.maxIterations,
-            runPolicy: this.config.runPolicy,
-        };
-        this.workers = [];
-        for (let i = 0; i < this.config.concurrency; i++) {
-            this.workers.push(new GoalWorker(coreLoopFactory(), workerCfg, {
-                onRunComplete: async (loopResult, cumulativeIterations) => {
-                    await this.deps.onCycleComplete?.(loopResult.goalId, {
-                        goalId: loopResult.goalId,
-                        status: loopResult.finalStatus,
-                        totalIterations: cumulativeIterations,
-                        durationMs: 0,
-                        error: loopResult.errorMessage,
-                    });
-                    this.persistState();
-                },
-            }));
-        }
-    }
-    activateGoal(goalId, options = {}) {
-        this.stoppedGoals.delete(goalId);
-        this.suspendedGoals.delete(goalId);
-        this.enqueueGoalActivation(goalId, options);
-    }
-    deactivateGoal(goalId) {
-        this.stoppedGoals.add(goalId);
-    }
-    schedulePoll() {
-        if (this.currentPoll !== null) {
-            return;
-        }
-        const poll = this.pollAndAssign();
-        this.currentPoll = poll;
-        void poll.finally(() => {
-            if (this.currentPoll === poll) {
-                this.currentPoll = null;
-            }
-        });
-    }
-    enqueueGoalActivation(goalId, options = {}) {
-        if (this.stoppedGoals.has(goalId)) {
-            return;
-        }
-        const backgroundRunId = options.backgroundRun?.backgroundRunId;
-        const envelope = createEnvelope({
-            type: 'event',
-            name: 'goal_activated',
-            source: 'supervisor',
-            goal_id: goalId,
-            payload: {
-                ...(backgroundRunId
-                    ? {
-                        backgroundRun: {
-                            backgroundRunId,
-                            ...(options.backgroundRun?.parentSessionId !== undefined
-                                ? { parentSessionId: options.backgroundRun.parentSessionId }
-                                : {}),
-                        },
-                    }
-                    : {}),
-                ...(options.waitResume ? { wait_resume: options.waitResume } : {}),
-            },
-            priority: 'normal',
-            dedupe_key: backgroundRunId ? `goal_activated:${goalId}:${backgroundRunId}` : `goal_activated:${goalId}`,
-        });
-        const accepted = this.deps.journalQueue.accept(envelope);
-        if (!accepted.accepted && !accepted.duplicate) {
-            this.deps.logger?.warn('Failed to enqueue durable goal activation', {
-                goalId,
-                envelopeId: envelope.id,
-            });
-        }
-    }
-    async pollAndAssign() {
-        if (!this.running || this.polling)
-            return;
-        this.polling = true;
-        const idleWorkers = this.workers.filter(w => w.isIdle());
-        try {
-            for (const worker of idleWorkers) {
-                const dispatch = await this.claimNextDispatch(worker.id);
-                if (!dispatch)
-                    break;
-                const goalId = dispatch.goalId;
-                if (this.activeGoals.has(goalId)) {
-                    const activeWorker = this.activeGoals.get(goalId);
-                    activeWorker.requestExtend();
-                    await this.markCoalescedBackgroundRun(dispatch, activeWorker);
-                    await this.completeClaim(dispatch);
-                    continue;
-                }
-                if (this.stoppedGoals.has(goalId)) {
-                    await this.completeClaim(dispatch);
-                    continue;
-                }
-                if (this.suspendedGoals.has(goalId)) {
-                    await this.failClaim(dispatch, 'goal suspended', false);
-                    continue;
-                }
-                if (!(await this.acquireExecutionLease(worker, dispatch))) {
-                    await this.failClaim(dispatch, 'goal lease unavailable', true);
-                    continue;
-                }
-                if (!this.running) {
-                    await this.failClaim(dispatch, 'supervisor stopping', true);
-                    await this.releaseExecutionLease(dispatch);
-                    break;
-                }
-                this.activeGoals.set(goalId, worker);
-                const controller = new AbortController();
-                const execution = this.executeWorker(worker, dispatch, controller.signal);
-                this.persistState();
-                const trackedExecution = {
-                    promise: execution,
-                    controller,
-                    goalId,
-                    workerId: worker.id,
-                };
-                this.runningExecutions.push(trackedExecution);
-                execution.finally(() => {
-                    const idx = this.runningExecutions.indexOf(trackedExecution);
-                    if (idx !== -1)
-                        this.runningExecutions.splice(idx, 1);
-                });
-            }
-        }
-        finally {
-            this.polling = false;
-        }
-    }
-    async claimNextDispatch(workerId) {
-        const claim = this.deps.journalQueue.claim(workerId, this.config.claimLeaseMs, (envelope) => envelope.type === 'event' && envelope.name === 'goal_activated' && Boolean(envelope.goal_id));
-        if (!claim || !claim.envelope.goal_id) {
-            return null;
-        }
-        return {
-            goalId: claim.envelope.goal_id,
-            claim,
-            ownerToken: claim.claimToken,
-            attemptId: claim.claimToken,
-            backgroundRun: this.extractActivationBackgroundRun(claim.envelope.payload),
-            waitResume: this.extractActivationWaitResume(claim.envelope.payload),
-        };
-    }
-    extractActivationBackgroundRun(payload) {
-        if (!payload || typeof payload !== 'object')
-            return undefined;
-        const backgroundRun = payload['backgroundRun'];
-        if (!backgroundRun || typeof backgroundRun !== 'object')
-            return undefined;
-        const input = backgroundRun;
-        const backgroundRunId = input['backgroundRunId'];
-        if (typeof backgroundRunId !== 'string' || backgroundRunId.trim() === '')
-            return undefined;
-        const parentSessionId = input['parentSessionId'];
-        return {
-            backgroundRunId,
-            ...(typeof parentSessionId === 'string' || parentSessionId === null ? { parentSessionId } : {}),
-        };
-    }
-    extractActivationWaitResume(payload) {
-        if (!payload || typeof payload !== 'object')
-            return undefined;
-        const waitResume = payload['wait_resume'];
-        if (!waitResume || typeof waitResume !== 'object')
-            return undefined;
-        const input = waitResume;
-        if (input['type'] !== 'wait_resume')
-            return undefined;
-        const strategyId = input['strategyId'];
-        if (typeof strategyId !== 'string' || strategyId.trim() === '')
-            return undefined;
-        return {
-            type: 'wait_resume',
-            strategyId,
-            ...(typeof input['scheduleEntryId'] === 'string' ? { scheduleEntryId: input['scheduleEntryId'] } : {}),
-            ...(typeof input['nextObserveAt'] === 'string' || input['nextObserveAt'] === null ? { nextObserveAt: input['nextObserveAt'] } : {}),
-            ...(typeof input['waitReason'] === 'string' || input['waitReason'] === null ? { waitReason: input['waitReason'] } : {}),
-        };
-    }
-    async acquireExecutionLease(worker, activation) {
-        const lease = await this.deps.goalLeaseManager.acquire(activation.goalId, {
-            workerId: worker.id,
-            ownerToken: activation.ownerToken,
-            attemptId: activation.attemptId,
-            leaseMs: this.config.claimLeaseMs,
-        });
-        return lease !== null;
-    }
-    startLeaseRenewLoop(activation, onLeaseLost) {
-        let stopped = false;
-        let renewing = false;
-        const timer = setInterval(() => {
-            if (stopped || renewing)
-                return;
-            renewing = true;
-            void (async () => {
-                try {
-                    const renewedClaim = this.deps.journalQueue.renew(activation.claim.claimToken, this.config.claimLeaseMs);
-                    const renewedLease = await this.deps.goalLeaseManager.renew(activation.goalId, activation.ownerToken, { leaseMs: this.config.claimLeaseMs });
-                    if (!renewedClaim || !renewedLease) {
-                        stopped = true;
-                        clearInterval(timer);
-                        this.deps.logger?.warn('Lost durable execution ownership during renewal', {
-                            goalId: activation.goalId,
-                            claimToken: activation.claim.claimToken,
-                        });
-                        onLeaseLost();
-                    }
-                }
-                catch (err) {
-                    this.deps.logger?.warn('Failed to renew durable execution ownership', {
-                        goalId: activation.goalId,
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-                finally {
-                    renewing = false;
-                }
-            })();
-        }, this.config.leaseRenewIntervalMs);
-        timer.unref?.();
-        return () => {
-            stopped = true;
-            clearInterval(timer);
-        };
-    }
-    async executeWorker(worker, activation, abortSignal) {
-        const { goalId } = activation;
-        let ownershipLost = false;
-        this.installWriteFence(activation);
-        const stopRenewal = this.startLeaseRenewLoop(activation, () => {
-            ownershipLost = true;
-        });
-        this.setActiveBackgroundRun(worker, activation);
-        await this.markBackgroundRunStarted(activation, worker);
-        try {
-            const result = await worker.execute(goalId, {
-                ...(activation.backgroundRun ? { backgroundRun: activation.backgroundRun } : {}),
-                ...(activation.waitResume ? { waitResume: activation.waitResume } : {}),
-                ...(abortSignal ? { abortSignal } : {}),
-            });
-            if (result.status === 'error') {
-                const count = (this.crashCounts.get(goalId) ?? 0) + 1;
-                this.crashCounts.set(goalId, count);
-                if (count >= this.config.maxCrashCount) {
-                    this.suspendedGoals.add(goalId);
-                    this.deps.logger?.warn('Goal suspended after max crashes', {
-                        goalId,
-                        crashCount: count,
-                    });
-                    this.deps.onEscalation?.(goalId, count, result.error ?? 'unknown error');
-                    await this.markBackgroundRunTerminal(activation, result);
-                    await this.failClaim(activation, result.error ?? 'goal suspended after max crashes', false, ownershipLost);
-                }
-                else {
-                    const backoffMs = this.calculateCrashBackoff(count);
-                    await this.deferDurableRetry(activation, result.error ?? 'goal execution failed', backoffMs, ownershipLost);
-                }
-                return;
-            }
-            this.crashCounts.delete(goalId);
-            this.suspendedGoals.delete(goalId);
-            try {
-                await this.deps.onGoalComplete?.(goalId, result);
-            }
-            catch (err) {
-                this.deps.logger?.warn('Goal completion callback failed', {
-                    goalId,
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-            await this.markBackgroundRunTerminal(activation, result);
-            await this.completeClaim(activation, ownershipLost);
-        }
-        finally {
-            stopRenewal();
-            this.clearWriteFence(goalId);
-            await this.releaseExecutionLease(activation);
-            this.activeGoals.delete(goalId);
-            this.activeBackgroundRuns.delete(worker.id);
-            this.persistState();
-        }
-    }
-    coreLoopSessionId(worker) {
-        return `session:coreloop:${worker.id}`;
-    }
-    setActiveBackgroundRun(worker, activation) {
-        const runId = activation.backgroundRun?.backgroundRunId;
-        if (!runId)
-            return;
-        this.activeBackgroundRuns.set(worker.id, {
-            backgroundRunId: runId,
-            sessionId: this.coreLoopSessionId(worker),
-            parentSessionId: activation.backgroundRun?.parentSessionId ?? null,
-        });
-    }
-    supervisorStateRef() {
-        return {
-            kind: 'supervisor_state',
-            id: null,
-            path: this.config.stateFilePath,
-            relative_path: null,
-            updated_at: null,
-        };
-    }
-    evidenceLedgerRef(activation) {
-        const runId = activation.backgroundRun?.backgroundRunId ?? null;
-        return {
-            kind: 'evidence_ledger',
-            id: runId,
-            path: null,
-            relative_path: runId ? `runtime/evidence-ledger/runs/${encodeURIComponent(runId)}.jsonl` : null,
-            updated_at: null,
-        };
-    }
-    async mergeBackgroundRunSourceRefs(runId, refs) {
-        const existing = await this.deps.backgroundRunLedger?.load(runId).catch(() => null);
-        const currentRefs = existing?.source_refs ?? [];
-        const merged = [...currentRefs];
-        for (const ref of refs) {
-            const duplicate = merged.some((existingRef) => existingRef.kind === ref.kind
-                && existingRef.id === ref.id
-                && existingRef.path === ref.path
-                && existingRef.relative_path === ref.relative_path);
-            if (!duplicate)
-                merged.push(ref);
-        }
-        return merged;
-    }
-    async markBackgroundRunStarted(activation, worker) {
-        const runId = activation.backgroundRun?.backgroundRunId;
-        if (!runId || !this.deps.backgroundRunLedger)
-            return;
-        const sourceRefs = await this.mergeBackgroundRunSourceRefs(runId, [
-            this.supervisorStateRef(),
-            this.evidenceLedgerRef(activation),
-        ]);
-        try {
-            if (activation.backgroundRun?.parentSessionId !== undefined) {
-                await this.deps.backgroundRunLedger.link(runId, {
-                    parent_session_id: activation.backgroundRun.parentSessionId,
-                    child_session_id: this.coreLoopSessionId(worker),
-                    source_refs: sourceRefs,
-                });
-            }
-            await this.deps.backgroundRunLedger.started(runId, {
-                child_session_id: this.coreLoopSessionId(worker),
-                source_refs: sourceRefs,
-            });
-        }
-        catch (err) {
-            this.deps.logger?.warn('Failed to mark background run started', {
-                goalId: activation.goalId,
-                backgroundRunId: runId,
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    async markBackgroundRunTerminal(activation, result) {
-        const runId = activation.backgroundRun?.backgroundRunId;
-        if (!runId || !this.deps.backgroundRunLedger)
-            return;
-        const sourceRefs = await this.mergeBackgroundRunSourceRefs(runId, [
-            this.supervisorStateRef(),
-            this.evidenceLedgerRef(activation),
-        ]);
-        try {
-            const run = await this.deps.backgroundRunLedger.terminal(runId, {
-                status: workerStatusToBackgroundRunStatus(result.status),
-                summary: `DurableLoop ${result.status} after ${result.totalIterations} iteration(s).`,
-                error: result.error ?? null,
-                source_refs: sourceRefs,
-            });
-            if (run.notify_policy !== 'silent' && run.pinned_reply_target) {
-                await this.deps.onBackgroundRunTerminal?.(run, result);
-            }
-        }
-        catch (err) {
-            this.deps.logger?.warn('Failed to mark background run terminal', {
-                goalId: activation.goalId,
-                backgroundRunId: runId,
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    async markCoalescedBackgroundRun(activation, activeWorker) {
-        const runId = activation.backgroundRun?.backgroundRunId;
-        if (!runId || !this.deps.backgroundRunLedger)
-            return;
-        const sourceRefs = await this.mergeBackgroundRunSourceRefs(runId, [
-            this.supervisorStateRef(),
-            this.evidenceLedgerRef(activation),
-        ]);
-        const childSessionId = this.coreLoopSessionId(activeWorker);
-        try {
-            await this.deps.backgroundRunLedger.link(runId, {
-                parent_session_id: activation.backgroundRun?.parentSessionId ?? null,
-                child_session_id: childSessionId,
-                source_refs: sourceRefs,
-            });
-            await this.deps.backgroundRunLedger.started(runId, {
-                child_session_id: childSessionId,
-                source_refs: sourceRefs,
-            });
-            const run = await this.deps.backgroundRunLedger.terminal(runId, {
-                status: "cancelled",
-                summary: `DurableLoop activation coalesced into active worker ${activeWorker.id}.`,
-                source_refs: sourceRefs,
-            });
-            if (run.notify_policy !== 'silent' && run.pinned_reply_target) {
-                await this.deps.onBackgroundRunTerminal?.(run, {
-                    goalId: activation.goalId,
-                    status: 'stopped',
-                    totalIterations: 0,
-                    durationMs: 0,
-                });
-            }
-        }
-        catch (err) {
-            this.deps.logger?.warn('Failed to settle coalesced background run', {
-                goalId: activation.goalId,
-                backgroundRunId: runId,
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    async completeClaim(activation, ownershipLost = false) {
-        if (ownershipLost) {
-            this.deps.logger?.warn('Skipping ack because durable execution ownership was lost', {
-                goalId: activation.goalId,
-                claimToken: activation.claim.claimToken,
-            });
-            return;
-        }
-        const acked = this.deps.journalQueue.ack(activation.claim.claimToken);
-        if (!acked) {
-            this.deps.logger?.warn('Failed to ack durable goal activation claim', {
-                goalId: activation.goalId,
-                claimToken: activation.claim.claimToken,
-            });
-        }
-    }
-    async failClaim(activation, reason, requeue, ownershipLost = false) {
-        if (ownershipLost) {
-            return;
-        }
-        const settled = this.deps.journalQueue.nack(activation.claim.claimToken, reason, requeue);
-        if (!settled) {
-            this.deps.logger?.warn('Failed to nack durable goal activation claim', {
-                goalId: activation.goalId,
-                claimToken: activation.claim.claimToken,
-                reason,
-                requeue,
-            });
-        }
-    }
-    async releaseExecutionLease(activation) {
-        try {
-            await this.deps.goalLeaseManager.release(activation.goalId, activation.ownerToken);
-        }
-        catch (err) {
-            this.deps.logger?.warn('Failed to release goal execution lease', {
-                goalId: activation.goalId,
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    calculateCrashBackoff(crashCount) {
-        const jitter = Math.random() * 0.3;
-        return Math.min(this.config.crashBackoffBaseMs * Math.pow(2, crashCount - 1) * (1 + jitter), 30_000);
-    }
-    async deferDurableRetry(activation, reason, backoffMs, ownershipLost) {
-        if (ownershipLost) {
-            return;
-        }
-        const leaseMs = backoffMs + Math.max(this.config.pollIntervalMs, 100);
-        const renewedClaim = this.deps.journalQueue.renew(activation.claim.claimToken, leaseMs);
-        if (!renewedClaim) {
-            return;
-        }
-        const timer = setTimeout(() => {
-            this.pendingTimers.delete(timer);
-            if (!this.running)
-                return;
-            void this.failClaim(activation, reason, true, false);
-        }, backoffMs);
-        this.pendingTimers.add(timer);
-    }
-    installWriteFence(activation) {
-        this.deps.stateManager.setWriteFence?.(activation.goalId, async () => {
-            const current = await this.deps.goalLeaseManager.read(activation.goalId);
-            if (!current ||
-                current.owner_token !== activation.ownerToken ||
-                current.attempt_id !== activation.attemptId ||
-                current.lease_until <= Date.now()) {
-                throw new StateFenceError(`Write fence rejected commit for goal "${activation.goalId}" because execution ownership is stale`);
-            }
-        });
-    }
-    clearWriteFence(goalId) {
-        this.deps.stateManager.clearWriteFence?.(goalId);
-    }
-    persistState() {
-        const state = this.getState();
-        const filePath = this.config.stateFilePath;
-        const tmpPath = filePath + '.tmp';
-        try {
-            mkdirSync(dirname(filePath), { recursive: true });
-            writeFileSync(tmpPath, JSON.stringify(state, null, 2), 'utf8');
-            renameSync(tmpPath, filePath);
-        }
-        catch (err) {
-            this.deps.logger?.error('Failed to persist supervisor state', { err: String(err) });
-        }
-    }
-    loadState() {
-        const filePath = this.config.stateFilePath;
-        if (!existsSync(filePath))
-            return;
-        try {
-            const raw = readFileSync(filePath, 'utf8');
-            const state = JSON.parse(raw);
-            for (const [goalId, count] of Object.entries(state.crashCounts)) {
-                this.crashCounts.set(goalId, count);
-            }
-        }
-        catch {
-            // Corrupt or missing state — start fresh
-        }
-    }
-}
-async function waitForExecutions(promises, timeoutMs) {
-    if (promises.length === 0)
-        return true;
-    let timer;
-    try {
-        const timeout = new Promise((resolve) => {
-            timer = setTimeout(() => resolve(false), timeoutMs);
-            timer.unref?.();
-        });
-        const settled = Promise.allSettled(promises).then(() => true);
-        return await Promise.race([settled, timeout]);
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-    }
-}
-//# sourceMappingURL=loop-supervisor.js.map