// Regression: upstream commit 7d1575b5df (#60310, 2026-04-04) introduced

// activeJobIds + markCronJobActive/clearCronJobActive but only wired the pair

// into runDueJob and executeJob. The manual-run path (cron.run() →

// into the scheduled due-job path. The manual-run path (cron.run() →

// prepareManualRun + finishPreparedManualRun in src/cron/service/ops.ts) was

// left without the mark/clear pair, so task-registry.maintenance.ts

// hasBackingSession (cron branch under isRuntimeAuthoritative()=true)

import {

DEFAULT_JOB_TIMEOUT_MS,

applyJobResult,

executeJob,

executeJobCore,

executeJobCoreWithTimeout,

onTimer,

});

it("retries recurring wake-now main jobs until temporary lane pressure clears (#75964)", async () => {

const store = timerRegressionFixtures.makeStorePath();

let now = 0;

const nowMs = () => {

now += 10;

sessionTarget: "main",

wakeMode: "now",

payload: { kind: "systemEvent", text: "tick" },

state: { nextRunAtMs: 0 },

state: { nextRunAtMs: 1 },

};

const state = createCronServiceState({

cronEnabled: true,

storePath: "/tmp/openclaw-cron-busy-main-test/jobs.json",

storePath: store.storePath,

log: noopLogger,

nowMs,

enqueueSystemEvent,

runIsolatedAgentJob: createDefaultIsolatedRunner(),

});

state.store = { version: 1, jobs: [job] };

await saveCronStore(store.storePath, { version: 1, jobs: [job] });

const runPromise = executeJob(state, job, nowMs(), { forced: false });

const runPromise = runMissedJobs(state);

await vi.advanceTimersByTimeAsync(1);

await runPromise;

const persistedJob = (await loadCronStore(store.storePath)).jobs.find(

(candidate) => candidate.id === job.id,

);

expect(enqueueSystemEvent).toHaveBeenCalledTimes(1);

expect(runHeartbeatOnce).toHaveBeenCalledTimes(2);

expect(requestHeartbeat).not.toHaveBeenCalled();

expect(job.state.lastStatus).toBe("ok");

expect(job.state.runningAtMs).toBeUndefined();

expect(persistedJob?.state.lastStatus).toBe("ok");

expect(persistedJob?.state.runningAtMs).toBeUndefined();

});

it("retries cron schedule computation from the next second when the first attempt returns undefined (#17821)", () => {

};

}

/** Executes a cron job and applies the resulting state transitions in memory. */

export async function executeJob(

state: CronServiceState,

job: CronJob,

_nowMs: number,

_opts: { forced: boolean },

) {

if (!job.state) {

job.state = {};

}

const startedAt = state.deps.nowMs();

job.state.runningAtMs = startedAt;

job.state.lastError = undefined;

const activeJobMarker = markCronJobActive(job.id, {

preserveAcrossGenerationAdvance: job.sessionTarget === "main",

});

emit(state, { jobId: job.id, action: "started", job, runAtMs: startedAt });

let coreResult: {

status: CronRunStatus;

delivered?: boolean;

delivery?: CronDeliveryTrace;

} & CronRunOutcome &

CronRunTelemetry;

try {

coreResult = await executeJobCoreWithTimeout(state, job, { activeJobMarker });

} catch (err) {

coreResult = { status: "error", error: String(err) };

}

const endedAt = state.deps.nowMs();

const shouldDelete = applyJobResult(state, job, {

status: coreResult.status,

error: coreResult.error,

diagnostics: coreResult.diagnostics,

delivered: coreResult.delivered,

provider: coreResult.provider,

startedAt,

endedAt,

});

emitJobFinished(state, job, coreResult, startedAt);

if (shouldDelete && state.store) {

state.store.jobs = state.store.jobs.filter((j) => j.id !== job.id);

emit(state, { jobId: job.id, action: "removed", job });

}

clearCronJobActive(job.id, activeJobMarker);

}

function emitJobFinished(

state: CronServiceState,

job: CronJob,