fix(cron): allow cold isolated runner setup

dredozubov · dredozubov · commit e864cf5b23a7 · 2026-05-29T08:34:31.000+04:00
diff --git a/src/cron/service/timer.regression.test.ts b/src/cron/service/timer.regression.test.ts
@@ -1573,6 +1573,72 @@ describe("cron service timer regressions", () => {
     }
   });
 
+  it("allows long isolated cron jobs more setup time for cold runner startup", async () => {
+    vi.useFakeTimers();
+    try {
+      const store = timerRegressionFixtures.makeStorePath();
+      const scheduledAt = Date.parse("2026-05-10T09:02:00.000Z");
+      const cronJob = createIsolatedRegressionJob({
+        id: "isolated-cold-runner-setup",
+        name: "cold runner setup",
+        scheduledAt,
+        schedule: { kind: "at", at: new Date(scheduledAt).toISOString() },
+        payload: { kind: "agentTurn", message: "work", timeoutSeconds: 1080 },
+        state: { nextRunAtMs: scheduledAt },
+      });
+      await writeCronJobs(store.storePath, [cronJob]);
+
+      vi.setSystemTime(scheduledAt);
+      let now = scheduledAt;
+      const started = createDeferred<void>();
+      let settled = false;
+      let abortObserved = false;
+      const cleanupTimedOutAgentRun = vi.fn(async () => {});
+      const state = createCronServiceState({
+        cronEnabled: true,
+        storePath: store.storePath,
+        log: noopLogger,
+        nowMs: () => now,
+        enqueueSystemEvent: vi.fn(),
+        requestHeartbeat: vi.fn(),
+        cleanupTimedOutAgentRun,
+        runIsolatedAgentJob: vi.fn(async ({ abortSignal }: { abortSignal?: AbortSignal }) => {
+          started.resolve();
+          abortSignal?.addEventListener(
+            "abort",
+            () => {
+              abortObserved = true;
+            },
+            { once: true },
+          );
+          return await new Promise<never>(() => {});
+        }),
+      });
+
+      const timerPromise = onTimer(state).finally(() => {
+        settled = true;
+      });
+      await started.promise;
+      await vi.advanceTimersByTimeAsync(60_100);
+      now += 60_100;
+      expect(settled).toBe(false);
+      expect(abortObserved).toBe(false);
+      expect(cleanupTimedOutAgentRun).not.toHaveBeenCalled();
+
+      await vi.advanceTimersByTimeAsync(240_000);
+      now += 240_000;
+      await timerPromise;
+
+      const job = requireJob(state, "isolated-cold-runner-setup");
+      expect(abortObserved).toBe(true);
+      expect(job.state.lastStatus).toBe("error");
+      expect(job.state.lastError).toContain("setup timed out before runner start");
+      expect(cleanupTimedOutAgentRun).toHaveBeenCalledTimes(1);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
   it("times out isolated agent runs that stall before execution starts (#74803)", async () => {
     vi.useFakeTimers();
     try {
diff --git a/src/cron/service/timer.ts b/src/cron/service/timer.ts
@@ -69,7 +69,8 @@ export { DEFAULT_JOB_TIMEOUT_MS } from "./timeout-policy.js";
 
 const MAX_TIMER_DELAY_MS = 60_000;
 const CRON_TIMEOUT_CLEANUP_GUARD_MS = 20_000;
-const CRON_AGENT_SETUP_WATCHDOG_MS = 60_000;
+const CRON_AGENT_SETUP_MIN_WATCHDOG_MS = 60_000;
+const CRON_AGENT_SETUP_MAX_WATCHDOG_MS = 5 * 60_000;
 const CRON_AGENT_PRE_EXECUTION_WATCHDOG_MS = 60_000;
 const CRON_AGENT_PRE_EXECUTION_MIN_WATCHDOG_MS = 1_000;
 
@@ -302,7 +303,7 @@ function createCronAgentWatchdog(params: {
           if (state === "waiting_for_runner") {
             setTimedOut(setupTimeoutErrorMessage(activeExecution));
           }
-        }, CRON_AGENT_SETUP_WATCHDOG_MS);
+        }, resolveCronAgentSetupWatchdogMs(params.jobTimeoutMs));
         return;
       }
       startTimeout();
@@ -400,6 +401,13 @@ function formatCronAgentExecutionPhase(execution?: CronAgentExecutionStarted): s
   return formatEmbeddedAgentExecutionPhase(execution?.phase);
 }
 
+function resolveCronAgentSetupWatchdogMs(jobTimeoutMs: number): number {
+  return Math.max(
+    CRON_AGENT_SETUP_MIN_WATCHDOG_MS,
+    Math.min(CRON_AGENT_SETUP_MAX_WATCHDOG_MS, Math.floor(jobTimeoutMs / 2)),
+  );
+}
+
 function resolveCronAgentPreExecutionWatchdogMs(jobTimeoutMs: number): number {
   return Math.max(
     CRON_AGENT_PRE_EXECUTION_MIN_WATCHDOG_MS,
