chore(deadcode): remove obsolete cron execution wrapper

vincentkoc · vincentkoc · commit 44ae2fd93601 · 2026-06-22T15:25:37.000+08:00
diff --git a/src/cron/active-jobs-manual-run.test.ts b/src/cron/active-jobs-manual-run.test.ts
@@ -1,6 +1,6 @@
 // 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)
diff --git a/src/cron/service/timer.regression.test.ts b/src/cron/service/timer.regression.test.ts
@@ -43,7 +43,6 @@ import { createCronServiceState, type CronEvent } from "./state.js";
 import {
   DEFAULT_JOB_TIMEOUT_MS,
   applyJobResult,
-  executeJob,
   executeJobCore,
   executeJobCoreWithTimeout,
   onTimer,
@@ -1738,6 +1737,7 @@ describe("cron service timer regressions", () => {
   });
 
   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;
@@ -1759,11 +1759,11 @@ describe("cron service timer regressions", () => {
       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,
@@ -1774,16 +1774,20 @@ describe("cron service timer regressions", () => {
       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)", () => {
diff --git a/src/cron/service/timer.ts b/src/cron/service/timer.ts
@@ -2164,56 +2164,6 @@ async function executeDetachedCronJob(
   };
 }
 
-/** 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,
