stableclaw 2026.5.1 → 2026.5.2

package/dist/server-cron-DuTAwT4O.js

@@ -0,0 +1,4173 @@
+import { r as formatErrorMessage } from "./errors-Bs2h5H8p.js";
+import { i as getChildLogger } from "./logger-MWEZrHUL.js";
+import { n as defaultRuntime } from "./runtime-kS8e4c6-.js";
+import { T as truncateUtf16Safe } from "./utils-CN_F_3Qg.js";
+import "./links-D7o22Ygt.js";
+import { n as DEFAULT_MODEL, r as DEFAULT_PROVIDER } from "./defaults-DAt--D9n.js";
+import { f as normalizeVerboseLevel, u as normalizeThinkLevel } from "./thinking.shared-D6IkoLJU.js";
+import { S as resolveThinkingDefault, _ as resolveHooksGmailModel, a as getModelRefStatus, d as normalizeModelSelection, h as resolveConfiguredModelRef, p as resolveAllowedModelRef, s as isCliProvider } from "./model-selection-w1RJdjfl.js";
+import { S as isCronRunSessionKey, _ as normalizeAccountId$1, c as normalizeAgentId, h as toAgentStoreSessionKey, u as resolveAgentIdFromSessionKey } from "./session-key-Do__tq1E.js";
+import { a as resolveAgentDir, b as matchesSkillFilter, f as resolveAgentSkillsFilter, i as resolveAgentConfig, m as resolveDefaultAgentId, p as resolveAgentWorkspaceDir, u as resolveAgentModelFallbacksOverride } from "./agent-scope-rWWUivuC.js";
+import { a as logWarn, n as logError } from "./logger-DdGvppaE.js";
+import { d as ensureAgentWorkspace } from "./workspace-D5P9nuJd.js";
+import { c as loadConfig } from "./io-8kNEV_ou.js";
+import { t as parseDurationMs } from "./parse-duration-D9q1V0xx.js";
+import "./zod-schema.providers-whatsapp-CanJPkvb.js";
+import "./config-D9-X_LMC.js";
+import { d as updateSessionStore, i as loadSessionStore, t as archiveRemovedSessionTranscripts } from "./store-DJaTq2_f.js";
+import { i as resolveMainSessionKey, n as resolveAgentMainSessionKey, t as canonicalizeMainSessionAlias } from "./main-session-BpIg43E9.js";
+import "./sessions-xeX9HpAZ.js";
+import { a as resolveSessionTranscriptPath, l as resolveStorePath } from "./paths-BJziUb2E.js";
+import { o as setSessionRuntimeModel } from "./types-K4m9JoyJ.js";
+import { r as callGateway } from "./call-D8qr1xFm.js";
+import "./logging-4dhwGOr5.js";
+import "./channel-plugin-common-vQdGQ26B.js";
+import "./tokens-DoLPJv4s.js";
+import { a as stripHeartbeatToken } from "./heartbeat-crshdWTu.js";
+import { Fn as readLatestAssistantReply, Ft as failTaskRunByRunId, Nt as completeTaskRunByRunId, Pt as createRunningTaskRun, Zn as registerAgentRunContext, _r as normalizeOptionalAgentId, br as normalizePayloadToSystemText, dr as runWithModelFallback, fr as LiveSessionModelSwitchError, p as resolveBootstrapWarningSignaturesSeen, pr as normalizeHttpWebhookUrl, t as runEmbeddedPiAgent, tr as resolveNestedAgentLane, vr as normalizeOptionalSessionKey, vt as countActiveDescendantRuns, wt as listDescendantRunsForRequester, xr as normalizeRequiredName, yr as normalizeOptionalText } from "./pi-embedded-T_JLa73v.js";
+import { n as enqueueCommandInLane, u as CommandLane } from "./command-queue-DGwMaQqF.js";
+import { n as resolveAgentTimeoutMs } from "./content-blocks-Bgp1uhV7.js";
+import { i as supportsXHighThinking } from "./thinking-CEPUwkqY.js";
+import "./common-cywhTwSJ.js";
+import { t as SsrFBlockedError } from "./ssrf-QGacif0_.js";
+import { n as fetchWithSsrFGuard } from "./fetch-guard-a7JwFUYT.js";
+import { a as mapHookExternalContentSource, i as isExternalHookSession, n as detectSuspiciousPatterns, o as resolveHookExternalContentSource, t as buildSafeExternalPrompt } from "./external-content-DTZoZlnZ.js";
+import { t as deliverOutboundPayloads } from "./deliver-DTfKSC4Q.js";
+import { S as requestHeartbeatNow } from "./model-runtime-BiWDK2-B.js";
+import { r as enqueueSystemEvent } from "./system-events-Di7LVrMk.js";
+import { p as resolveSendableOutboundReplyParts, s as hasOutboundReplyContent } from "./reply-payload-DPD7eb4b.js";
+import { n as resolveMessageChannelSelection } from "./channel-selection-BdwVgYH4.js";
+import { t as buildOutboundSessionContext } from "./session-context-DvXLSOcy.js";
+import { i as resolveSessionDeliveryTarget, r as resolveOutboundTarget } from "./targets-Bf54gXl-.js";
+import { i as parseAbsoluteTimeMs, n as resolveCronStaggerMs, r as resolveDefaultCronStaggerMs, t as normalizeCronStaggerMs } from "./stagger-C7snJAQl.js";
+import { o as resolveFailoverReasonFromError } from "./failover-error-DRdCzmSn.js";
+import "./web-media-CDBfT8E2.js";
+import { i as loadModelCatalog } from "./model-catalog-sx4GaLTc.js";
+import { t as buildChannelAccountBindings } from "./bindings-BIT9SrYa.js";
+import { r as maybeResolveIdLikeTarget } from "./target-resolver-h0WiZJ2z.js";
+import { C as resolveFastModeState } from "./queue-Ca31F-8a.js";
+import "./session-utils-B6yctVT6.js";
+import { n as sleepWithAbort } from "./backoff-Y3d8DA-r.js";
+import { t as lookupContextTokens } from "./context-DeDQINVq.js";
+import { r as buildWorkspaceSkillSnapshot } from "./skills-CM3EU8vl.js";
+import { c as hasNonzeroUsage, s as deriveSessionTotalTokens } from "./chat-envelope-xeX-vE4I.js";
+import { i as resolveModelCostConfig, t as estimateUsageCost } from "./usage-format-CXDESRWt.js";
+import { i as cleanupArchivedSessionTranscripts } from "./session-transcript-files.fs-D2Mq9mp7.js";
+import { n as resolveCronStyleNow } from "./current-time-bF6j_L8w.js";
+import { o as readChannelAllowFromStoreSync } from "./pairing-store-BZr880dY.js";
+import { n as resolveSessionAuthProfileOverride } from "./session-override-Cd7zBl0i.js";
+import { r as resolveCronSession, t as runHeartbeatOnce } from "./heartbeat-runner-N3rkIDfo.js";
+import { n as resolveCronStorePath, r as saveCronStore, t as loadCronStore } from "./store-Ctwo8nHJ.js";
+import { r as normalizeWhatsAppTarget } from "./whatsapp-targets-DjBJudn8.js";
+import "./whatsapp-DnsDZ_TC.js";
+import "./whatsapp-heartbeat-Bgu6Y7Re.js";
+import { n as resolveAgentOutboundIdentity } from "./identity-Rl0zYy8N.js";
+import { _ as getSkillsSnapshotVersion, t as getRemoteSkillEligibility } from "./skills-remote-D0fT8yCa.js";
+import { i as getCliSessionId, o as setCliSessionId, t as runCliAgent } from "./cli-runner-CNdeXILj.js";
+import { t as createOutboundSendDeps } from "./outbound-send-deps-BK8EJyax.js";
+import "./outbound-media-DPt_PPtU.js";
+import { o as resolveWhatsAppAccount } from "./whatsapp-surface-B703CwBf.js";
+import "./whatsapp-shared-Mr2ko9yj.js";
+import { n as computeNextRunAtMs, r as computePreviousRunAtMs, t as coerceFiniteScheduleNumber } from "./schedule-DfdPkX_R.js";
+import { S as resolveWaWebAuthDir } from "./runtime-whatsapp-boundary-DLjcLkDC.js";
+import { a as resolveCronRunLogPruneOptions, i as resolveCronRunLogPath, t as appendCronRunLog } from "./run-log-ORr-RiRk.js";
+import fsSync from "node:fs";
+import crypto from "node:crypto";
+//#region src/channel-web.ts
+var LazyWhatsAppAuthDir = class {
+	#value = null;
+	#read() {
+		this.#value ??= resolveWaWebAuthDir();
+		return this.#value;
+	}
+	toString() {
+		return this.#read();
+	}
+	valueOf() {
+		return this.#read();
+	}
+	[Symbol.toPrimitive]() {
+		return this.#read();
+	}
+};
+new LazyWhatsAppAuthDir();
+//#endregion
+//#region src/cron/isolated-agent/delivery-target.ts
+async function resolveDeliveryTarget(cfg, agentId, jobPayload) {
+	const requestedChannel = typeof jobPayload.channel === "string" ? jobPayload.channel : "last";
+	const explicitTo = typeof jobPayload.to === "string" ? jobPayload.to : void 0;
+	const allowMismatchedLastTo = requestedChannel === "last";
+	const sessionCfg = cfg.session;
+	const mainSessionKey = resolveAgentMainSessionKey({
+		cfg,
+		agentId
+	});
+	const store = loadSessionStore(resolveStorePath(sessionCfg?.store, { agentId }));
+	const threadSessionKey = jobPayload.sessionKey?.trim();
+	const main = (threadSessionKey ? store[threadSessionKey] : void 0) ?? store[mainSessionKey];
+	const preliminary = resolveSessionDeliveryTarget({
+		entry: main,
+		requestedChannel,
+		explicitTo,
+		explicitThreadId: jobPayload.threadId,
+		allowMismatchedLastTo
+	});
+	let fallbackChannel;
+	let channelResolutionError;
+	if (!preliminary.channel) if (preliminary.lastChannel) fallbackChannel = preliminary.lastChannel;
+	else try {
+		fallbackChannel = (await resolveMessageChannelSelection({ cfg })).channel;
+	} catch (err) {
+		const detail = err instanceof Error ? err.message : String(err);
+		channelResolutionError = /* @__PURE__ */ new Error(`${detail} Set delivery.channel explicitly or use a main session with a previous channel.`);
+	}
+	const resolved = fallbackChannel ? resolveSessionDeliveryTarget({
+		entry: main,
+		requestedChannel,
+		explicitTo,
+		explicitThreadId: jobPayload.threadId,
+		fallbackChannel,
+		allowMismatchedLastTo,
+		mode: preliminary.mode
+	}) : preliminary;
+	const channel = resolved.channel ?? fallbackChannel;
+	const mode = resolved.mode;
+	let toCandidate = resolved.to;
+	let accountId = (typeof jobPayload.accountId === "string" && jobPayload.accountId.trim() ? jobPayload.accountId.trim() : void 0) ?? resolved.accountId;
+	if (!accountId && channel) {
+		const boundAccounts = buildChannelAccountBindings(cfg).get(channel)?.get(normalizeAgentId(agentId));
+		if (boundAccounts && boundAccounts.length > 0) accountId = boundAccounts[0];
+	}
+	if (jobPayload.accountId) accountId = jobPayload.accountId;
+	const threadId = resolved.threadId && (resolved.threadIdExplicit || resolved.to && resolved.to === resolved.lastTo) ? resolved.threadId : void 0;
+	if (!channel) return {
+		ok: false,
+		channel: void 0,
+		to: void 0,
+		accountId,
+		threadId,
+		mode,
+		error: channelResolutionError ?? /* @__PURE__ */ new Error("Channel is required when delivery.channel=last has no previous channel.")
+	};
+	let allowFromOverride;
+	if (channel === "whatsapp") {
+		const resolvedAccountId = normalizeAccountId$1(accountId);
+		const configuredAllowFrom = (resolveWhatsAppAccount({
+			cfg,
+			accountId: resolvedAccountId
+		}).allowFrom ?? []).map((entry) => String(entry).trim()).filter((entry) => entry && entry !== "*").map((entry) => normalizeWhatsAppTarget(entry)).filter((entry) => Boolean(entry));
+		const storeAllowFrom = readChannelAllowFromStoreSync("whatsapp", process.env, resolvedAccountId).map((entry) => normalizeWhatsAppTarget(entry)).filter((entry) => Boolean(entry));
+		allowFromOverride = [...new Set([...configuredAllowFrom, ...storeAllowFrom])];
+		if (toCandidate && mode === "implicit" && allowFromOverride.length > 0) {
+			const normalizedCurrentTarget = normalizeWhatsAppTarget(toCandidate);
+			if (!normalizedCurrentTarget || !allowFromOverride.includes(normalizedCurrentTarget)) toCandidate = allowFromOverride[0];
+		}
+	}
+	const docked = resolveOutboundTarget({
+		channel,
+		to: toCandidate,
+		cfg,
+		accountId,
+		mode,
+		allowFrom: allowFromOverride
+	});
+	if (!docked.ok) return {
+		ok: false,
+		channel,
+		to: void 0,
+		accountId,
+		threadId,
+		mode,
+		error: docked.error
+	};
+	return {
+		ok: true,
+		channel,
+		to: (await maybeResolveIdLikeTarget({
+			cfg,
+			channel,
+			input: docked.to,
+			accountId
+		}))?.to ?? docked.to,
+		accountId,
+		threadId,
+		mode
+	};
+}
+//#endregion
+//#region src/cron/delivery.ts
+function normalizeChannel(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim().toLowerCase();
+	if (!trimmed) return;
+	return trimmed;
+}
+function normalizeTo$1(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed ? trimmed : void 0;
+}
+function normalizeAccountId(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed ? trimmed : void 0;
+}
+function normalizeThreadId(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed ? trimmed : void 0;
+}
+function resolveCronDeliveryPlan(job) {
+	const delivery = job.delivery;
+	const hasDelivery = delivery && typeof delivery === "object";
+	const rawMode = hasDelivery ? delivery.mode : void 0;
+	const normalizedMode = typeof rawMode === "string" ? rawMode.trim().toLowerCase() : rawMode;
+	const mode = normalizedMode === "announce" ? "announce" : normalizedMode === "webhook" ? "webhook" : normalizedMode === "none" ? "none" : normalizedMode === "deliver" ? "announce" : void 0;
+	const deliveryChannel = normalizeChannel(delivery?.channel);
+	const deliveryTo = normalizeTo$1(delivery?.to);
+	const deliveryThreadId = normalizeThreadId(delivery?.threadId);
+	const channel = deliveryChannel ?? "last";
+	const to = deliveryTo;
+	const deliveryAccountId = normalizeAccountId(delivery?.accountId);
+	if (hasDelivery) {
+		const resolvedMode = mode ?? "announce";
+		return {
+			mode: resolvedMode,
+			channel: resolvedMode === "announce" ? channel : void 0,
+			to,
+			threadId: resolvedMode === "announce" ? deliveryThreadId : void 0,
+			accountId: deliveryAccountId,
+			source: "delivery",
+			requested: resolvedMode === "announce"
+		};
+	}
+	const resolvedMode = job.payload.kind === "agentTurn" && (job.sessionTarget === "isolated" || job.sessionTarget === "current" || job.sessionTarget.startsWith("session:")) ? "announce" : "none";
+	return {
+		mode: resolvedMode,
+		channel: resolvedMode === "announce" ? "last" : void 0,
+		to: void 0,
+		threadId: void 0,
+		source: "delivery",
+		requested: resolvedMode === "announce"
+	};
+}
+function normalizeFailureMode(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim().toLowerCase();
+	if (trimmed === "announce" || trimmed === "webhook") return trimmed;
+}
+function resolveFailureDestination(job, globalConfig) {
+	const delivery = job.delivery;
+	const jobFailureDest = delivery?.failureDestination;
+	const hasJobFailureDest = jobFailureDest && typeof jobFailureDest === "object";
+	let channel;
+	let to;
+	let accountId;
+	let mode;
+	if (globalConfig) {
+		channel = normalizeChannel(globalConfig.channel);
+		to = normalizeTo$1(globalConfig.to);
+		accountId = normalizeAccountId(globalConfig.accountId);
+		mode = normalizeFailureMode(globalConfig.mode);
+	}
+	if (hasJobFailureDest) {
+		const jobChannel = normalizeChannel(jobFailureDest.channel);
+		const jobTo = normalizeTo$1(jobFailureDest.to);
+		const jobAccountId = normalizeAccountId(jobFailureDest.accountId);
+		const jobMode = normalizeFailureMode(jobFailureDest.mode);
+		const hasJobChannelField = "channel" in jobFailureDest;
+		const hasJobToField = "to" in jobFailureDest;
+		const hasJobAccountIdField = "accountId" in jobFailureDest;
+		const jobToExplicitValue = hasJobToField && jobTo !== void 0;
+		if (hasJobChannelField) channel = jobChannel;
+		if (hasJobToField) to = jobTo;
+		if (hasJobAccountIdField) accountId = jobAccountId;
+		if (jobMode !== void 0) {
+			const globalMode = globalConfig?.mode ?? "announce";
+			if (!jobToExplicitValue && globalMode !== jobMode) to = void 0;
+			mode = jobMode;
+		}
+	}
+	if (!channel && !to && !accountId && !mode) return null;
+	const resolvedMode = mode ?? "announce";
+	if (resolvedMode === "webhook" && !to) return null;
+	const result = {
+		mode: resolvedMode,
+		channel: resolvedMode === "announce" ? channel ?? "last" : void 0,
+		to,
+		accountId
+	};
+	if (delivery && isSameDeliveryTarget(delivery, result)) return null;
+	return result;
+}
+function isSameDeliveryTarget(delivery, failurePlan) {
+	const primaryMode = delivery.mode ?? "announce";
+	if (primaryMode === "none") return false;
+	const primaryChannel = delivery.channel;
+	const primaryTo = delivery.to;
+	const primaryAccountId = delivery.accountId;
+	if (failurePlan.mode === "webhook") return primaryMode === "webhook" && primaryTo === failurePlan.to;
+	const primaryChannelNormalized = primaryChannel ?? "last";
+	return (failurePlan.channel ?? "last") === primaryChannelNormalized && failurePlan.to === primaryTo && failurePlan.accountId === primaryAccountId;
+}
+const FAILURE_NOTIFICATION_TIMEOUT_MS = 3e4;
+const cronDeliveryLogger = getChildLogger({ subsystem: "cron-delivery" });
+async function sendFailureNotificationAnnounce(deps, cfg, agentId, jobId, target, message) {
+	const resolvedTarget = await resolveDeliveryTarget(cfg, agentId, {
+		channel: target.channel,
+		to: target.to,
+		accountId: target.accountId
+	});
+	if (!resolvedTarget.ok) {
+		cronDeliveryLogger.warn({ error: resolvedTarget.error.message }, "cron: failed to resolve failure destination target");
+		return;
+	}
+	const identity = resolveAgentOutboundIdentity(cfg, agentId);
+	const session = buildOutboundSessionContext({
+		cfg,
+		agentId,
+		sessionKey: `cron:${jobId}:failure`
+	});
+	const abortController = new AbortController();
+	const timeout = setTimeout(() => {
+		abortController.abort();
+	}, FAILURE_NOTIFICATION_TIMEOUT_MS);
+	try {
+		await deliverOutboundPayloads({
+			cfg,
+			channel: resolvedTarget.channel,
+			to: resolvedTarget.to,
+			accountId: resolvedTarget.accountId,
+			threadId: resolvedTarget.threadId,
+			payloads: [{ text: message }],
+			session,
+			identity,
+			bestEffort: false,
+			deps: createOutboundSendDeps(deps),
+			abortSignal: abortController.signal
+		});
+	} catch (err) {
+		cronDeliveryLogger.warn({
+			err: formatErrorMessage(err),
+			channel: resolvedTarget.channel,
+			to: resolvedTarget.to
+		}, "cron: failure destination announce failed");
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+//#endregion
+//#region src/cron/heartbeat-policy.ts
+function shouldSkipHeartbeatOnlyDelivery(payloads, ackMaxChars) {
+	if (payloads.length === 0) return true;
+	if (payloads.some((payload) => resolveSendableOutboundReplyParts(payload).hasMedia)) return false;
+	return payloads.some((payload) => {
+		return stripHeartbeatToken(payload.text, {
+			mode: "heartbeat",
+			maxAckChars: ackMaxChars
+		}).shouldSkip;
+	});
+}
+//#endregion
+//#region src/cron/isolated-agent/helpers.ts
+function pickSummaryFromOutput(text) {
+	const clean = (text ?? "").trim();
+	if (!clean) return;
+	const limit = 2e3;
+	return clean.length > limit ? `${truncateUtf16Safe(clean, limit)}…` : clean;
+}
+function pickSummaryFromPayloads(payloads) {
+	for (let i = payloads.length - 1; i >= 0; i--) {
+		if (payloads[i]?.isError) continue;
+		const summary = pickSummaryFromOutput(payloads[i]?.text);
+		if (summary) return summary;
+	}
+	for (let i = payloads.length - 1; i >= 0; i--) {
+		const summary = pickSummaryFromOutput(payloads[i]?.text);
+		if (summary) return summary;
+	}
+}
+function pickLastNonEmptyTextFromPayloads(payloads) {
+	for (let i = payloads.length - 1; i >= 0; i--) {
+		if (payloads[i]?.isError) continue;
+		const clean = (payloads[i]?.text ?? "").trim();
+		if (clean) return clean;
+	}
+	for (let i = payloads.length - 1; i >= 0; i--) {
+		const clean = (payloads[i]?.text ?? "").trim();
+		if (clean) return clean;
+	}
+}
+function isDeliverablePayload(payload) {
+	if (!payload) return false;
+	const hasInteractive = (payload.interactive?.blocks?.length ?? 0) > 0;
+	const hasChannelData = Object.keys(payload.channelData ?? {}).length > 0;
+	return hasOutboundReplyContent(payload, { trimText: true }) || hasInteractive || hasChannelData;
+}
+function pickLastDeliverablePayload(payloads) {
+	for (let i = payloads.length - 1; i >= 0; i--) {
+		if (payloads[i]?.isError) continue;
+		if (isDeliverablePayload(payloads[i])) return payloads[i];
+	}
+	for (let i = payloads.length - 1; i >= 0; i--) if (isDeliverablePayload(payloads[i])) return payloads[i];
+}
+function pickDeliverablePayloads(payloads) {
+	const successfulDeliverablePayloads = payloads.filter((payload) => payload != null && payload.isError !== true && isDeliverablePayload(payload));
+	if (successfulDeliverablePayloads.length > 0) return successfulDeliverablePayloads;
+	const lastDeliverablePayload = pickLastDeliverablePayload(payloads);
+	return lastDeliverablePayload ? [lastDeliverablePayload] : [];
+}
+/**
+* Check if delivery should be skipped because the agent signaled no user-visible update.
+* Returns true when any payload is a heartbeat ack token and no payload contains media.
+*/
+function isHeartbeatOnlyResponse(payloads, ackMaxChars) {
+	return shouldSkipHeartbeatOnlyDelivery(payloads, ackMaxChars);
+}
+function resolveHeartbeatAckMaxChars(agentCfg) {
+	const raw = agentCfg?.heartbeat?.ackMaxChars ?? 300;
+	return Math.max(0, raw);
+}
+function resolveCronPayloadOutcome(params) {
+	const firstText = params.payloads[0]?.text ?? "";
+	const summary = pickSummaryFromPayloads(params.payloads) ?? pickSummaryFromOutput(firstText);
+	const outputText = pickLastNonEmptyTextFromPayloads(params.payloads);
+	const synthesizedText = outputText?.trim() || summary?.trim() || void 0;
+	const deliveryPayload = pickLastDeliverablePayload(params.payloads);
+	const selectedDeliveryPayloads = pickDeliverablePayloads(params.payloads);
+	const resolvedDeliveryPayloads = selectedDeliveryPayloads.length > 0 ? selectedDeliveryPayloads : synthesizedText ? [{ text: synthesizedText }] : [];
+	const deliveryPayloadHasStructuredContent = deliveryPayload?.mediaUrl !== void 0 || (deliveryPayload?.mediaUrls?.length ?? 0) > 0 || (deliveryPayload?.interactive?.blocks?.length ?? 0) > 0 || Object.keys(deliveryPayload?.channelData ?? {}).length > 0;
+	const hasErrorPayload = params.payloads.some((payload) => payload?.isError === true);
+	const lastErrorPayloadIndex = params.payloads.findLastIndex((payload) => payload?.isError === true);
+	const hasSuccessfulPayloadAfterLastError = !params.runLevelError && lastErrorPayloadIndex >= 0 && params.payloads.slice(lastErrorPayloadIndex + 1).some((payload) => payload?.isError !== true && Boolean(payload?.text?.trim()));
+	const hasFatalErrorPayload = hasErrorPayload && !hasSuccessfulPayloadAfterLastError;
+	const lastErrorPayloadText = [...params.payloads].toReversed().find((payload) => payload?.isError === true && Boolean(payload?.text?.trim()))?.text?.trim();
+	return {
+		summary,
+		outputText,
+		synthesizedText,
+		deliveryPayload,
+		deliveryPayloads: resolvedDeliveryPayloads,
+		deliveryPayloadHasStructuredContent,
+		hasFatalErrorPayload,
+		embeddedRunError: hasFatalErrorPayload ? lastErrorPayloadText ?? "cron isolated run returned an error payload" : void 0
+	};
+}
+//#endregion
+//#region src/cron/isolated-agent/subagent-followup.ts
+function resolveCronSubagentTimings() {
+	const fastTestMode = process.env.OPENCLAW_TEST_FAST === "1";
+	return {
+		waitMinMs: fastTestMode ? 10 : 3e4,
+		finalReplyGraceMs: fastTestMode ? 50 : 5e3,
+		gracePollMs: fastTestMode ? 8 : 200
+	};
+}
+const SUBAGENT_FOLLOWUP_HINTS = [
+	"subagent spawned",
+	"spawned a subagent",
+	"auto-announce when done",
+	"both subagents are running",
+	"wait for them to report back"
+];
+const INTERIM_CRON_HINTS = [
+	"on it",
+	"pulling everything together",
+	"give me a few",
+	"give me a few min",
+	"few minutes",
+	"let me compile",
+	"i'll gather",
+	"i will gather",
+	"working on it",
+	"retrying now",
+	"should be about",
+	"should have your summary",
+	"it'll auto-announce when done",
+	"it will auto-announce when done",
+	...SUBAGENT_FOLLOWUP_HINTS
+];
+function normalizeHintText(value) {
+	return value.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function isLikelyInterimCronMessage(value) {
+	const normalized = normalizeHintText(value);
+	if (!normalized) return false;
+	return normalized.split(" ").filter(Boolean).length <= 45 && INTERIM_CRON_HINTS.some((hint) => normalized.includes(hint));
+}
+function expectsSubagentFollowup(value) {
+	const normalized = normalizeHintText(value);
+	return Boolean(normalized && SUBAGENT_FOLLOWUP_HINTS.some((hint) => normalized.includes(hint)));
+}
+async function readDescendantSubagentFallbackReply(params) {
+	const descendants = listDescendantRunsForRequester(params.sessionKey).filter((entry) => typeof entry.endedAt === "number" && entry.endedAt >= params.runStartedAt && entry.childSessionKey.trim().length > 0).toSorted((a, b) => (a.endedAt ?? 0) - (b.endedAt ?? 0));
+	if (descendants.length === 0) return;
+	const latestByChild = /* @__PURE__ */ new Map();
+	for (const entry of descendants) {
+		const childKey = entry.childSessionKey.trim();
+		if (!childKey) continue;
+		const current = latestByChild.get(childKey);
+		if (!current || (entry.endedAt ?? 0) >= (current.endedAt ?? 0)) latestByChild.set(childKey, entry);
+	}
+	const replies = [];
+	const latestRuns = [...latestByChild.values()].toSorted((a, b) => (a.endedAt ?? 0) - (b.endedAt ?? 0)).slice(-4);
+	for (const entry of latestRuns) {
+		let reply = (await readLatestAssistantReply({ sessionKey: entry.childSessionKey }))?.trim();
+		if (!reply && typeof entry.frozenResultText === "string" && entry.frozenResultText.trim()) reply = entry.frozenResultText.trim();
+		if (!reply || reply.toUpperCase() === "NO_REPLY".toUpperCase()) continue;
+		replies.push(reply);
+	}
+	if (replies.length === 0) return;
+	if (replies.length === 1) return replies[0];
+	return replies.join("\n\n");
+}
+/**
+* Waits for descendant subagents to complete using a push-based approach:
+* each active descendant run is awaited via `agent.wait` (gateway RPC) instead
+* of a busy-poll loop.  After all active runs settle, a short grace period
+* polls the cron agent's session for a post-orchestration synthesis message.
+*/
+async function waitForDescendantSubagentSummary(params) {
+	const timings = resolveCronSubagentTimings();
+	const initialReply = params.initialReply?.trim();
+	const deadline = Date.now() + Math.max(timings.waitMinMs, Math.floor(params.timeoutMs));
+	const getActiveRuns = () => listDescendantRunsForRequester(params.sessionKey).filter((entry) => typeof entry.endedAt !== "number");
+	const initialActiveRuns = getActiveRuns();
+	if (!(params.observedActiveDescendants === true || initialActiveRuns.length > 0)) return initialReply;
+	let pendingRunIds = new Set(initialActiveRuns.map((e) => e.runId));
+	while (pendingRunIds.size > 0 && Date.now() < deadline) {
+		const remainingMs = Math.max(1, deadline - Date.now());
+		await Promise.allSettled([...pendingRunIds].map((runId) => callGateway({
+			method: "agent.wait",
+			params: {
+				runId,
+				timeoutMs: remainingMs
+			},
+			timeoutMs: remainingMs + 2e3
+		}).catch(() => void 0)));
+		pendingRunIds = new Set(getActiveRuns().map((e) => e.runId));
+	}
+	const gracePeriodDeadline = Math.min(Date.now() + timings.finalReplyGraceMs, deadline);
+	const resolveUsableLatestReply = async () => {
+		const latest = (await readLatestAssistantReply({ sessionKey: params.sessionKey }))?.trim();
+		if (latest && latest.toUpperCase() !== "NO_REPLY".toUpperCase() && (latest !== initialReply || !isLikelyInterimCronMessage(latest))) return latest;
+	};
+	while (Date.now() < gracePeriodDeadline) {
+		const latest = await resolveUsableLatestReply();
+		if (latest) return latest;
+		await new Promise((resolve) => setTimeout(resolve, timings.gracePollMs));
+	}
+	const latest = await resolveUsableLatestReply();
+	if (latest) return latest;
+}
+//#endregion
+//#region src/cron/isolated-agent/delivery-dispatch.ts
+function normalizeDeliveryTarget(channel, to) {
+	const channelLower = channel.trim().toLowerCase();
+	const toTrimmed = to.trim();
+	if (channelLower === "feishu" || channelLower === "lark") {
+		const lowered = toTrimmed.toLowerCase();
+		if (lowered.startsWith("user:")) return toTrimmed.slice(5).trim();
+		if (lowered.startsWith("chat:")) return toTrimmed.slice(5).trim();
+	}
+	return toTrimmed;
+}
+function matchesMessagingToolDeliveryTarget(target, delivery) {
+	if (!delivery.channel || !delivery.to || !target.to) return false;
+	const channel = delivery.channel.trim().toLowerCase();
+	const provider = target.provider?.trim().toLowerCase();
+	if (provider && provider !== "message" && provider !== channel) return false;
+	if (target.accountId && delivery.accountId && target.accountId !== delivery.accountId) return false;
+	return normalizeDeliveryTarget(channel, target.to.replace(/:topic:\d+$/, "")) === normalizeDeliveryTarget(channel, delivery.to);
+}
+function resolveCronDeliveryBestEffort(job) {
+	return job.delivery?.bestEffort === true;
+}
+const TRANSIENT_DIRECT_CRON_DELIVERY_ERROR_PATTERNS = [
+	/\berrorcode=unavailable\b/i,
+	/\bstatus\s*[:=]\s*"?unavailable\b/i,
+	/\bUNAVAILABLE\b/,
+	/no active .* listener/i,
+	/gateway not connected/i,
+	/gateway closed \(1006/i,
+	/gateway timeout/i,
+	/\b(econnreset|econnrefused|etimedout|enotfound|ehostunreach|network error)\b/i
+];
+const PERMANENT_DIRECT_CRON_DELIVERY_ERROR_PATTERNS = [
+	/unsupported channel/i,
+	/unknown channel/i,
+	/chat not found/i,
+	/user not found/i,
+	/bot.*not.*member/i,
+	/bot was blocked by the user/i,
+	/forbidden: bot was kicked/i,
+	/recipient is not a valid/i,
+	/outbound not configured for channel/i
+];
+const STALE_CRON_DELIVERY_MAX_START_DELAY_MS = 180 * 6e4;
+const COMPLETED_DIRECT_CRON_DELIVERIES = /* @__PURE__ */ new Map();
+function cloneDeliveryResults(results) {
+	return results.map((result) => ({
+		...result,
+		...result.meta ? { meta: { ...result.meta } } : {}
+	}));
+}
+function pruneCompletedDirectCronDeliveries(now) {
+	const ttlMs = process.env.OPENCLAW_TEST_FAST === "1" ? 6e4 : 1440 * 60 * 1e3;
+	for (const [key, entry] of COMPLETED_DIRECT_CRON_DELIVERIES) if (now - entry.ts >= ttlMs) COMPLETED_DIRECT_CRON_DELIVERIES.delete(key);
+	const maxEntries = 2e3;
+	if (COMPLETED_DIRECT_CRON_DELIVERIES.size <= maxEntries) return;
+	const entries = [...COMPLETED_DIRECT_CRON_DELIVERIES.entries()].toSorted((a, b) => a[1].ts - b[1].ts);
+	const toDelete = COMPLETED_DIRECT_CRON_DELIVERIES.size - maxEntries;
+	for (let i = 0; i < toDelete; i += 1) {
+		const oldest = entries[i];
+		if (!oldest) break;
+		COMPLETED_DIRECT_CRON_DELIVERIES.delete(oldest[0]);
+	}
+}
+function resolveCronDeliveryScheduledAtMs(params) {
+	const scheduledAt = params.job.state?.nextRunAtMs;
+	return typeof scheduledAt === "number" && Number.isFinite(scheduledAt) ? scheduledAt : params.runStartedAt;
+}
+function resolveCronDeliveryStartDelayMs(params) {
+	return params.runStartedAt - resolveCronDeliveryScheduledAtMs(params);
+}
+function isStaleCronDelivery(params) {
+	return resolveCronDeliveryStartDelayMs(params) > STALE_CRON_DELIVERY_MAX_START_DELAY_MS;
+}
+function rememberCompletedDirectCronDelivery(idempotencyKey, results) {
+	const now = Date.now();
+	COMPLETED_DIRECT_CRON_DELIVERIES.set(idempotencyKey, {
+		ts: now,
+		results: cloneDeliveryResults(results)
+	});
+	pruneCompletedDirectCronDeliveries(now);
+}
+function getCompletedDirectCronDelivery(idempotencyKey) {
+	pruneCompletedDirectCronDeliveries(Date.now());
+	const cached = COMPLETED_DIRECT_CRON_DELIVERIES.get(idempotencyKey);
+	if (!cached) return;
+	return cloneDeliveryResults(cached.results);
+}
+function buildDirectCronDeliveryIdempotencyKey(params) {
+	const threadId = params.delivery.threadId == null || params.delivery.threadId === "" ? "" : String(params.delivery.threadId);
+	const accountId = params.delivery.accountId?.trim() ?? "";
+	const normalizedTo = normalizeDeliveryTarget(params.delivery.channel, params.delivery.to);
+	return `cron-direct-delivery:v1:${params.runSessionId}:${params.delivery.channel}:${accountId}:${normalizedTo}:${threadId}`;
+}
+function shouldQueueCronAwareness(job, deliveryBestEffort) {
+	return job.sessionTarget === "isolated" && !deliveryBestEffort;
+}
+function resolveCronAwarenessMainSessionKey(params) {
+	return params.cfg.session?.scope === "global" ? resolveMainSessionKey(params.cfg) : resolveAgentMainSessionKey({
+		cfg: params.cfg,
+		agentId: params.agentId
+	});
+}
+function queueCronAwarenessSystemEvent(params) {
+	const text = params.outputText?.trim() || params.synthesizedText?.trim() || void 0;
+	if (!text) return;
+	try {
+		enqueueSystemEvent(text, {
+			sessionKey: resolveCronAwarenessMainSessionKey({
+				cfg: params.cfg,
+				agentId: params.agentId
+			}),
+			contextKey: params.deliveryIdempotencyKey
+		});
+	} catch (err) {
+		logWarn(`[cron:${params.jobId}] failed to queue isolated cron awareness for the main session: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+function summarizeDirectCronDeliveryError(error) {
+	if (error instanceof Error) return error.message || "error";
+	if (typeof error === "string") return error;
+	try {
+		return JSON.stringify(error) || String(error);
+	} catch {
+		return String(error);
+	}
+}
+function isTransientDirectCronDeliveryError(error) {
+	const message = summarizeDirectCronDeliveryError(error);
+	if (!message) return false;
+	if (PERMANENT_DIRECT_CRON_DELIVERY_ERROR_PATTERNS.some((re) => re.test(message))) return false;
+	return TRANSIENT_DIRECT_CRON_DELIVERY_ERROR_PATTERNS.some((re) => re.test(message));
+}
+function resolveDirectCronRetryDelaysMs() {
+	return [
+		5e3,
+		1e4,
+		2e4
+	];
+}
+async function retryTransientDirectCronDelivery(params) {
+	const retryDelaysMs = resolveDirectCronRetryDelaysMs();
+	let retryIndex = 0;
+	for (;;) {
+		if (params.signal?.aborted) throw new Error("cron delivery aborted");
+		try {
+			return await params.run();
+		} catch (err) {
+			const delayMs = retryDelaysMs[retryIndex];
+			if (delayMs == null || !isTransientDirectCronDeliveryError(err) || params.signal?.aborted) throw err;
+			const nextAttempt = retryIndex + 2;
+			const maxAttempts = retryDelaysMs.length + 1;
+			logWarn(`[cron:${params.jobId}] transient direct announce delivery failure, retrying ${nextAttempt}/${maxAttempts} in ${Math.round(delayMs / 1e3)}s: ${summarizeDirectCronDeliveryError(err)}`);
+			retryIndex += 1;
+			await sleepWithAbort(delayMs, params.signal);
+		}
+	}
+}
+async function dispatchCronDelivery(params) {
+	const skipMessagingToolDelivery = params.skipMessagingToolDelivery === true;
+	let summary = params.summary;
+	let outputText = params.outputText;
+	let synthesizedText = params.synthesizedText;
+	let deliveryPayloads = params.deliveryPayloads;
+	let delivered = skipMessagingToolDelivery;
+	let deliveryAttempted = skipMessagingToolDelivery;
+	const failDeliveryTarget = (error) => params.withRunSession({
+		status: "error",
+		error,
+		errorKind: "delivery-target",
+		summary,
+		outputText,
+		deliveryAttempted,
+		...params.telemetry
+	});
+	const deliverViaDirect = async (delivery, options) => {
+		const identity = resolveAgentOutboundIdentity(params.cfgWithAgentDefaults, params.agentId);
+		const deliveryIdempotencyKey = buildDirectCronDeliveryIdempotencyKey({
+			runSessionId: params.runSessionId,
+			delivery
+		});
+		try {
+			const payloadsForDelivery = deliveryPayloads.length > 0 ? deliveryPayloads : synthesizedText ? [{ text: synthesizedText }] : [];
+			if (payloadsForDelivery.length === 0) return null;
+			if (params.isAborted()) return params.withRunSession({
+				status: "error",
+				error: params.abortReason(),
+				deliveryAttempted,
+				...params.telemetry
+			});
+			if (params.deliveryRequested && isStaleCronDelivery({
+				job: params.job,
+				runStartedAt: params.runStartedAt
+			})) {
+				deliveryAttempted = true;
+				const nowMs = Date.now();
+				const scheduledAtMs = resolveCronDeliveryScheduledAtMs({
+					job: params.job,
+					runStartedAt: params.runStartedAt
+				});
+				const startDelayMs = resolveCronDeliveryStartDelayMs({
+					job: params.job,
+					runStartedAt: params.runStartedAt
+				});
+				logWarn(`[cron:${params.job.id}] skipping stale delivery scheduled at ${new Date(scheduledAtMs).toISOString()}, started ${Math.round(startDelayMs / 6e4)}m late, current age ${Math.round((nowMs - scheduledAtMs) / 6e4)}m`);
+				return params.withRunSession({
+					status: "ok",
+					summary,
+					outputText,
+					deliveryAttempted,
+					delivered: false,
+					...params.telemetry
+				});
+			}
+			deliveryAttempted = true;
+			if (getCompletedDirectCronDelivery(deliveryIdempotencyKey)) {
+				delivered = true;
+				return null;
+			}
+			const deliverySession = buildOutboundSessionContext({
+				cfg: params.cfgWithAgentDefaults,
+				agentId: params.agentId,
+				sessionKey: params.agentSessionKey
+			});
+			let hadPartialFailure = false;
+			const onError = params.deliveryBestEffort ? (err, _payload) => {
+				hadPartialFailure = true;
+				logError(`[cron:${params.job.id}] delivery payload failed (bestEffort): ${err instanceof Error ? err.message : String(err)}`);
+			} : void 0;
+			const runDelivery = async () => await deliverOutboundPayloads({
+				cfg: params.cfgWithAgentDefaults,
+				channel: delivery.channel,
+				to: delivery.to,
+				accountId: delivery.accountId,
+				threadId: delivery.threadId,
+				payloads: payloadsForDelivery,
+				session: deliverySession,
+				identity,
+				bestEffort: params.deliveryBestEffort,
+				deps: createOutboundSendDeps(params.deps),
+				abortSignal: params.abortSignal,
+				onError,
+				skipQueue: true
+			});
+			const deliveryResults = options?.retryTransient ? await retryTransientDirectCronDelivery({
+				jobId: params.job.id,
+				signal: params.abortSignal,
+				run: runDelivery
+			}) : await runDelivery();
+			delivered = deliveryResults.length > 0 && !hadPartialFailure;
+			if (delivered && shouldQueueCronAwareness(params.job, params.deliveryBestEffort)) queueCronAwarenessSystemEvent({
+				cfg: params.cfgWithAgentDefaults,
+				jobId: params.job.id,
+				agentId: params.agentId,
+				deliveryIdempotencyKey,
+				outputText,
+				synthesizedText
+			});
+			if (delivered) rememberCompletedDirectCronDelivery(deliveryIdempotencyKey, deliveryResults);
+			return null;
+		} catch (err) {
+			if (!params.deliveryBestEffort) return params.withRunSession({
+				status: "error",
+				summary,
+				outputText,
+				error: String(err),
+				deliveryAttempted,
+				...params.telemetry
+			});
+			logError(`[cron:${params.job.id}] delivery failed (bestEffort): ${err instanceof Error ? err.message : String(err)}`);
+			return null;
+		}
+	};
+	const finalizeTextDelivery = async (delivery) => {
+		const cleanupDirectCronSessionIfNeeded = async () => {
+			if (!params.job.deleteAfterRun) return;
+			try {
+				await callGateway({
+					method: "sessions.delete",
+					params: {
+						key: params.agentSessionKey,
+						deleteTranscript: true,
+						emitLifecycleHooks: false
+					},
+					timeoutMs: 1e4
+				});
+			} catch {}
+		};
+		if (!synthesizedText) return null;
+		const initialSynthesizedText = synthesizedText.trim();
+		let activeSubagentRuns = countActiveDescendantRuns(params.agentSessionKey);
+		const expectedSubagentFollowup = expectsSubagentFollowup(initialSynthesizedText);
+		const completedDescendantReply = activeSubagentRuns === 0 && isLikelyInterimCronMessage(initialSynthesizedText) ? await readDescendantSubagentFallbackReply({
+			sessionKey: params.agentSessionKey,
+			runStartedAt: params.runStartedAt
+		}) : void 0;
+		const hadDescendants = activeSubagentRuns > 0 || Boolean(completedDescendantReply);
+		if (activeSubagentRuns > 0 || expectedSubagentFollowup) {
+			let finalReply = await waitForDescendantSubagentSummary({
+				sessionKey: params.agentSessionKey,
+				initialReply: initialSynthesizedText,
+				timeoutMs: params.timeoutMs,
+				observedActiveDescendants: activeSubagentRuns > 0 || expectedSubagentFollowup
+			});
+			activeSubagentRuns = countActiveDescendantRuns(params.agentSessionKey);
+			if (!finalReply && activeSubagentRuns === 0) finalReply = await readDescendantSubagentFallbackReply({
+				sessionKey: params.agentSessionKey,
+				runStartedAt: params.runStartedAt
+			});
+			if (finalReply && activeSubagentRuns === 0) {
+				outputText = finalReply;
+				summary = pickSummaryFromOutput(finalReply) ?? summary;
+				synthesizedText = finalReply;
+				deliveryPayloads = [{ text: finalReply }];
+			}
+		} else if (completedDescendantReply) {
+			outputText = completedDescendantReply;
+			summary = pickSummaryFromOutput(completedDescendantReply) ?? summary;
+			synthesizedText = completedDescendantReply;
+			deliveryPayloads = [{ text: completedDescendantReply }];
+		}
+		if (activeSubagentRuns > 0) {
+			deliveryAttempted = true;
+			return params.withRunSession({
+				status: "ok",
+				summary,
+				outputText,
+				deliveryAttempted,
+				...params.telemetry
+			});
+		}
+		if (hadDescendants && synthesizedText.trim() === initialSynthesizedText && isLikelyInterimCronMessage(initialSynthesizedText) && initialSynthesizedText.toUpperCase() !== "NO_REPLY".toUpperCase()) {
+			deliveryAttempted = true;
+			return params.withRunSession({
+				status: "ok",
+				summary,
+				outputText,
+				deliveryAttempted,
+				...params.telemetry
+			});
+		}
+		if (synthesizedText.toUpperCase() === "NO_REPLY".toUpperCase()) {
+			await cleanupDirectCronSessionIfNeeded();
+			return params.withRunSession({
+				status: "ok",
+				summary,
+				outputText,
+				delivered: false,
+				...params.telemetry
+			});
+		}
+		if (params.isAborted()) return params.withRunSession({
+			status: "error",
+			error: params.abortReason(),
+			deliveryAttempted,
+			...params.telemetry
+		});
+		try {
+			return await deliverViaDirect(delivery, { retryTransient: true });
+		} finally {
+			await cleanupDirectCronSessionIfNeeded();
+		}
+	};
+	if (params.deliveryRequested && !params.skipHeartbeatDelivery && !skipMessagingToolDelivery) {
+		if (!params.resolvedDelivery.ok) {
+			if (!params.deliveryBestEffort) return {
+				result: failDeliveryTarget(params.resolvedDelivery.error.message),
+				delivered,
+				deliveryAttempted,
+				summary,
+				outputText,
+				synthesizedText,
+				deliveryPayloads
+			};
+			logWarn(`[cron:${params.job.id}] ${params.resolvedDelivery.error.message}`);
+			return {
+				result: params.withRunSession({
+					status: "ok",
+					summary,
+					outputText,
+					deliveryAttempted,
+					...params.telemetry
+				}),
+				delivered,
+				deliveryAttempted,
+				summary,
+				outputText,
+				synthesizedText,
+				deliveryPayloads
+			};
+		}
+		if (params.deliveryPayloadHasStructuredContent || params.resolvedDelivery.threadId != null) {
+			const directResult = await deliverViaDirect(params.resolvedDelivery);
+			if (directResult) return {
+				result: directResult,
+				delivered,
+				deliveryAttempted,
+				summary,
+				outputText,
+				synthesizedText,
+				deliveryPayloads
+			};
+		} else {
+			const finalizedTextResult = await finalizeTextDelivery(params.resolvedDelivery);
+			if (finalizedTextResult) return {
+				result: finalizedTextResult,
+				delivered,
+				deliveryAttempted,
+				summary,
+				outputText,
+				synthesizedText,
+				deliveryPayloads
+			};
+		}
+	}
+	return {
+		delivered,
+		deliveryAttempted,
+		summary,
+		outputText,
+		synthesizedText,
+		deliveryPayloads
+	};
+}
+//#endregion
+//#region src/cron/isolated-agent/model-selection.ts
+async function resolveCronModelSelection(params) {
+	const resolvedDefault = resolveConfiguredModelRef({
+		cfg: params.cfgWithAgentDefaults,
+		defaultProvider: DEFAULT_PROVIDER,
+		defaultModel: DEFAULT_MODEL
+	});
+	let provider = resolvedDefault.provider;
+	let model = resolvedDefault.model;
+	let catalog;
+	const loadCatalogOnce = async () => {
+		if (!catalog) catalog = await loadModelCatalog({ config: params.cfgWithAgentDefaults });
+		return catalog;
+	};
+	const subagentModelRaw = normalizeModelSelection(params.agentConfigOverride?.subagents?.model) ?? normalizeModelSelection(params.agentConfigOverride?.model) ?? normalizeModelSelection(params.cfg.agents?.defaults?.subagents?.model);
+	if (subagentModelRaw) {
+		const resolvedSubagent = resolveAllowedModelRef({
+			cfg: params.cfgWithAgentDefaults,
+			catalog: await loadCatalogOnce(),
+			raw: subagentModelRaw,
+			defaultProvider: resolvedDefault.provider,
+			defaultModel: resolvedDefault.model
+		});
+		if (!("error" in resolvedSubagent)) {
+			provider = resolvedSubagent.ref.provider;
+			model = resolvedSubagent.ref.model;
+		}
+	}
+	let hooksGmailModelApplied = false;
+	const hooksGmailModelRef = params.isGmailHook ? resolveHooksGmailModel({
+		cfg: params.cfg,
+		defaultProvider: DEFAULT_PROVIDER
+	}) : null;
+	if (hooksGmailModelRef) {
+		if (getModelRefStatus({
+			cfg: params.cfg,
+			catalog: await loadCatalogOnce(),
+			ref: hooksGmailModelRef,
+			defaultProvider: resolvedDefault.provider,
+			defaultModel: resolvedDefault.model
+		}).allowed) {
+			provider = hooksGmailModelRef.provider;
+			model = hooksGmailModelRef.model;
+			hooksGmailModelApplied = true;
+		}
+	}
+	const modelOverrideRaw = params.payload.kind === "agentTurn" ? params.payload.model : void 0;
+	const modelOverride = typeof modelOverrideRaw === "string" ? modelOverrideRaw.trim() : void 0;
+	if (modelOverride !== void 0 && modelOverride.length > 0) {
+		const resolvedOverride = resolveAllowedModelRef({
+			cfg: params.cfgWithAgentDefaults,
+			catalog: await loadCatalogOnce(),
+			raw: modelOverride,
+			defaultProvider: resolvedDefault.provider,
+			defaultModel: resolvedDefault.model
+		});
+		if ("error" in resolvedOverride) {
+			if (resolvedOverride.error.startsWith("model not allowed:")) return {
+				ok: true,
+				provider,
+				model,
+				warning: `cron: payload.model '${modelOverride}' not allowed, falling back to agent defaults`
+			};
+			return {
+				ok: false,
+				error: resolvedOverride.error
+			};
+		}
+		provider = resolvedOverride.ref.provider;
+		model = resolvedOverride.ref.model;
+	}
+	if (!modelOverride && !hooksGmailModelApplied) {
+		const sessionModelOverride = params.sessionEntry.modelOverride?.trim();
+		if (sessionModelOverride) {
+			const sessionProviderOverride = params.sessionEntry.providerOverride?.trim() || resolvedDefault.provider;
+			const resolvedSessionOverride = resolveAllowedModelRef({
+				cfg: params.cfgWithAgentDefaults,
+				catalog: await loadCatalogOnce(),
+				raw: `${sessionProviderOverride}/${sessionModelOverride}`,
+				defaultProvider: resolvedDefault.provider,
+				defaultModel: resolvedDefault.model
+			});
+			if (!("error" in resolvedSessionOverride)) {
+				provider = resolvedSessionOverride.ref.provider;
+				model = resolvedSessionOverride.ref.model;
+			}
+		}
+	}
+	return {
+		ok: true,
+		provider,
+		model
+	};
+}
+//#endregion
+//#region src/cron/isolated-agent/run-config.ts
+function extractCronAgentDefaultsOverride(agentConfigOverride) {
+	const { model: overrideModel, sandbox: _agentSandboxOverride, ...agentOverrideRest } = agentConfigOverride ?? {};
+	return {
+		overrideModel,
+		definedOverrides: Object.fromEntries(Object.entries(agentOverrideRest).filter(([, value]) => value !== void 0))
+	};
+}
+function mergeCronAgentModelOverride(params) {
+	const nextDefaults = { ...params.defaults };
+	const existingModel = nextDefaults.model && typeof nextDefaults.model === "object" ? nextDefaults.model : {};
+	if (typeof params.overrideModel === "string") nextDefaults.model = {
+		...existingModel,
+		primary: params.overrideModel
+	};
+	else if (params.overrideModel) nextDefaults.model = {
+		...existingModel,
+		...params.overrideModel
+	};
+	return nextDefaults;
+}
+function buildCronAgentDefaultsConfig(params) {
+	const { overrideModel, definedOverrides } = extractCronAgentDefaultsOverride(params.agentConfigOverride);
+	return mergeCronAgentModelOverride({
+		defaults: Object.assign({}, params.defaults, definedOverrides),
+		overrideModel
+	});
+}
+//#endregion
+//#region src/cron/isolated-agent/session-key.ts
+function resolveCronAgentSessionKey(params) {
+	const raw = toAgentStoreSessionKey({
+		agentId: params.agentId,
+		requestKey: params.sessionKey.trim(),
+		mainKey: params.mainKey
+	});
+	return canonicalizeMainSessionAlias({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		sessionKey: raw
+	});
+}
+//#endregion
+//#region src/cron/isolated-agent/skills-snapshot.ts
+function resolveCronSkillsSnapshot(params) {
+	if (params.isFastTestEnv) return params.existingSnapshot ?? {
+		prompt: "",
+		skills: []
+	};
+	const snapshotVersion = getSkillsSnapshotVersion(params.workspaceDir);
+	const skillFilter = resolveAgentSkillsFilter(params.config, params.agentId);
+	const existingSnapshot = params.existingSnapshot;
+	if (!(!existingSnapshot || existingSnapshot.version !== snapshotVersion || !matchesSkillFilter(existingSnapshot.skillFilter, skillFilter))) return existingSnapshot;
+	return buildWorkspaceSkillSnapshot(params.workspaceDir, {
+		config: params.config,
+		skillFilter,
+		eligibility: { remote: getRemoteSkillEligibility() },
+		snapshotVersion
+	});
+}
+//#endregion
+//#region src/cron/isolated-agent/run.ts
+function resolveNonNegativeNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function resolveCronToolPolicy(params) {
+	return {
+		requireExplicitMessageTarget: params.deliveryRequested && params.resolvedDelivery.ok,
+		disableMessageTool: params.deliveryContract === "cron-owned" ? true : params.deliveryRequested
+	};
+}
+async function resolveCronDeliveryContext(params) {
+	const deliveryPlan = resolveCronDeliveryPlan(params.job);
+	if (!deliveryPlan.requested) {
+		const resolvedDelivery = {
+			ok: false,
+			channel: void 0,
+			to: void 0,
+			accountId: void 0,
+			threadId: void 0,
+			mode: "implicit",
+			error: /* @__PURE__ */ new Error("cron delivery not requested")
+		};
+		return {
+			deliveryPlan,
+			deliveryRequested: false,
+			resolvedDelivery,
+			toolPolicy: resolveCronToolPolicy({
+				deliveryRequested: false,
+				resolvedDelivery,
+				deliveryContract: params.deliveryContract
+			})
+		};
+	}
+	const resolvedDelivery = await resolveDeliveryTarget(params.cfg, params.agentId, {
+		channel: deliveryPlan.channel ?? "last",
+		to: deliveryPlan.to,
+		threadId: deliveryPlan.threadId,
+		accountId: deliveryPlan.accountId,
+		sessionKey: params.job.sessionKey
+	});
+	return {
+		deliveryPlan,
+		deliveryRequested: deliveryPlan.requested,
+		resolvedDelivery,
+		toolPolicy: resolveCronToolPolicy({
+			deliveryRequested: deliveryPlan.requested,
+			resolvedDelivery,
+			deliveryContract: params.deliveryContract
+		})
+	};
+}
+function appendCronDeliveryInstruction(params) {
+	if (!params.deliveryRequested) return params.commandBody;
+	return `${params.commandBody}\n\nReturn your summary as plain text; it will be delivered automatically. If the task explicitly calls for messaging a specific external recipient, note who/where it should go instead of sending it yourself.`.trim();
+}
+async function runCronIsolatedAgentTurn(params) {
+	const abortSignal = params.abortSignal ?? params.signal;
+	const isAborted = () => abortSignal?.aborted === true;
+	const abortReason = () => {
+		const reason = abortSignal?.reason;
+		return typeof reason === "string" && reason.trim() ? reason.trim() : "cron: job execution timed out";
+	};
+	const isFastTestEnv = process.env.OPENCLAW_TEST_FAST === "1";
+	const deliveryContract = params.deliveryContract ?? "cron-owned";
+	const defaultAgentId = resolveDefaultAgentId(params.cfg);
+	const requestedAgentId = typeof params.agentId === "string" && params.agentId.trim() ? params.agentId : typeof params.job.agentId === "string" && params.job.agentId.trim() ? params.job.agentId : void 0;
+	const normalizedRequested = requestedAgentId ? normalizeAgentId(requestedAgentId) : void 0;
+	const agentConfigOverride = normalizedRequested ? resolveAgentConfig(params.cfg, normalizedRequested) : void 0;
+	const agentId = normalizedRequested ?? defaultAgentId;
+	const agentCfg = buildCronAgentDefaultsConfig({
+		defaults: params.cfg.agents?.defaults,
+		agentConfigOverride
+	});
+	const cfgWithAgentDefaults = {
+		...params.cfg,
+		agents: Object.assign({}, params.cfg.agents, { defaults: agentCfg })
+	};
+	let catalog;
+	const loadCatalog = async () => {
+		if (!catalog) catalog = await loadModelCatalog({ config: cfgWithAgentDefaults });
+		return catalog;
+	};
+	const baseSessionKey = (params.sessionKey?.trim() || `cron:${params.job.id}`).trim();
+	const agentSessionKey = resolveCronAgentSessionKey({
+		sessionKey: baseSessionKey,
+		agentId,
+		mainKey: params.cfg.session?.mainKey,
+		cfg: params.cfg
+	});
+	const hookExternalContentSource = (params.job.payload.kind === "agentTurn" ? params.job.payload.externalContentSource : void 0) ?? resolveHookExternalContentSource(baseSessionKey);
+	const workspaceDirRaw = resolveAgentWorkspaceDir(params.cfg, agentId);
+	const agentDir = resolveAgentDir(params.cfg, agentId);
+	const workspaceDir = (await ensureAgentWorkspace({
+		dir: workspaceDirRaw,
+		ensureBootstrapFiles: !agentCfg?.skipBootstrap && !isFastTestEnv
+	})).dir;
+	const isGmailHook = hookExternalContentSource === "gmail";
+	const now = Date.now();
+	const cronSession = resolveCronSession({
+		cfg: params.cfg,
+		sessionKey: agentSessionKey,
+		agentId,
+		nowMs: now,
+		forceNew: params.job.sessionTarget === "isolated"
+	});
+	const runSessionId = cronSession.sessionEntry.sessionId;
+	const runSessionKey = baseSessionKey.startsWith("cron:") ? `${agentSessionKey}:run:${runSessionId}` : agentSessionKey;
+	const persistSessionEntry = async () => {
+		if (isFastTestEnv) return;
+		cronSession.store[agentSessionKey] = cronSession.sessionEntry;
+		if (runSessionKey !== agentSessionKey) cronSession.store[runSessionKey] = cronSession.sessionEntry;
+		await updateSessionStore(cronSession.storePath, (store) => {
+			store[agentSessionKey] = cronSession.sessionEntry;
+			if (runSessionKey !== agentSessionKey) store[runSessionKey] = cronSession.sessionEntry;
+		});
+	};
+	const withRunSession = (result) => ({
+		...result,
+		sessionId: runSessionId,
+		sessionKey: runSessionKey
+	});
+	if (!cronSession.sessionEntry.label?.trim() && baseSessionKey.startsWith("cron:")) {
+		const labelSuffix = typeof params.job.name === "string" && params.job.name.trim() ? params.job.name.trim() : params.job.id;
+		cronSession.sessionEntry.label = `Cron: ${labelSuffix}`;
+	}
+	const resolvedModelSelection = await resolveCronModelSelection({
+		cfg: params.cfg,
+		cfgWithAgentDefaults,
+		agentConfigOverride,
+		sessionEntry: cronSession.sessionEntry,
+		payload: params.job.payload,
+		isGmailHook
+	});
+	if (!resolvedModelSelection.ok) return {
+		status: "error",
+		error: resolvedModelSelection.error
+	};
+	let provider = resolvedModelSelection.provider;
+	let model = resolvedModelSelection.model;
+	if (resolvedModelSelection.warning) logWarn(resolvedModelSelection.warning);
+	const hooksGmailThinking = isGmailHook ? normalizeThinkLevel(params.cfg.hooks?.gmail?.thinking) : void 0;
+	let thinkLevel = normalizeThinkLevel((params.job.payload.kind === "agentTurn" ? params.job.payload.thinking : void 0) ?? void 0) ?? hooksGmailThinking;
+	if (!thinkLevel) thinkLevel = resolveThinkingDefault({
+		cfg: cfgWithAgentDefaults,
+		provider,
+		model,
+		catalog: await loadCatalog()
+	});
+	if (thinkLevel === "xhigh" && !supportsXHighThinking(provider, model)) {
+		logWarn(`[cron:${params.job.id}] Thinking level "xhigh" is not supported for ${provider}/${model}; downgrading to "high".`);
+		thinkLevel = "high";
+	}
+	const timeoutMs = resolveAgentTimeoutMs({
+		cfg: cfgWithAgentDefaults,
+		overrideSeconds: params.job.payload.kind === "agentTurn" ? params.job.payload.timeoutSeconds : void 0
+	});
+	const agentPayload = params.job.payload.kind === "agentTurn" ? params.job.payload : null;
+	const { deliveryRequested, resolvedDelivery, toolPolicy } = await resolveCronDeliveryContext({
+		cfg: cfgWithAgentDefaults,
+		job: params.job,
+		agentId,
+		deliveryContract
+	});
+	const { formattedTime, timeLine } = resolveCronStyleNow(params.cfg, now);
+	const base = `[cron:${params.job.id} ${params.job.name}] ${params.message}`.trim();
+	const isExternalHook = hookExternalContentSource !== void 0 || isExternalHookSession(baseSessionKey);
+	const allowUnsafeExternalContent = agentPayload?.allowUnsafeExternalContent === true || isGmailHook && params.cfg.hooks?.gmail?.allowUnsafeExternalContent === true;
+	const shouldWrapExternal = isExternalHook && !allowUnsafeExternalContent;
+	let commandBody;
+	if (isExternalHook) {
+		const suspiciousPatterns = detectSuspiciousPatterns(params.message);
+		if (suspiciousPatterns.length > 0) logWarn(`[security] Suspicious patterns detected in external hook content (session=${baseSessionKey}, patterns=${suspiciousPatterns.length}): ${suspiciousPatterns.slice(0, 3).join(", ")}`);
+	}
+	if (shouldWrapExternal) {
+		const hookType = mapHookExternalContentSource(hookExternalContentSource ?? "webhook");
+		commandBody = `${buildSafeExternalPrompt({
+			content: params.message,
+			source: hookType,
+			jobName: params.job.name,
+			jobId: params.job.id,
+			timestamp: formattedTime
+		})}\n\n${timeLine}`.trim();
+	} else commandBody = `${base}\n${timeLine}`.trim();
+	commandBody = appendCronDeliveryInstruction({
+		commandBody,
+		deliveryRequested
+	});
+	const existingSkillsSnapshot = cronSession.sessionEntry.skillsSnapshot;
+	const skillsSnapshot = resolveCronSkillsSnapshot({
+		workspaceDir,
+		config: cfgWithAgentDefaults,
+		agentId,
+		existingSnapshot: existingSkillsSnapshot,
+		isFastTestEnv
+	});
+	if (!isFastTestEnv && skillsSnapshot !== existingSkillsSnapshot) {
+		cronSession.sessionEntry = {
+			...cronSession.sessionEntry,
+			updatedAt: Date.now(),
+			skillsSnapshot
+		};
+		await persistSessionEntry();
+	}
+	cronSession.sessionEntry.modelProvider = provider;
+	cronSession.sessionEntry.model = model;
+	cronSession.sessionEntry.systemSent = true;
+	try {
+		await persistSessionEntry();
+	} catch (err) {
+		logWarn(`[cron:${params.job.id}] Failed to persist pre-run session entry: ${String(err)}`);
+	}
+	const authProfileId = await resolveSessionAuthProfileOverride({
+		cfg: cfgWithAgentDefaults,
+		provider,
+		agentDir,
+		sessionEntry: cronSession.sessionEntry,
+		sessionStore: cronSession.store,
+		sessionKey: agentSessionKey,
+		storePath: cronSession.storePath,
+		isNewSession: cronSession.isNewSession
+	});
+	let liveSelection = {
+		provider,
+		model,
+		authProfileId,
+		authProfileIdSource: authProfileId ? cronSession.sessionEntry.authProfileOverrideSource : void 0
+	};
+	const syncSessionEntryLiveSelection = () => {
+		cronSession.sessionEntry.modelProvider = liveSelection.provider;
+		cronSession.sessionEntry.model = liveSelection.model;
+		if (liveSelection.authProfileId) {
+			cronSession.sessionEntry.authProfileOverride = liveSelection.authProfileId;
+			cronSession.sessionEntry.authProfileOverrideSource = liveSelection.authProfileIdSource;
+			if (liveSelection.authProfileIdSource === "auto") cronSession.sessionEntry.authProfileOverrideCompactionCount = cronSession.sessionEntry.compactionCount ?? 0;
+			else delete cronSession.sessionEntry.authProfileOverrideCompactionCount;
+			return;
+		}
+		delete cronSession.sessionEntry.authProfileOverride;
+		delete cronSession.sessionEntry.authProfileOverrideSource;
+		delete cronSession.sessionEntry.authProfileOverrideCompactionCount;
+	};
+	let runResult;
+	let fallbackProvider = liveSelection.provider;
+	let fallbackModel = liveSelection.model;
+	const runStartedAt = Date.now();
+	let runEndedAt = runStartedAt;
+	try {
+		const sessionFile = resolveSessionTranscriptPath(cronSession.sessionEntry.sessionId, agentId);
+		const resolvedVerboseLevel = normalizeVerboseLevel(cronSession.sessionEntry.verboseLevel) ?? normalizeVerboseLevel(agentCfg?.verboseDefault) ?? "off";
+		registerAgentRunContext(cronSession.sessionEntry.sessionId, {
+			sessionKey: agentSessionKey,
+			verboseLevel: resolvedVerboseLevel
+		});
+		const messageChannel = resolvedDelivery.channel;
+		const payloadFallbacks = params.job.payload.kind === "agentTurn" && Array.isArray(params.job.payload.fallbacks) ? params.job.payload.fallbacks : void 0;
+		let bootstrapPromptWarningSignaturesSeen = resolveBootstrapWarningSignaturesSeen(cronSession.sessionEntry.systemPromptReport);
+		const runPrompt = async (promptText) => {
+			const fallbackResult = await runWithModelFallback({
+				cfg: cfgWithAgentDefaults,
+				provider: liveSelection.provider,
+				model: liveSelection.model,
+				runId: cronSession.sessionEntry.sessionId,
+				agentDir,
+				fallbacksOverride: payloadFallbacks ?? resolveAgentModelFallbacksOverride(params.cfg, agentId),
+				run: async (providerOverride, modelOverride, runOptions) => {
+					if (abortSignal?.aborted) throw new Error(abortReason());
+					const bootstrapPromptWarningSignature = bootstrapPromptWarningSignaturesSeen[bootstrapPromptWarningSignaturesSeen.length - 1];
+					if (isCliProvider(providerOverride, cfgWithAgentDefaults)) {
+						const cliSessionId = cronSession.isNewSession ? void 0 : getCliSessionId(cronSession.sessionEntry, providerOverride);
+						const result = await runCliAgent({
+							sessionId: cronSession.sessionEntry.sessionId,
+							sessionKey: agentSessionKey,
+							agentId,
+							sessionFile,
+							workspaceDir,
+							config: cfgWithAgentDefaults,
+							prompt: promptText,
+							provider: providerOverride,
+							model: modelOverride,
+							thinkLevel,
+							timeoutMs,
+							runId: cronSession.sessionEntry.sessionId,
+							cliSessionId,
+							bootstrapPromptWarningSignaturesSeen,
+							bootstrapPromptWarningSignature
+						});
+						bootstrapPromptWarningSignaturesSeen = resolveBootstrapWarningSignaturesSeen(result.meta?.systemPromptReport);
+						return result;
+					}
+					const result = await runEmbeddedPiAgent({
+						sessionId: cronSession.sessionEntry.sessionId,
+						sessionKey: agentSessionKey,
+						agentId,
+						trigger: "cron",
+						allowGatewaySubagentBinding: true,
+						senderIsOwner: true,
+						messageChannel,
+						agentAccountId: resolvedDelivery.accountId,
+						sessionFile,
+						agentDir,
+						workspaceDir,
+						config: cfgWithAgentDefaults,
+						skillsSnapshot,
+						prompt: promptText,
+						lane: resolveNestedAgentLane(params.lane),
+						provider: providerOverride,
+						model: modelOverride,
+						authProfileId: liveSelection.authProfileId,
+						authProfileIdSource: liveSelection.authProfileId ? liveSelection.authProfileIdSource : void 0,
+						thinkLevel,
+						fastMode: resolveFastModeState({
+							cfg: cfgWithAgentDefaults,
+							provider: providerOverride,
+							model: modelOverride,
+							agentId,
+							sessionEntry: cronSession.sessionEntry
+						}).enabled,
+						verboseLevel: resolvedVerboseLevel,
+						timeoutMs,
+						bootstrapContextMode: agentPayload?.lightContext ? "lightweight" : void 0,
+						bootstrapContextRunKind: "cron",
+						toolsAllow: agentPayload?.toolsAllow,
+						runId: cronSession.sessionEntry.sessionId,
+						requireExplicitMessageTarget: toolPolicy.requireExplicitMessageTarget,
+						disableMessageTool: toolPolicy.disableMessageTool,
+						allowTransientCooldownProbe: runOptions?.allowTransientCooldownProbe,
+						abortSignal,
+						bootstrapPromptWarningSignaturesSeen,
+						bootstrapPromptWarningSignature
+					});
+					bootstrapPromptWarningSignaturesSeen = resolveBootstrapWarningSignaturesSeen(result.meta?.systemPromptReport);
+					return result;
+				}
+			});
+			runResult = fallbackResult.result;
+			fallbackProvider = fallbackResult.provider;
+			fallbackModel = fallbackResult.model;
+			liveSelection.provider = fallbackResult.provider;
+			liveSelection.model = fallbackResult.model;
+			runEndedAt = Date.now();
+		};
+		const MAX_MODEL_SWITCH_RETRIES = 2;
+		let modelSwitchRetries = 0;
+		while (true) try {
+			await runPrompt(commandBody);
+			break;
+		} catch (err) {
+			if (err instanceof LiveSessionModelSwitchError) {
+				modelSwitchRetries += 1;
+				if (modelSwitchRetries > MAX_MODEL_SWITCH_RETRIES) {
+					logWarn(`[cron:${params.job.id}] LiveSessionModelSwitchError retry limit reached (${MAX_MODEL_SWITCH_RETRIES}); aborting`);
+					throw err;
+				}
+				liveSelection = {
+					provider: err.provider,
+					model: err.model,
+					authProfileId: err.authProfileId,
+					authProfileIdSource: err.authProfileId ? err.authProfileIdSource : void 0
+				};
+				fallbackProvider = err.provider;
+				fallbackModel = err.model;
+				syncSessionEntryLiveSelection();
+				try {
+					await persistSessionEntry();
+				} catch (persistErr) {
+					logWarn(`[cron:${params.job.id}] Failed to persist model switch session entry: ${String(persistErr)}`);
+				}
+				continue;
+			}
+			throw err;
+		}
+		if (!runResult) throw new Error("cron isolated run returned no result");
+		if (!isAborted()) {
+			const interimRunResult = runResult;
+			const interimPayloads = interimRunResult.payloads ?? [];
+			const { deliveryPayloadHasStructuredContent: interimPayloadHasStructuredContent, outputText: interimOutputText } = resolveCronPayloadOutcome({
+				payloads: interimPayloads,
+				runLevelError: interimRunResult.meta?.error
+			});
+			const interimText = interimOutputText?.trim() ?? "";
+			const hasDescendantsSinceRunStart = listDescendantRunsForRequester(agentSessionKey).some((entry) => {
+				const descendantStartedAt = typeof entry.startedAt === "number" ? entry.startedAt : entry.createdAt;
+				return typeof descendantStartedAt === "number" && descendantStartedAt >= runStartedAt;
+			});
+			if (!interimRunResult.meta?.error && !interimRunResult.didSendViaMessagingTool && !interimPayloadHasStructuredContent && !interimPayloads.some((payload) => payload?.isError === true) && countActiveDescendantRuns(agentSessionKey) === 0 && !hasDescendantsSinceRunStart && isLikelyInterimCronMessage(interimText)) await runPrompt([
+				"Your previous response was only an acknowledgement and did not complete this cron task.",
+				"Complete the original task now.",
+				"Do not send a status update like 'on it'.",
+				"Use tools when needed, including sessions_spawn for parallel subtasks, wait for spawned subagents to finish, then return only the final summary."
+			].join(" "));
+		}
+	} catch (err) {
+		return withRunSession({
+			status: "error",
+			error: String(err)
+		});
+	}
+	if (isAborted()) return withRunSession({
+		status: "error",
+		error: abortReason()
+	});
+	if (!runResult) return withRunSession({
+		status: "error",
+		error: "cron isolated run returned no result"
+	});
+	const finalRunResult = runResult;
+	const payloads = finalRunResult.payloads ?? [];
+	let telemetry;
+	{
+		if (finalRunResult.meta?.systemPromptReport) cronSession.sessionEntry.systemPromptReport = finalRunResult.meta.systemPromptReport;
+		const usage = finalRunResult.meta?.agentMeta?.usage;
+		const promptTokens = finalRunResult.meta?.agentMeta?.promptTokens;
+		const modelUsed = finalRunResult.meta?.agentMeta?.model ?? fallbackModel ?? liveSelection.model;
+		const providerUsed = finalRunResult.meta?.agentMeta?.provider ?? fallbackProvider ?? liveSelection.provider;
+		const contextTokens = agentCfg?.contextTokens ?? lookupContextTokens(modelUsed, { allowAsyncLoad: false }) ?? 2e5;
+		setSessionRuntimeModel(cronSession.sessionEntry, {
+			provider: providerUsed,
+			model: modelUsed
+		});
+		cronSession.sessionEntry.contextTokens = contextTokens;
+		if (isCliProvider(providerUsed, cfgWithAgentDefaults)) {
+			const cliSessionId = finalRunResult.meta?.agentMeta?.sessionId?.trim();
+			if (cliSessionId) setCliSessionId(cronSession.sessionEntry, providerUsed, cliSessionId);
+		}
+		if (hasNonzeroUsage(usage)) {
+			const input = usage.input ?? 0;
+			const output = usage.output ?? 0;
+			const totalTokens = deriveSessionTotalTokens({
+				usage,
+				contextTokens,
+				promptTokens
+			});
+			const runEstimatedCostUsd = resolveNonNegativeNumber(estimateUsageCost({
+				usage,
+				cost: resolveModelCostConfig({
+					provider: providerUsed,
+					model: modelUsed,
+					config: cfgWithAgentDefaults
+				})
+			}));
+			cronSession.sessionEntry.inputTokens = input;
+			cronSession.sessionEntry.outputTokens = output;
+			const telemetryUsage = {
+				input_tokens: input,
+				output_tokens: output
+			};
+			if (typeof totalTokens === "number" && Number.isFinite(totalTokens) && totalTokens > 0) {
+				cronSession.sessionEntry.totalTokens = totalTokens;
+				cronSession.sessionEntry.totalTokensFresh = true;
+				telemetryUsage.total_tokens = totalTokens;
+			} else {
+				cronSession.sessionEntry.totalTokens = void 0;
+				cronSession.sessionEntry.totalTokensFresh = false;
+			}
+			cronSession.sessionEntry.cacheRead = usage.cacheRead ?? 0;
+			cronSession.sessionEntry.cacheWrite = usage.cacheWrite ?? 0;
+			if (runEstimatedCostUsd !== void 0) cronSession.sessionEntry.estimatedCostUsd = (resolveNonNegativeNumber(cronSession.sessionEntry.estimatedCostUsd) ?? 0) + runEstimatedCostUsd;
+			telemetry = {
+				model: modelUsed,
+				provider: providerUsed,
+				usage: telemetryUsage
+			};
+		} else telemetry = {
+			model: modelUsed,
+			provider: providerUsed
+		};
+		await persistSessionEntry();
+	}
+	if (isAborted()) return withRunSession({
+		status: "error",
+		error: abortReason(),
+		...telemetry
+	});
+	let { summary, outputText, synthesizedText, deliveryPayloads, deliveryPayloadHasStructuredContent, hasFatalErrorPayload, embeddedRunError } = resolveCronPayloadOutcome({
+		payloads,
+		runLevelError: finalRunResult.meta?.error
+	});
+	const deliveryBestEffort = resolveCronDeliveryBestEffort(params.job);
+	const resolveRunOutcome = (params) => withRunSession({
+		status: hasFatalErrorPayload ? "error" : "ok",
+		...hasFatalErrorPayload ? { error: embeddedRunError ?? "cron isolated run returned an error payload" } : {},
+		summary,
+		outputText,
+		delivered: params?.delivered,
+		deliveryAttempted: params?.deliveryAttempted,
+		...telemetry
+	});
+	const ackMaxChars = resolveHeartbeatAckMaxChars(agentCfg);
+	const skipHeartbeatDelivery = deliveryRequested && isHeartbeatOnlyResponse(payloads, ackMaxChars);
+	const skipMessagingToolDelivery = deliveryContract === "shared" && deliveryRequested && finalRunResult.didSendViaMessagingTool === true && (finalRunResult.messagingToolSentTargets ?? []).some((target) => matchesMessagingToolDeliveryTarget(target, {
+		channel: resolvedDelivery.channel,
+		to: resolvedDelivery.to,
+		accountId: resolvedDelivery.accountId
+	}));
+	const deliveryResult = await dispatchCronDelivery({
+		cfg: params.cfg,
+		cfgWithAgentDefaults,
+		deps: params.deps,
+		job: params.job,
+		agentId,
+		agentSessionKey,
+		runSessionId,
+		runStartedAt,
+		runEndedAt,
+		timeoutMs,
+		resolvedDelivery,
+		deliveryRequested,
+		skipHeartbeatDelivery,
+		skipMessagingToolDelivery,
+		deliveryBestEffort,
+		deliveryPayloadHasStructuredContent,
+		deliveryPayloads,
+		synthesizedText,
+		summary,
+		outputText,
+		telemetry,
+		abortSignal,
+		isAborted,
+		abortReason,
+		withRunSession
+	});
+	if (deliveryResult.result) {
+		const resultWithDeliveryMeta = {
+			...deliveryResult.result,
+			deliveryAttempted: deliveryResult.result.deliveryAttempted ?? deliveryResult.deliveryAttempted
+		};
+		if (!hasFatalErrorPayload || deliveryResult.result.status !== "ok") return resultWithDeliveryMeta;
+		return resolveRunOutcome({
+			delivered: deliveryResult.result.delivered,
+			deliveryAttempted: resultWithDeliveryMeta.deliveryAttempted
+		});
+	}
+	const delivered = deliveryResult.delivered;
+	const deliveryAttempted = deliveryResult.deliveryAttempted;
+	summary = deliveryResult.summary;
+	outputText = deliveryResult.outputText;
+	return resolveRunOutcome({
+		delivered,
+		deliveryAttempted
+	});
+}
+//#endregion
+//#region src/cron/service/initial-delivery.ts
+function resolveInitialCronDelivery(input) {
+	if (input.delivery) return input.delivery;
+	if (input.sessionTarget === "isolated" && input.payload.kind === "agentTurn") return { mode: "announce" };
+}
+//#endregion
+//#region src/cron/service/jobs.ts
+const STUCK_RUN_MS = 7200 * 1e3;
+const STAGGER_OFFSET_CACHE_MAX = 4096;
+const staggerOffsetCache = /* @__PURE__ */ new Map();
+function isFiniteTimestamp(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function resolveStableCronOffsetMs(jobId, staggerMs) {
+	if (staggerMs <= 1) return 0;
+	const cacheKey = `${staggerMs}:${jobId}`;
+	const cached = staggerOffsetCache.get(cacheKey);
+	if (cached !== void 0) return cached;
+	const offset = crypto.createHash("sha256").update(jobId).digest().readUInt32BE(0) % staggerMs;
+	if (staggerOffsetCache.size >= STAGGER_OFFSET_CACHE_MAX) {
+		const first = staggerOffsetCache.keys().next();
+		if (!first.done) staggerOffsetCache.delete(first.value);
+	}
+	staggerOffsetCache.set(cacheKey, offset);
+	return offset;
+}
+function computeStaggeredCronNextRunAtMs(job, nowMs) {
+	if (job.schedule.kind !== "cron") return computeNextRunAtMs(job.schedule, nowMs);
+	const staggerMs = resolveCronStaggerMs(job.schedule);
+	const offsetMs = resolveStableCronOffsetMs(job.id, staggerMs);
+	if (offsetMs <= 0) return computeNextRunAtMs(job.schedule, nowMs);
+	let cursorMs = Math.max(0, nowMs - offsetMs);
+	for (let attempt = 0; attempt < 4; attempt += 1) {
+		const baseNext = computeNextRunAtMs(job.schedule, cursorMs);
+		if (baseNext === void 0) return;
+		const shifted = baseNext + offsetMs;
+		if (shifted > nowMs) return shifted;
+		cursorMs = Math.max(cursorMs + 1, baseNext + 1e3);
+	}
+}
+function computeStaggeredCronPreviousRunAtMs(job, nowMs) {
+	if (job.schedule.kind !== "cron") return;
+	const staggerMs = resolveCronStaggerMs(job.schedule);
+	const offsetMs = resolveStableCronOffsetMs(job.id, staggerMs);
+	if (offsetMs <= 0) return computePreviousRunAtMs(job.schedule, nowMs);
+	let cursorMs = Math.max(0, nowMs - offsetMs);
+	for (let attempt = 0; attempt < 4; attempt += 1) {
+		const basePrevious = computePreviousRunAtMs(job.schedule, cursorMs);
+		if (basePrevious === void 0) return;
+		const shifted = basePrevious + offsetMs;
+		if (shifted <= nowMs) return shifted;
+		cursorMs = Math.max(0, basePrevious - 1e3);
+	}
+}
+function resolveEveryAnchorMs(params) {
+	const coerced = coerceFiniteScheduleNumber(params.schedule.anchorMs);
+	if (coerced !== void 0) return Math.max(0, Math.floor(coerced));
+	if (isFiniteTimestamp(params.fallbackAnchorMs)) return Math.max(0, Math.floor(params.fallbackAnchorMs));
+	return 0;
+}
+function assertSupportedJobSpec(job) {
+	const isIsolatedLike = job.sessionTarget === "isolated" || job.sessionTarget === "current" || job.sessionTarget.startsWith("session:");
+	if (job.sessionTarget === "main" && job.payload.kind !== "systemEvent") throw new Error("main cron jobs require payload.kind=\"systemEvent\"");
+	if (isIsolatedLike && job.payload.kind !== "agentTurn") throw new Error("isolated/current/session cron jobs require payload.kind=\"agentTurn\"");
+}
+function assertMainSessionAgentId(job, defaultAgentId) {
+	if (job.sessionTarget !== "main") return;
+	if (!job.agentId) return;
+	if (normalizeAgentId(job.agentId) !== normalizeAgentId(defaultAgentId)) throw new Error(`cron: sessionTarget "main" is only valid for the default agent. Use sessionTarget "isolated" with payload.kind "agentTurn" for non-default agents (agentId: ${job.agentId})`);
+}
+const TELEGRAM_TME_URL_REGEX = /^https?:\/\/t\.me\/|t\.me\//i;
+const TELEGRAM_SLASH_TOPIC_REGEX = /^-?\d+\/\d+$/;
+function validateTelegramDeliveryTarget(to) {
+	if (!to) return;
+	const trimmed = to.trim();
+	if (TELEGRAM_TME_URL_REGEX.test(trimmed)) return;
+	if (TELEGRAM_SLASH_TOPIC_REGEX.test(trimmed)) return `Invalid Telegram delivery target "${to}". Use colon (:) as delimiter for topics, not slash. Valid formats: -1001234567890, -1001234567890:123, -1001234567890:topic:123, @username, https://t.me/username`;
+}
+function assertDeliverySupport(job) {
+	if (!job.delivery || job.delivery.mode === "none") return;
+	if (job.delivery.mode === "webhook") {
+		const target = normalizeHttpWebhookUrl(job.delivery.to);
+		if (!target) throw new Error("cron webhook delivery requires delivery.to to be a valid http(s) URL");
+		job.delivery.to = target;
+		return;
+	}
+	if (!(job.sessionTarget === "isolated" || job.sessionTarget === "current" || job.sessionTarget.startsWith("session:"))) throw new Error("cron channel delivery config is only supported for sessionTarget=\"isolated\"");
+	if (job.delivery.channel === "telegram") {
+		const telegramError = validateTelegramDeliveryTarget(job.delivery.to);
+		if (telegramError) throw new Error(telegramError);
+	}
+}
+function assertFailureDestinationSupport(job) {
+	const failureDestination = job.delivery?.failureDestination;
+	if (!failureDestination) return;
+	if (job.sessionTarget === "main" && job.delivery?.mode !== "webhook") throw new Error("cron delivery.failureDestination is only supported for sessionTarget=\"isolated\" unless delivery.mode=\"webhook\"");
+	if (failureDestination.mode === "webhook") {
+		const target = normalizeHttpWebhookUrl(failureDestination.to);
+		if (!target) throw new Error("cron failure destination webhook requires delivery.failureDestination.to to be a valid http(s) URL");
+		failureDestination.to = target;
+	}
+}
+function findJobOrThrow(state, id) {
+	const job = state.store?.jobs.find((j) => j.id === id);
+	if (!job) throw new Error(`unknown cron job id: ${id}`);
+	return job;
+}
+function isJobEnabled(job) {
+	return job.enabled ?? true;
+}
+function computeJobNextRunAtMs(job, nowMs) {
+	if (!isJobEnabled(job)) return;
+	if (job.schedule.kind === "every") {
+		const everyMsRaw = coerceFiniteScheduleNumber(job.schedule.everyMs);
+		if (everyMsRaw === void 0) return;
+		const everyMs = Math.max(1, Math.floor(everyMsRaw));
+		const lastRunAtMs = job.state.lastRunAtMs;
+		if (typeof lastRunAtMs === "number" && Number.isFinite(lastRunAtMs)) {
+			const nextFromLastRun = Math.floor(lastRunAtMs) + everyMs;
+			if (nextFromLastRun > nowMs) return nextFromLastRun;
+		}
+		const fallbackAnchorMs = isFiniteTimestamp(job.createdAtMs) ? job.createdAtMs : nowMs;
+		const anchorMs = resolveEveryAnchorMs({
+			schedule: job.schedule,
+			fallbackAnchorMs
+		});
+		const next = computeNextRunAtMs({
+			...job.schedule,
+			everyMs,
+			anchorMs
+		}, nowMs);
+		return isFiniteTimestamp(next) ? next : void 0;
+	}
+	if (job.schedule.kind === "at") {
+		const schedule = job.schedule;
+		const atMs = typeof schedule.atMs === "number" && Number.isFinite(schedule.atMs) && schedule.atMs > 0 ? schedule.atMs : typeof schedule.atMs === "string" ? parseAbsoluteTimeMs(schedule.atMs) : typeof schedule.at === "string" ? parseAbsoluteTimeMs(schedule.at) : null;
+		if (job.state.lastStatus === "ok" && job.state.lastRunAtMs) {
+			if (atMs !== null && Number.isFinite(atMs) && atMs > job.state.lastRunAtMs) return atMs;
+			return;
+		}
+		return atMs !== null && Number.isFinite(atMs) ? atMs : void 0;
+	}
+	const next = computeStaggeredCronNextRunAtMs(job, nowMs);
+	if (next === void 0 && job.schedule.kind === "cron") return computeStaggeredCronNextRunAtMs(job, Math.floor(nowMs / 1e3) * 1e3 + 1e3);
+	return isFiniteTimestamp(next) ? next : void 0;
+}
+function computeJobPreviousRunAtMs(job, nowMs) {
+	if (!isJobEnabled(job) || job.schedule.kind !== "cron") return;
+	const previous = computeStaggeredCronPreviousRunAtMs(job, nowMs);
+	return isFiniteTimestamp(previous) ? previous : void 0;
+}
+/** Maximum consecutive schedule errors before auto-disabling a job. */
+const MAX_SCHEDULE_ERRORS = 3;
+function recordScheduleComputeError(params) {
+	const { state, job, err } = params;
+	const errorCount = (job.state.scheduleErrorCount ?? 0) + 1;
+	const errText = String(err);
+	job.state.scheduleErrorCount = errorCount;
+	job.state.nextRunAtMs = void 0;
+	job.state.lastError = `schedule error: ${errText}`;
+	if (errorCount >= MAX_SCHEDULE_ERRORS) {
+		job.enabled = false;
+		state.deps.log.error({
+			jobId: job.id,
+			name: job.name,
+			errorCount,
+			err: errText
+		}, "cron: auto-disabled job after repeated schedule errors");
+		const notifyText = `⚠️ Cron job "${job.name}" has been auto-disabled after ${errorCount} consecutive schedule errors. Last error: ${errText}`;
+		state.deps.enqueueSystemEvent(notifyText, {
+			agentId: job.agentId,
+			sessionKey: job.sessionKey,
+			contextKey: `cron:${job.id}:auto-disabled`
+		});
+		state.deps.requestHeartbeatNow({
+			reason: `cron:${job.id}:auto-disabled`,
+			agentId: job.agentId,
+			sessionKey: job.sessionKey
+		});
+	} else state.deps.log.warn({
+		jobId: job.id,
+		name: job.name,
+		errorCount,
+		err: errText
+	}, "cron: failed to compute next run for job (skipping)");
+	return true;
+}
+function normalizeJobTickState(params) {
+	const { state, job, nowMs } = params;
+	let changed = false;
+	if (!job.state) {
+		job.state = {};
+		changed = true;
+	}
+	if (job.schedule.kind === "every") {
+		const normalizedAnchorMs = resolveEveryAnchorMs({
+			schedule: job.schedule,
+			fallbackAnchorMs: isFiniteTimestamp(job.createdAtMs) ? job.createdAtMs : nowMs
+		});
+		if (job.schedule.anchorMs !== normalizedAnchorMs) {
+			job.schedule = {
+				...job.schedule,
+				anchorMs: normalizedAnchorMs
+			};
+			changed = true;
+		}
+	}
+	if (!isJobEnabled(job)) {
+		if (job.state.nextRunAtMs !== void 0) {
+			job.state.nextRunAtMs = void 0;
+			changed = true;
+		}
+		if (job.state.runningAtMs !== void 0) {
+			job.state.runningAtMs = void 0;
+			changed = true;
+		}
+		return {
+			changed,
+			skip: true
+		};
+	}
+	if (!isFiniteTimestamp(job.state.nextRunAtMs) && job.state.nextRunAtMs !== void 0) {
+		job.state.nextRunAtMs = void 0;
+		changed = true;
+	}
+	const runningAt = job.state.runningAtMs;
+	if (typeof runningAt === "number" && nowMs - runningAt > STUCK_RUN_MS) {
+		state.deps.log.warn({
+			jobId: job.id,
+			runningAtMs: runningAt
+		}, "cron: clearing stuck running marker");
+		job.state.runningAtMs = void 0;
+		changed = true;
+	}
+	return {
+		changed,
+		skip: false
+	};
+}
+function walkSchedulableJobs(state, fn, nowMs = state.deps.nowMs()) {
+	if (!state.store) return false;
+	let changed = false;
+	for (const job of state.store.jobs) {
+		const tick = normalizeJobTickState({
+			state,
+			job,
+			nowMs
+		});
+		if (tick.changed) changed = true;
+		if (tick.skip) continue;
+		if (fn({
+			job,
+			nowMs
+		})) changed = true;
+	}
+	return changed;
+}
+function recomputeJobNextRunAtMs(params) {
+	let changed = false;
+	try {
+		const newNext = computeJobNextRunAtMs(params.job, params.nowMs);
+		if (params.job.state.nextRunAtMs !== newNext) {
+			params.job.state.nextRunAtMs = newNext;
+			changed = true;
+		}
+		if (params.job.state.scheduleErrorCount) {
+			params.job.state.scheduleErrorCount = void 0;
+			changed = true;
+		}
+	} catch (err) {
+		if (recordScheduleComputeError({
+			state: params.state,
+			job: params.job,
+			err
+		})) changed = true;
+	}
+	return changed;
+}
+function recomputeNextRuns(state) {
+	return walkSchedulableJobs(state, ({ job, nowMs: now }) => {
+		let changed = false;
+		const nextRun = job.state.nextRunAtMs;
+		if (!isFiniteTimestamp(nextRun) || now >= nextRun) {
+			if (recomputeJobNextRunAtMs({
+				state,
+				job,
+				nowMs: now
+			})) changed = true;
+		}
+		return changed;
+	});
+}
+/**
+* Maintenance-only version of recomputeNextRuns that handles disabled jobs
+* and stuck markers, but does NOT recompute nextRunAtMs for enabled jobs
+* with existing values. Used during timer ticks when no due jobs were found
+* to prevent silently advancing past-due nextRunAtMs values without execution
+* (see #13992).
+*/
+function recomputeNextRunsForMaintenance(state, opts) {
+	const recomputeExpired = opts?.recomputeExpired ?? false;
+	return walkSchedulableJobs(state, ({ job, nowMs: now }) => {
+		let changed = false;
+		if (!isFiniteTimestamp(job.state.nextRunAtMs)) {
+			if (recomputeJobNextRunAtMs({
+				state,
+				job,
+				nowMs: now
+			})) changed = true;
+		} else if (recomputeExpired && now >= job.state.nextRunAtMs && typeof job.state.runningAtMs !== "number") {
+			const lastRun = job.state.lastRunAtMs;
+			if (isFiniteTimestamp(lastRun) && lastRun >= job.state.nextRunAtMs) {
+				if (recomputeJobNextRunAtMs({
+					state,
+					job,
+					nowMs: now
+				})) changed = true;
+			}
+		}
+		return changed;
+	}, opts?.nowMs);
+}
+function nextWakeAtMs(state) {
+	const enabled = (state.store?.jobs ?? []).filter((j) => j.enabled && isFiniteTimestamp(j.state.nextRunAtMs));
+	if (enabled.length === 0) return;
+	const first = enabled[0]?.state.nextRunAtMs;
+	if (!isFiniteTimestamp(first)) return;
+	return enabled.reduce((min, j) => {
+		const next = j.state.nextRunAtMs;
+		return isFiniteTimestamp(next) ? Math.min(min, next) : min;
+	}, first);
+}
+function createJob(state, input) {
+	const now = state.deps.nowMs();
+	const id = crypto.randomUUID();
+	const schedule = input.schedule.kind === "every" ? {
+		...input.schedule,
+		anchorMs: resolveEveryAnchorMs({
+			schedule: input.schedule,
+			fallbackAnchorMs: now
+		})
+	} : input.schedule.kind === "cron" ? (() => {
+		const explicitStaggerMs = normalizeCronStaggerMs(input.schedule.staggerMs);
+		if (explicitStaggerMs !== void 0) return {
+			...input.schedule,
+			staggerMs: explicitStaggerMs
+		};
+		const defaultStaggerMs = resolveDefaultCronStaggerMs(input.schedule.expr);
+		return defaultStaggerMs !== void 0 ? {
+			...input.schedule,
+			staggerMs: defaultStaggerMs
+		} : input.schedule;
+	})() : input.schedule;
+	const deleteAfterRun = typeof input.deleteAfterRun === "boolean" ? input.deleteAfterRun : schedule.kind === "at" ? true : void 0;
+	const enabled = typeof input.enabled === "boolean" ? input.enabled : true;
+	const job = {
+		id,
+		agentId: normalizeOptionalAgentId(input.agentId),
+		sessionKey: normalizeOptionalSessionKey(input.sessionKey),
+		name: normalizeRequiredName(input.name),
+		description: normalizeOptionalText(input.description),
+		enabled,
+		deleteAfterRun,
+		createdAtMs: now,
+		updatedAtMs: now,
+		schedule,
+		sessionTarget: input.sessionTarget,
+		wakeMode: input.wakeMode,
+		payload: input.payload,
+		delivery: resolveInitialCronDelivery(input),
+		failureAlert: input.failureAlert,
+		state: { ...input.state }
+	};
+	assertSupportedJobSpec(job);
+	assertMainSessionAgentId(job, state.deps.defaultAgentId);
+	assertDeliverySupport(job);
+	assertFailureDestinationSupport(job);
+	job.state.nextRunAtMs = computeJobNextRunAtMs(job, now);
+	return job;
+}
+function applyJobPatch(job, patch, opts) {
+	if ("name" in patch) job.name = normalizeRequiredName(patch.name);
+	if ("description" in patch) job.description = normalizeOptionalText(patch.description);
+	if (typeof patch.enabled === "boolean") job.enabled = patch.enabled;
+	if (typeof patch.deleteAfterRun === "boolean") job.deleteAfterRun = patch.deleteAfterRun;
+	if (patch.schedule) if (patch.schedule.kind === "cron") {
+		const explicitStaggerMs = normalizeCronStaggerMs(patch.schedule.staggerMs);
+		if (explicitStaggerMs !== void 0) job.schedule = {
+			...patch.schedule,
+			staggerMs: explicitStaggerMs
+		};
+		else if (job.schedule.kind === "cron") job.schedule = {
+			...patch.schedule,
+			staggerMs: job.schedule.staggerMs
+		};
+		else {
+			const defaultStaggerMs = resolveDefaultCronStaggerMs(patch.schedule.expr);
+			job.schedule = defaultStaggerMs !== void 0 ? {
+				...patch.schedule,
+				staggerMs: defaultStaggerMs
+			} : patch.schedule;
+		}
+	} else job.schedule = patch.schedule;
+	if (patch.sessionTarget) job.sessionTarget = patch.sessionTarget;
+	if (patch.wakeMode) job.wakeMode = patch.wakeMode;
+	if (patch.payload) job.payload = mergeCronPayload(job.payload, patch.payload);
+	if (patch.delivery) job.delivery = mergeCronDelivery(job.delivery, patch.delivery);
+	if ("failureAlert" in patch) job.failureAlert = mergeCronFailureAlert(job.failureAlert, patch.failureAlert);
+	if (job.sessionTarget === "main" && job.delivery?.mode !== "webhook" && job.delivery?.failureDestination) throw new Error("cron delivery.failureDestination is only supported for sessionTarget=\"isolated\" unless delivery.mode=\"webhook\"");
+	if (job.sessionTarget === "main" && job.delivery?.mode !== "webhook") job.delivery = void 0;
+	if (patch.state) job.state = {
+		...job.state,
+		...patch.state
+	};
+	if ("agentId" in patch) job.agentId = normalizeOptionalAgentId(patch.agentId);
+	if ("sessionKey" in patch) job.sessionKey = normalizeOptionalSessionKey(patch.sessionKey);
+	assertSupportedJobSpec(job);
+	assertMainSessionAgentId(job, opts?.defaultAgentId);
+	assertDeliverySupport(job);
+	assertFailureDestinationSupport(job);
+}
+function mergeCronPayload(existing, patch) {
+	if (patch.kind !== existing.kind) return buildPayloadFromPatch(patch);
+	if (patch.kind === "systemEvent") {
+		if (existing.kind !== "systemEvent") return buildPayloadFromPatch(patch);
+		return {
+			kind: "systemEvent",
+			text: typeof patch.text === "string" ? patch.text : existing.text
+		};
+	}
+	if (existing.kind !== "agentTurn") return buildPayloadFromPatch(patch);
+	const next = { ...existing };
+	if (typeof patch.message === "string") next.message = patch.message;
+	if (typeof patch.model === "string") next.model = patch.model;
+	if (Array.isArray(patch.fallbacks)) next.fallbacks = patch.fallbacks;
+	if (Array.isArray(patch.toolsAllow)) next.toolsAllow = patch.toolsAllow;
+	else if (patch.toolsAllow === null) delete next.toolsAllow;
+	if (typeof patch.thinking === "string") next.thinking = patch.thinking;
+	if (typeof patch.timeoutSeconds === "number") next.timeoutSeconds = patch.timeoutSeconds;
+	if (typeof patch.lightContext === "boolean") next.lightContext = patch.lightContext;
+	if (typeof patch.allowUnsafeExternalContent === "boolean") next.allowUnsafeExternalContent = patch.allowUnsafeExternalContent;
+	return next;
+}
+function buildPayloadFromPatch(patch) {
+	if (patch.kind === "systemEvent") {
+		if (typeof patch.text !== "string" || patch.text.length === 0) throw new Error("cron.update payload.kind=\"systemEvent\" requires text");
+		return {
+			kind: "systemEvent",
+			text: patch.text
+		};
+	}
+	if (typeof patch.message !== "string" || patch.message.length === 0) throw new Error("cron.update payload.kind=\"agentTurn\" requires message");
+	return {
+		kind: "agentTurn",
+		message: patch.message,
+		model: patch.model,
+		fallbacks: patch.fallbacks,
+		toolsAllow: Array.isArray(patch.toolsAllow) ? patch.toolsAllow : void 0,
+		thinking: patch.thinking,
+		timeoutSeconds: patch.timeoutSeconds,
+		lightContext: patch.lightContext,
+		allowUnsafeExternalContent: patch.allowUnsafeExternalContent
+	};
+}
+function normalizeOptionalTrimmedString(value) {
+	const trimmed = typeof value === "string" ? value.trim() : "";
+	return trimmed ? trimmed : void 0;
+}
+function normalizeOptionalThreadId(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	return normalizeOptionalTrimmedString(value);
+}
+function mergeCronDelivery(existing, patch) {
+	const next = {
+		mode: existing?.mode ?? "none",
+		channel: existing?.channel,
+		to: existing?.to,
+		threadId: existing?.threadId,
+		accountId: existing?.accountId,
+		bestEffort: existing?.bestEffort,
+		failureDestination: existing?.failureDestination
+	};
+	if (typeof patch.mode === "string") next.mode = patch.mode === "deliver" ? "announce" : patch.mode;
+	if ("channel" in patch) next.channel = normalizeOptionalTrimmedString(patch.channel);
+	if ("to" in patch) next.to = normalizeOptionalTrimmedString(patch.to);
+	if ("threadId" in patch) next.threadId = normalizeOptionalThreadId(patch.threadId);
+	if ("accountId" in patch) next.accountId = normalizeOptionalTrimmedString(patch.accountId);
+	if (typeof patch.bestEffort === "boolean") next.bestEffort = patch.bestEffort;
+	if ("failureDestination" in patch) if (patch.failureDestination === void 0) next.failureDestination = void 0;
+	else {
+		const existingFd = next.failureDestination;
+		const patchFd = patch.failureDestination;
+		const nextFd = {
+			channel: existingFd?.channel,
+			to: existingFd?.to,
+			accountId: existingFd?.accountId,
+			mode: existingFd?.mode
+		};
+		if (patchFd) {
+			if ("channel" in patchFd) {
+				const channel = typeof patchFd.channel === "string" ? patchFd.channel.trim() : "";
+				nextFd.channel = channel ? channel : void 0;
+			}
+			if ("to" in patchFd) {
+				const to = typeof patchFd.to === "string" ? patchFd.to.trim() : "";
+				nextFd.to = to ? to : void 0;
+			}
+			if ("accountId" in patchFd) {
+				const accountId = typeof patchFd.accountId === "string" ? patchFd.accountId.trim() : "";
+				nextFd.accountId = accountId ? accountId : void 0;
+			}
+			if ("mode" in patchFd) {
+				const mode = typeof patchFd.mode === "string" ? patchFd.mode.trim() : "";
+				nextFd.mode = mode === "announce" || mode === "webhook" ? mode : void 0;
+			}
+		}
+		next.failureDestination = nextFd;
+	}
+	return next;
+}
+function mergeCronFailureAlert(existing, patch) {
+	if (patch === false) return false;
+	if (patch === void 0) return existing;
+	const next = { ...existing === false || existing === void 0 ? {} : existing };
+	if ("after" in patch) {
+		const after = typeof patch.after === "number" && Number.isFinite(patch.after) ? patch.after : 0;
+		next.after = after > 0 ? Math.floor(after) : void 0;
+	}
+	if ("channel" in patch) next.channel = normalizeOptionalTrimmedString(patch.channel);
+	if ("to" in patch) next.to = normalizeOptionalTrimmedString(patch.to);
+	if ("cooldownMs" in patch) {
+		const cooldownMs = typeof patch.cooldownMs === "number" && Number.isFinite(patch.cooldownMs) ? patch.cooldownMs : -1;
+		next.cooldownMs = cooldownMs >= 0 ? Math.floor(cooldownMs) : void 0;
+	}
+	if ("mode" in patch) {
+		const mode = typeof patch.mode === "string" ? patch.mode.trim() : "";
+		next.mode = mode === "announce" || mode === "webhook" ? mode : void 0;
+	}
+	if ("accountId" in patch) {
+		const accountId = typeof patch.accountId === "string" ? patch.accountId.trim() : "";
+		next.accountId = accountId ? accountId : void 0;
+	}
+	return next;
+}
+function isJobDue(job, nowMs, opts) {
+	if (!job.state) job.state = {};
+	if (typeof job.state.runningAtMs === "number") return false;
+	if (opts.forced) return true;
+	return isJobEnabled(job) && typeof job.state.nextRunAtMs === "number" && nowMs >= job.state.nextRunAtMs;
+}
+function resolveJobPayloadTextForMain(job) {
+	if (job.payload.kind !== "systemEvent") return;
+	const text = normalizePayloadToSystemText(job.payload);
+	return text.trim() ? text : void 0;
+}
+//#endregion
+//#region src/cron/service/locked.ts
+const storeLocks = /* @__PURE__ */ new Map();
+const resolveChain = (promise) => promise.then(() => void 0, () => void 0);
+async function locked(state, fn) {
+	const storePath = state.deps.storePath;
+	const storeOp = storeLocks.get(storePath) ?? Promise.resolve();
+	const next = Promise.all([resolveChain(state.op), resolveChain(storeOp)]).then(fn);
+	const keepAlive = resolveChain(next);
+	state.op = keepAlive;
+	storeLocks.set(storePath, keepAlive);
+	return await next;
+}
+//#endregion
+//#region src/cron/service/store.ts
+async function getFileMtimeMs(path) {
+	try {
+		return (await fsSync.promises.stat(path)).mtimeMs;
+	} catch {
+		return null;
+	}
+}
+async function ensureLoaded(state, opts) {
+	if (state.store && !opts?.forceReload) return;
+	const fileMtimeMs = await getFileMtimeMs(state.deps.storePath);
+	const jobs = (await loadCronStore(state.deps.storePath)).jobs ?? [];
+	for (const job of jobs) if (typeof job.enabled !== "boolean") job.enabled = true;
+	state.store = {
+		version: 1,
+		jobs
+	};
+	state.storeLoadedAtMs = state.deps.nowMs();
+	state.storeFileMtimeMs = fileMtimeMs;
+	if (!opts?.skipRecompute) recomputeNextRuns(state);
+}
+function warnIfDisabled(state, action) {
+	if (state.deps.cronEnabled) return;
+	if (state.warnedDisabled) return;
+	state.warnedDisabled = true;
+	state.deps.log.warn({
+		enabled: false,
+		action,
+		storePath: state.deps.storePath
+	}, "cron: scheduler disabled; jobs will not run automatically");
+}
+async function persist(state, opts) {
+	if (!state.store) return;
+	await saveCronStore(state.deps.storePath, state.store, opts);
+	state.storeFileMtimeMs = await getFileMtimeMs(state.deps.storePath);
+}
+//#endregion
+//#region src/cron/session-reaper.ts
+/**
+* Cron session reaper — prunes completed isolated cron run sessions
+* from the session store after a configurable retention period.
+*
+* Pattern: sessions keyed as `...:cron:<jobId>:run:<uuid>` are ephemeral
+* run records. The base session (`...:cron:<jobId>`) is kept as-is.
+*/
+const DEFAULT_RETENTION_MS = 24 * 36e5;
+/** Minimum interval between reaper sweeps (avoid running every timer tick). */
+const MIN_SWEEP_INTERVAL_MS = 5 * 6e4;
+const lastSweepAtMsByStore = /* @__PURE__ */ new Map();
+function resolveRetentionMs(cronConfig) {
+	if (cronConfig?.sessionRetention === false) return null;
+	const raw = cronConfig?.sessionRetention;
+	if (typeof raw === "string" && raw.trim()) try {
+		return parseDurationMs(raw.trim(), { defaultUnit: "h" });
+	} catch {
+		return DEFAULT_RETENTION_MS;
+	}
+	return DEFAULT_RETENTION_MS;
+}
+/**
+* Sweep the session store and prune expired cron run sessions.
+* Designed to be called from the cron timer tick — self-throttles via
+* MIN_SWEEP_INTERVAL_MS to avoid excessive I/O.
+*
+* Lock ordering: this function acquires the session-store file lock via
+* `updateSessionStore`. It must be called OUTSIDE of the cron service's
+* own `locked()` section to avoid lock-order inversions. The cron timer
+* calls this after all `locked()` sections have been released.
+*/
+async function sweepCronRunSessions(params) {
+	const now = params.nowMs ?? Date.now();
+	const storePath = params.sessionStorePath;
+	const lastSweepAtMs = lastSweepAtMsByStore.get(storePath) ?? 0;
+	if (!params.force && now - lastSweepAtMs < MIN_SWEEP_INTERVAL_MS) return {
+		swept: false,
+		pruned: 0
+	};
+	const retentionMs = resolveRetentionMs(params.cronConfig);
+	if (retentionMs === null) {
+		lastSweepAtMsByStore.set(storePath, now);
+		return {
+			swept: false,
+			pruned: 0
+		};
+	}
+	let pruned = 0;
+	const prunedSessions = /* @__PURE__ */ new Map();
+	try {
+		await updateSessionStore(storePath, (store) => {
+			const cutoff = now - retentionMs;
+			for (const key of Object.keys(store)) {
+				if (!isCronRunSessionKey(key)) continue;
+				const entry = store[key];
+				if (!entry) continue;
+				if ((entry.updatedAt ?? 0) < cutoff) {
+					if (!prunedSessions.has(entry.sessionId) || entry.sessionFile) prunedSessions.set(entry.sessionId, entry.sessionFile);
+					delete store[key];
+					pruned++;
+				}
+			}
+		});
+	} catch (err) {
+		params.log.warn({ err: String(err) }, "cron-reaper: failed to sweep session store");
+		return {
+			swept: false,
+			pruned: 0
+		};
+	}
+	lastSweepAtMsByStore.set(storePath, now);
+	if (prunedSessions.size > 0) try {
+		const store = loadSessionStore(storePath, { skipCache: true });
+		const archivedDirs = await archiveRemovedSessionTranscripts({
+			removedSessionFiles: prunedSessions,
+			referencedSessionIds: new Set(Object.values(store).map((entry) => entry?.sessionId).filter((id) => Boolean(id))),
+			storePath,
+			reason: "deleted",
+			restrictToStoreDir: true
+		});
+		if (archivedDirs.size > 0) await cleanupArchivedSessionTranscripts({
+			directories: [...archivedDirs],
+			olderThanMs: retentionMs,
+			reason: "deleted",
+			nowMs: now
+		});
+	} catch (err) {
+		params.log.warn({ err: String(err) }, "cron-reaper: transcript cleanup failed");
+	}
+	if (pruned > 0) params.log.info({
+		pruned,
+		retentionMs
+	}, `cron-reaper: pruned ${pruned} expired cron run session(s)`);
+	return {
+		swept: true,
+		pruned
+	};
+}
+//#endregion
+//#region src/cron/service/timeout-policy.ts
+/**
+* Maximum wall-clock time for a single job execution. Acts as a safety net
+* on top of per-provider/per-agent timeouts to prevent one stuck job from
+* wedging the entire cron lane.
+*/
+const DEFAULT_JOB_TIMEOUT_MS = 10 * 6e4;
+/**
+* Agent turns can legitimately run much longer than generic cron jobs.
+* Use a larger safety ceiling when no explicit timeout is set.
+*/
+const AGENT_TURN_SAFETY_TIMEOUT_MS = 60 * 6e4;
+function resolveCronJobTimeoutMs(job) {
+	const configuredTimeoutMs = job.payload.kind === "agentTurn" && typeof job.payload.timeoutSeconds === "number" ? Math.floor(job.payload.timeoutSeconds * 1e3) : void 0;
+	if (configuredTimeoutMs === void 0) return job.payload.kind === "agentTurn" ? AGENT_TURN_SAFETY_TIMEOUT_MS : DEFAULT_JOB_TIMEOUT_MS;
+	return configuredTimeoutMs <= 0 ? void 0 : configuredTimeoutMs;
+}
+//#endregion
+//#region src/cron/service/timer.ts
+const MAX_TIMER_DELAY_MS = 6e4;
+/**
+* Minimum gap between consecutive fires of the same cron job.  This is a
+* safety net that prevents spin-loops when `computeJobNextRunAtMs` returns
+* a value within the same second as the just-completed run.  The guard
+* is intentionally generous (2 s) so it never masks a legitimate schedule
+* but always breaks an infinite re-trigger cycle.  (See #17821)
+*/
+const MIN_REFIRE_GAP_MS = 2e3;
+const DEFAULT_MISSED_JOB_STAGGER_MS = 5e3;
+const DEFAULT_MAX_MISSED_JOBS_PER_RESTART = 5;
+const DEFAULT_FAILURE_ALERT_AFTER = 2;
+const DEFAULT_FAILURE_ALERT_COOLDOWN_MS = 60 * 6e4;
+function executeJobCoreWithTimeout(state, job) {
+	const jobTimeoutMs = resolveCronJobTimeoutMs(job);
+	if (typeof jobTimeoutMs !== "number") return executeJobCore(state, job);
+	const runAbortController = new AbortController();
+	let timeoutId;
+	try {
+		return Promise.race([executeJobCore(state, job, runAbortController.signal), new Promise((_, reject) => {
+			timeoutId = setTimeout(() => {
+				const taskLabel = job.name || job.id || "unnamed";
+				runAbortController.abort(timeoutErrorMessage(taskLabel));
+				reject(new Error(timeoutErrorMessage(taskLabel)));
+			}, jobTimeoutMs);
+		})]);
+	} finally {
+		if (timeoutId) clearTimeout(timeoutId);
+	}
+}
+function resolveRunConcurrency(state) {
+	const raw = state.deps.cronConfig?.maxConcurrentRuns;
+	if (typeof raw !== "number" || !Number.isFinite(raw)) return 1;
+	return Math.max(1, Math.floor(raw));
+}
+function timeoutErrorMessage(taskLabel) {
+	return `cron: job execution timed out${taskLabel ? ` "${taskLabel}"` : ""}`;
+}
+function isAbortError(err) {
+	if (!(err instanceof Error)) return false;
+	return err.name === "AbortError" || err.message === timeoutErrorMessage();
+}
+function normalizeCronRunErrorText(err) {
+	if (isAbortError(err)) return timeoutErrorMessage();
+	if (typeof err === "string") return err === `Error: ${timeoutErrorMessage()}` ? timeoutErrorMessage() : err;
+	return String(err);
+}
+function createCronTaskRunId$1(jobId, startedAt) {
+	return `cron:${jobId}:${startedAt}`;
+}
+function tryCreateCronTaskRun(params) {
+	const runId = createCronTaskRunId$1(params.job.id, params.startedAt);
+	try {
+		createRunningTaskRun({
+			runtime: "cron",
+			sourceId: params.job.id,
+			ownerKey: "",
+			scopeKind: "system",
+			childSessionKey: params.job.sessionKey,
+			agentId: params.job.agentId,
+			runId,
+			label: params.job.name,
+			task: params.job.name || params.job.id,
+			deliveryStatus: "not_applicable",
+			notifyPolicy: "silent",
+			startedAt: params.startedAt,
+			lastEventAt: params.startedAt
+		});
+		return runId;
+	} catch (error) {
+		params.state.deps.log.warn({
+			jobId: params.job.id,
+			error
+		}, "cron: failed to create task ledger record");
+		return;
+	}
+}
+function tryFinishCronTaskRun(state, result) {
+	if (!result.taskRunId) return;
+	try {
+		if (result.status === "ok" || result.status === "skipped") {
+			completeTaskRunByRunId({
+				runId: result.taskRunId,
+				runtime: "cron",
+				endedAt: result.endedAt,
+				lastEventAt: result.endedAt,
+				terminalSummary: result.summary ?? void 0
+			});
+			return;
+		}
+		failTaskRunByRunId({
+			runId: result.taskRunId,
+			runtime: "cron",
+			status: normalizeCronRunErrorText(result.error) === timeoutErrorMessage() ? "timed_out" : "failed",
+			endedAt: result.endedAt,
+			lastEventAt: result.endedAt,
+			error: result.status === "error" ? normalizeCronRunErrorText(result.error) : void 0,
+			terminalSummary: result.summary ?? void 0
+		});
+	} catch (error) {
+		state.deps.log.warn({
+			runId: result.taskRunId,
+			jobStatus: result.status,
+			error
+		}, "cron: failed to update task ledger record");
+	}
+}
+/**
+* Exponential backoff delays (in ms) indexed by consecutive error count.
+* After the last entry the delay stays constant.
+*/
+const DEFAULT_BACKOFF_SCHEDULE_MS = [
+	3e4,
+	6e4,
+	5 * 6e4,
+	15 * 6e4,
+	60 * 6e4
+];
+function errorBackoffMs(consecutiveErrors, scheduleMs = DEFAULT_BACKOFF_SCHEDULE_MS) {
+	const idx = Math.min(consecutiveErrors - 1, scheduleMs.length - 1);
+	return scheduleMs[Math.max(0, idx)];
+}
+/** Default max retries for one-shot jobs on transient errors (#24355). */
+const DEFAULT_MAX_TRANSIENT_RETRIES = 3;
+const TRANSIENT_PATTERNS = {
+	rate_limit: /(rate[_ ]limit|too many requests|429|resource has been exhausted|cloudflare|tokens per day)/i,
+	overloaded: /\b529\b|\boverloaded(?:_error)?\b|high demand|temporar(?:ily|y) overloaded|capacity exceeded/i,
+	network: /(network|econnreset|econnrefused|fetch failed|socket)/i,
+	timeout: /(timeout|etimedout)/i,
+	server_error: /\b5\d{2}\b/
+};
+function isTransientCronError(error, retryOn) {
+	if (!error || typeof error !== "string") return false;
+	return (retryOn?.length ? retryOn : Object.keys(TRANSIENT_PATTERNS)).some((k) => TRANSIENT_PATTERNS[k]?.test(error));
+}
+function resolveRetryConfig(cronConfig) {
+	const retry = cronConfig?.retry;
+	return {
+		maxAttempts: typeof retry?.maxAttempts === "number" ? retry.maxAttempts : DEFAULT_MAX_TRANSIENT_RETRIES,
+		backoffMs: Array.isArray(retry?.backoffMs) && retry.backoffMs.length > 0 ? retry.backoffMs : DEFAULT_BACKOFF_SCHEDULE_MS.slice(0, 3),
+		retryOn: Array.isArray(retry?.retryOn) && retry.retryOn.length > 0 ? retry.retryOn : void 0
+	};
+}
+function resolveDeliveryStatus(params) {
+	if (params.delivered === true) return "delivered";
+	if (params.delivered === false) return "not-delivered";
+	return resolveCronDeliveryPlan(params.job).requested ? "unknown" : "not-requested";
+}
+function normalizeCronMessageChannel(input) {
+	if (typeof input !== "string") return;
+	const channel = input.trim().toLowerCase();
+	return channel ? channel : void 0;
+}
+function normalizeTo(input) {
+	if (typeof input !== "string") return;
+	const to = input.trim();
+	return to ? to : void 0;
+}
+function clampPositiveInt(value, fallback) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+	const floored = Math.floor(value);
+	return floored >= 1 ? floored : fallback;
+}
+function clampNonNegativeInt(value, fallback) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+	const floored = Math.floor(value);
+	return floored >= 0 ? floored : fallback;
+}
+function resolveFailureAlert(state, job) {
+	const globalConfig = state.deps.cronConfig?.failureAlert;
+	const jobConfig = job.failureAlert === false ? void 0 : job.failureAlert;
+	if (job.failureAlert === false) return null;
+	if (!jobConfig && globalConfig?.enabled !== true) return null;
+	const mode = jobConfig?.mode ?? globalConfig?.mode;
+	const explicitTo = normalizeTo(jobConfig?.to);
+	return {
+		after: clampPositiveInt(jobConfig?.after ?? globalConfig?.after, DEFAULT_FAILURE_ALERT_AFTER),
+		cooldownMs: clampNonNegativeInt(jobConfig?.cooldownMs ?? globalConfig?.cooldownMs, DEFAULT_FAILURE_ALERT_COOLDOWN_MS),
+		channel: normalizeCronMessageChannel(jobConfig?.channel) ?? normalizeCronMessageChannel(job.delivery?.channel) ?? "last",
+		to: mode === "webhook" ? explicitTo : explicitTo ?? normalizeTo(job.delivery?.to),
+		mode,
+		accountId: jobConfig?.accountId ?? globalConfig?.accountId
+	};
+}
+function emitFailureAlert(state, params) {
+	const safeJobName = params.job.name || params.job.id;
+	const truncatedError = (params.error?.trim() || "unknown error").slice(0, 200);
+	const text = [`Cron job "${safeJobName}" failed ${params.consecutiveErrors} times`, `Last error: ${truncatedError}`].join("\n");
+	if (state.deps.sendCronFailureAlert) {
+		state.deps.sendCronFailureAlert({
+			job: params.job,
+			text,
+			channel: params.channel,
+			to: params.to,
+			mode: params.mode,
+			accountId: params.accountId
+		}).catch((err) => {
+			state.deps.log.warn({
+				jobId: params.job.id,
+				err: String(err)
+			}, "cron: failure alert delivery failed");
+		});
+		return;
+	}
+	state.deps.enqueueSystemEvent(text, { agentId: params.job.agentId });
+	if (params.job.wakeMode === "now") state.deps.requestHeartbeatNow({ reason: `cron:${params.job.id}:failure-alert` });
+}
+/**
+* Apply the result of a job execution to the job's state.
+* Handles consecutive error tracking, exponential backoff, one-shot disable,
+* and nextRunAtMs computation. Returns `true` if the job should be deleted.
+*/
+function applyJobResult(state, job, result, opts) {
+	const prevLastRunAtMs = job.state.lastRunAtMs;
+	const computeNextWithPreservedLastRun = (nowMs) => {
+		const saved = job.state.lastRunAtMs;
+		job.state.lastRunAtMs = prevLastRunAtMs;
+		try {
+			return computeJobNextRunAtMs(job, nowMs);
+		} finally {
+			job.state.lastRunAtMs = saved;
+		}
+	};
+	job.state.runningAtMs = void 0;
+	job.state.lastRunAtMs = result.startedAt;
+	job.state.lastRunStatus = result.status;
+	job.state.lastStatus = result.status;
+	job.state.lastDurationMs = Math.max(0, result.endedAt - result.startedAt);
+	job.state.lastError = result.error;
+	job.state.lastErrorReason = result.status === "error" && typeof result.error === "string" ? resolveFailoverReasonFromError(result.error) ?? void 0 : void 0;
+	job.state.lastDelivered = result.delivered;
+	const deliveryStatus = resolveDeliveryStatus({
+		job,
+		delivered: result.delivered
+	});
+	job.state.lastDeliveryStatus = deliveryStatus;
+	job.state.lastDeliveryError = deliveryStatus === "not-delivered" && result.error ? result.error : void 0;
+	job.updatedAtMs = result.endedAt;
+	if (result.status === "error") {
+		job.state.consecutiveErrors = (job.state.consecutiveErrors ?? 0) + 1;
+		const alertConfig = resolveFailureAlert(state, job);
+		if (alertConfig && job.state.consecutiveErrors >= alertConfig.after) {
+			if (!(job.delivery?.bestEffort === true)) {
+				const now = state.deps.nowMs();
+				const lastAlert = job.state.lastFailureAlertAtMs;
+				if (!(typeof lastAlert === "number" && now - lastAlert < Math.max(0, alertConfig.cooldownMs))) {
+					emitFailureAlert(state, {
+						job,
+						error: result.error,
+						consecutiveErrors: job.state.consecutiveErrors,
+						channel: alertConfig.channel,
+						to: alertConfig.to,
+						mode: alertConfig.mode,
+						accountId: alertConfig.accountId
+					});
+					job.state.lastFailureAlertAtMs = now;
+				}
+			}
+		}
+	} else {
+		job.state.consecutiveErrors = 0;
+		job.state.lastFailureAlertAtMs = void 0;
+	}
+	const shouldDelete = job.schedule.kind === "at" && job.deleteAfterRun === true && result.status === "ok";
+	if (!shouldDelete) if (job.schedule.kind === "at") {
+		if (result.status === "ok" || result.status === "skipped") {
+			job.enabled = false;
+			job.state.nextRunAtMs = void 0;
+		} else if (result.status === "error") {
+			const retryConfig = resolveRetryConfig(state.deps.cronConfig);
+			const transient = isTransientCronError(result.error, retryConfig.retryOn);
+			const consecutive = job.state.consecutiveErrors;
+			if (transient && consecutive <= retryConfig.maxAttempts) {
+				const backoff = errorBackoffMs(consecutive, retryConfig.backoffMs);
+				job.state.nextRunAtMs = result.endedAt + backoff;
+				state.deps.log.info({
+					jobId: job.id,
+					jobName: job.name,
+					consecutiveErrors: consecutive,
+					backoffMs: backoff,
+					nextRunAtMs: job.state.nextRunAtMs
+				}, "cron: scheduling one-shot retry after transient error");
+			} else {
+				job.enabled = false;
+				job.state.nextRunAtMs = void 0;
+				state.deps.log.warn({
+					jobId: job.id,
+					jobName: job.name,
+					consecutiveErrors: consecutive,
+					error: result.error,
+					reason: transient ? "max retries exhausted" : "permanent error"
+				}, "cron: disabling one-shot job after error");
+			}
+		}
+	} else if (result.status === "error" && isJobEnabled(job)) {
+		const backoff = errorBackoffMs(job.state.consecutiveErrors ?? 1);
+		let normalNext;
+		try {
+			normalNext = opts?.preserveSchedule && job.schedule.kind === "every" ? computeNextWithPreservedLastRun(result.endedAt) : computeJobNextRunAtMs(job, result.endedAt);
+		} catch (err) {
+			recordScheduleComputeError({
+				state,
+				job,
+				err
+			});
+		}
+		const backoffNext = result.endedAt + backoff;
+		job.state.nextRunAtMs = normalNext !== void 0 ? Math.max(normalNext, backoffNext) : backoffNext;
+		state.deps.log.info({
+			jobId: job.id,
+			consecutiveErrors: job.state.consecutiveErrors,
+			backoffMs: backoff,
+			nextRunAtMs: job.state.nextRunAtMs
+		}, "cron: applying error backoff");
+	} else if (isJobEnabled(job)) {
+		let naturalNext;
+		try {
+			naturalNext = opts?.preserveSchedule && job.schedule.kind === "every" ? computeNextWithPreservedLastRun(result.endedAt) : computeJobNextRunAtMs(job, result.endedAt);
+		} catch (err) {
+			recordScheduleComputeError({
+				state,
+				job,
+				err
+			});
+		}
+		if (job.schedule.kind === "cron") {
+			const minNext = result.endedAt + MIN_REFIRE_GAP_MS;
+			job.state.nextRunAtMs = naturalNext !== void 0 ? Math.max(naturalNext, minNext) : minNext;
+		} else job.state.nextRunAtMs = naturalNext;
+	} else job.state.nextRunAtMs = void 0;
+	return shouldDelete;
+}
+function applyOutcomeToStoredJob(state, result) {
+	tryFinishCronTaskRun(state, result);
+	const store = state.store;
+	if (!store) return;
+	const jobs = store.jobs;
+	const job = jobs.find((entry) => entry.id === result.jobId);
+	if (!job) {
+		state.deps.log.warn({ jobId: result.jobId }, "cron: applyOutcomeToStoredJob — job not found after forceReload, result discarded");
+		return;
+	}
+	const shouldDelete = applyJobResult(state, job, {
+		status: result.status,
+		error: result.error,
+		delivered: result.delivered,
+		startedAt: result.startedAt,
+		endedAt: result.endedAt
+	});
+	emitJobFinished(state, job, result, result.startedAt);
+	if (shouldDelete) {
+		store.jobs = jobs.filter((entry) => entry.id !== job.id);
+		emit(state, {
+			jobId: job.id,
+			action: "removed"
+		});
+	}
+}
+function armTimer(state) {
+	if (state.timer) clearTimeout(state.timer);
+	state.timer = null;
+	if (!state.deps.cronEnabled) {
+		state.deps.log.debug({}, "cron: armTimer skipped - scheduler disabled");
+		return;
+	}
+	const nextAt = nextWakeAtMs(state);
+	if (!nextAt) {
+		const jobCount = state.store?.jobs.length ?? 0;
+		const enabledCount = state.store?.jobs.filter((j) => j.enabled).length ?? 0;
+		const withNextRun = state.store?.jobs.filter((j) => j.enabled && typeof j.state.nextRunAtMs === "number" && Number.isFinite(j.state.nextRunAtMs)).length ?? 0;
+		state.deps.log.debug({
+			jobCount,
+			enabledCount,
+			withNextRun
+		}, "cron: armTimer skipped - no jobs with nextRunAtMs");
+		return;
+	}
+	const now = state.deps.nowMs();
+	const delay = Math.max(nextAt - now, 0);
+	const clampedDelay = Math.min(delay === 0 ? MIN_REFIRE_GAP_MS : delay, MAX_TIMER_DELAY_MS);
+	state.timer = setTimeout(() => {
+		onTimer(state).catch((err) => {
+			state.deps.log.error({ err: String(err) }, "cron: timer tick failed");
+		});
+	}, clampedDelay);
+	state.deps.log.debug({
+		nextAt,
+		delayMs: clampedDelay,
+		clamped: delay > MAX_TIMER_DELAY_MS
+	}, "cron: timer armed");
+}
+function armRunningRecheckTimer(state) {
+	if (state.timer) clearTimeout(state.timer);
+	state.timer = setTimeout(() => {
+		onTimer(state).catch((err) => {
+			state.deps.log.error({ err: String(err) }, "cron: timer tick failed");
+		});
+	}, MAX_TIMER_DELAY_MS);
+}
+async function onTimer(state) {
+	if (state.running) {
+		armRunningRecheckTimer(state);
+		return;
+	}
+	state.running = true;
+	armRunningRecheckTimer(state);
+	try {
+		const dueJobs = await locked(state, async () => {
+			await ensureLoaded(state, {
+				forceReload: true,
+				skipRecompute: true
+			});
+			const dueCheckNow = state.deps.nowMs();
+			const due = collectRunnableJobs(state, dueCheckNow);
+			if (due.length === 0) {
+				if (recomputeNextRunsForMaintenance(state, {
+					recomputeExpired: true,
+					nowMs: dueCheckNow
+				})) await persist(state);
+				return [];
+			}
+			const now = state.deps.nowMs();
+			for (const job of due) {
+				job.state.runningAtMs = now;
+				job.state.lastError = void 0;
+			}
+			await persist(state);
+			return due.map((j) => ({
+				id: j.id,
+				job: j
+			}));
+		});
+		const runDueJob = async (params) => {
+			const { id, job } = params;
+			const startedAt = state.deps.nowMs();
+			job.state.runningAtMs = startedAt;
+			emit(state, {
+				jobId: job.id,
+				action: "started",
+				runAtMs: startedAt
+			});
+			const jobTimeoutMs = resolveCronJobTimeoutMs(job);
+			const taskRunId = tryCreateCronTaskRun({
+				state,
+				job,
+				startedAt
+			});
+			try {
+				return {
+					jobId: id,
+					taskRunId,
+					...await executeJobCoreWithTimeout(state, job),
+					startedAt,
+					endedAt: state.deps.nowMs()
+				};
+			} catch (err) {
+				const errorText = normalizeCronRunErrorText(err);
+				state.deps.log.warn({
+					jobId: id,
+					jobName: job.name,
+					timeoutMs: jobTimeoutMs ?? null
+				}, `cron: job failed: ${errorText}`);
+				return {
+					jobId: id,
+					taskRunId,
+					status: "error",
+					error: errorText,
+					startedAt,
+					endedAt: state.deps.nowMs()
+				};
+			}
+		};
+		const concurrency = Math.min(resolveRunConcurrency(state), Math.max(1, dueJobs.length));
+		const results = Array.from({ length: dueJobs.length });
+		let cursor = 0;
+		const workers = Array.from({ length: concurrency }, async () => {
+			for (;;) {
+				const index = cursor++;
+				if (index >= dueJobs.length) return;
+				const due = dueJobs[index];
+				if (!due) return;
+				results[index] = await runDueJob(due);
+			}
+		});
+		await Promise.all(workers);
+		const completedResults = results.filter((entry) => entry !== void 0);
+		if (completedResults.length > 0) await locked(state, async () => {
+			await ensureLoaded(state, {
+				forceReload: true,
+				skipRecompute: true
+			});
+			for (const result of completedResults) applyOutcomeToStoredJob(state, result);
+			recomputeNextRunsForMaintenance(state);
+			await persist(state);
+		});
+	} finally {
+		const storePaths = /* @__PURE__ */ new Set();
+		if (state.deps.resolveSessionStorePath) {
+			const defaultAgentId = state.deps.defaultAgentId ?? "main";
+			if (state.store?.jobs?.length) for (const job of state.store.jobs) {
+				const agentId = typeof job.agentId === "string" && job.agentId.trim() ? job.agentId : defaultAgentId;
+				storePaths.add(state.deps.resolveSessionStorePath(agentId));
+			}
+			else storePaths.add(state.deps.resolveSessionStorePath(defaultAgentId));
+		} else if (state.deps.sessionStorePath) storePaths.add(state.deps.sessionStorePath);
+		if (storePaths.size > 0) {
+			const nowMs = state.deps.nowMs();
+			for (const storePath of storePaths) try {
+				await sweepCronRunSessions({
+					cronConfig: state.deps.cronConfig,
+					sessionStorePath: storePath,
+					nowMs,
+					log: state.deps.log
+				});
+			} catch (err) {
+				state.deps.log.warn({
+					err: String(err),
+					storePath
+				}, "cron: session reaper sweep failed");
+			}
+		}
+		state.running = false;
+		armTimer(state);
+	}
+}
+function isRunnableJob(params) {
+	const { job, nowMs } = params;
+	if (!job.state) job.state = {};
+	if (!isJobEnabled(job)) return false;
+	if (params.skipJobIds?.has(job.id)) return false;
+	if (typeof job.state.runningAtMs === "number") return false;
+	if (params.skipAtIfAlreadyRan && job.schedule.kind === "at" && job.state.lastStatus) {
+		const lastRun = job.state.lastRunAtMs;
+		const nextRun = job.state.nextRunAtMs;
+		if (job.state.lastStatus === "error" && isJobEnabled(job) && typeof nextRun === "number" && typeof lastRun === "number" && nextRun > lastRun) return nowMs >= nextRun;
+		return false;
+	}
+	const next = job.state.nextRunAtMs;
+	if (typeof next === "number" && Number.isFinite(next) && nowMs >= next) return true;
+	if (typeof next === "number" && Number.isFinite(next) && next > nowMs && isErrorBackoffPending(job, nowMs)) return false;
+	if (!params.allowCronMissedRunByLastRun || job.schedule.kind !== "cron") return false;
+	let previousRunAtMs;
+	try {
+		previousRunAtMs = computeJobPreviousRunAtMs(job, nowMs);
+	} catch {
+		return false;
+	}
+	if (typeof previousRunAtMs !== "number" || !Number.isFinite(previousRunAtMs)) return false;
+	const lastRunAtMs = job.state.lastRunAtMs;
+	if (typeof lastRunAtMs !== "number" || !Number.isFinite(lastRunAtMs)) return false;
+	return previousRunAtMs > lastRunAtMs;
+}
+function isErrorBackoffPending(job, nowMs) {
+	if (job.schedule.kind === "at" || job.state.lastStatus !== "error") return false;
+	const lastRunAtMs = job.state.lastRunAtMs;
+	if (typeof lastRunAtMs !== "number" || !Number.isFinite(lastRunAtMs)) return false;
+	const consecutiveErrorsRaw = job.state.consecutiveErrors;
+	return nowMs < lastRunAtMs + errorBackoffMs(typeof consecutiveErrorsRaw === "number" && Number.isFinite(consecutiveErrorsRaw) ? Math.max(1, Math.floor(consecutiveErrorsRaw)) : 1);
+}
+function collectRunnableJobs(state, nowMs, opts) {
+	if (!state.store) return [];
+	return state.store.jobs.filter((job) => isRunnableJob({
+		job,
+		nowMs,
+		skipJobIds: opts?.skipJobIds,
+		skipAtIfAlreadyRan: opts?.skipAtIfAlreadyRan,
+		allowCronMissedRunByLastRun: opts?.allowCronMissedRunByLastRun
+	}));
+}
+async function runMissedJobs(state, opts) {
+	const plan = await planStartupCatchup(state, opts);
+	if (plan.candidates.length === 0 && plan.deferredJobIds.length === 0) return;
+	await applyStartupCatchupOutcomes(state, plan, await executeStartupCatchupPlan(state, plan));
+}
+async function planStartupCatchup(state, opts) {
+	const maxImmediate = Math.max(0, state.deps.maxMissedJobsPerRestart ?? DEFAULT_MAX_MISSED_JOBS_PER_RESTART);
+	return locked(state, async () => {
+		await ensureLoaded(state, { skipRecompute: true });
+		if (!state.store) return {
+			candidates: [],
+			deferredJobIds: []
+		};
+		const now = state.deps.nowMs();
+		const missed = collectRunnableJobs(state, now, {
+			skipJobIds: opts?.skipJobIds,
+			skipAtIfAlreadyRan: true,
+			allowCronMissedRunByLastRun: true
+		});
+		if (missed.length === 0) return {
+			candidates: [],
+			deferredJobIds: []
+		};
+		const sorted = missed.toSorted((a, b) => (a.state.nextRunAtMs ?? 0) - (b.state.nextRunAtMs ?? 0));
+		const startupCandidates = sorted.slice(0, maxImmediate);
+		const deferred = sorted.slice(maxImmediate);
+		if (deferred.length > 0) state.deps.log.info({
+			immediateCount: startupCandidates.length,
+			deferredCount: deferred.length,
+			totalMissed: missed.length
+		}, "cron: staggering missed jobs to prevent gateway overload");
+		if (startupCandidates.length > 0) state.deps.log.info({
+			count: startupCandidates.length,
+			jobIds: startupCandidates.map((j) => j.id)
+		}, "cron: running missed jobs after restart");
+		for (const job of startupCandidates) {
+			job.state.runningAtMs = now;
+			job.state.lastError = void 0;
+		}
+		await persist(state);
+		return {
+			candidates: startupCandidates.map((job) => ({
+				jobId: job.id,
+				job
+			})),
+			deferredJobIds: deferred.map((job) => job.id)
+		};
+	});
+}
+async function executeStartupCatchupPlan(state, plan) {
+	const outcomes = [];
+	for (const candidate of plan.candidates) outcomes.push(await runStartupCatchupCandidate(state, candidate));
+	return outcomes;
+}
+async function runStartupCatchupCandidate(state, candidate) {
+	const startedAt = state.deps.nowMs();
+	const taskRunId = tryCreateCronTaskRun({
+		state,
+		job: candidate.job,
+		startedAt
+	});
+	emit(state, {
+		jobId: candidate.job.id,
+		action: "started",
+		runAtMs: startedAt
+	});
+	try {
+		const result = await executeJobCoreWithTimeout(state, candidate.job);
+		return {
+			jobId: candidate.jobId,
+			taskRunId,
+			status: result.status,
+			error: result.error,
+			summary: result.summary,
+			delivered: result.delivered,
+			sessionId: result.sessionId,
+			sessionKey: result.sessionKey,
+			model: result.model,
+			provider: result.provider,
+			usage: result.usage,
+			startedAt,
+			endedAt: state.deps.nowMs()
+		};
+	} catch (err) {
+		return {
+			jobId: candidate.jobId,
+			taskRunId,
+			status: "error",
+			error: normalizeCronRunErrorText(err),
+			startedAt,
+			endedAt: state.deps.nowMs()
+		};
+	}
+}
+async function applyStartupCatchupOutcomes(state, plan, outcomes) {
+	const staggerMs = Math.max(0, state.deps.missedJobStaggerMs ?? DEFAULT_MISSED_JOB_STAGGER_MS);
+	await locked(state, async () => {
+		await ensureLoaded(state, { skipRecompute: true });
+		if (!state.store) return;
+		for (const result of outcomes) applyOutcomeToStoredJob(state, result);
+		if (plan.deferredJobIds.length > 0) {
+			const baseNow = state.deps.nowMs();
+			let offset = staggerMs;
+			for (const jobId of plan.deferredJobIds) {
+				const job = state.store.jobs.find((entry) => entry.id === jobId);
+				if (!job || !isJobEnabled(job)) continue;
+				job.state.nextRunAtMs = baseNow + offset;
+				offset += staggerMs;
+			}
+		}
+		recomputeNextRunsForMaintenance(state);
+		await persist(state);
+	});
+}
+async function executeJobCore(state, job, abortSignal) {
+	const resolveAbortError = () => ({
+		status: "error",
+		error: timeoutErrorMessage()
+	});
+	const waitWithAbort = async (ms) => {
+		if (!abortSignal) {
+			await new Promise((resolve) => setTimeout(resolve, ms));
+			return;
+		}
+		if (abortSignal.aborted) return;
+		await new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				abortSignal.removeEventListener("abort", onAbort);
+				resolve();
+			}, ms);
+			const onAbort = () => {
+				clearTimeout(timer);
+				abortSignal.removeEventListener("abort", onAbort);
+				resolve();
+			};
+			abortSignal.addEventListener("abort", onAbort, { once: true });
+		});
+	};
+	if (abortSignal?.aborted) return resolveAbortError();
+	if (job.sessionTarget === "main") return await executeMainSessionCronJob(state, job, abortSignal, waitWithAbort);
+	return await executeDetachedCronJob(state, job, abortSignal, resolveAbortError);
+}
+async function executeMainSessionCronJob(state, job, abortSignal, waitWithAbort) {
+	const text = resolveJobPayloadTextForMain(job);
+	if (!text) return {
+		status: "skipped",
+		error: job.payload.kind === "systemEvent" ? "main job requires non-empty systemEvent text" : "main job requires payload.kind=\"systemEvent\""
+	};
+	const targetMainSessionKey = job.sessionKey;
+	state.deps.enqueueSystemEvent(text, {
+		agentId: job.agentId,
+		sessionKey: targetMainSessionKey,
+		contextKey: `cron:${job.id}`
+	});
+	if (job.wakeMode === "now" && state.deps.runHeartbeatOnce) {
+		const reason = `cron:${job.id}`;
+		const isRecurringJob = job.schedule.kind !== "at";
+		const maxWaitMs = state.deps.wakeNowHeartbeatBusyMaxWaitMs ?? 2 * 6e4;
+		const retryDelayMs = state.deps.wakeNowHeartbeatBusyRetryDelayMs ?? 250;
+		const waitStartedAt = state.deps.nowMs();
+		let heartbeatResult;
+		for (;;) {
+			if (abortSignal?.aborted) return {
+				status: "error",
+				error: timeoutErrorMessage()
+			};
+			heartbeatResult = await state.deps.runHeartbeatOnce({
+				reason,
+				agentId: job.agentId,
+				sessionKey: targetMainSessionKey,
+				heartbeat: { target: "last" }
+			});
+			if (heartbeatResult.status !== "skipped" || heartbeatResult.reason !== "requests-in-flight") break;
+			if (isRecurringJob) {
+				state.deps.requestHeartbeatNow({
+					reason,
+					agentId: job.agentId,
+					sessionKey: targetMainSessionKey
+				});
+				return {
+					status: "ok",
+					summary: text
+				};
+			}
+			if (abortSignal?.aborted) return {
+				status: "error",
+				error: timeoutErrorMessage()
+			};
+			if (state.deps.nowMs() - waitStartedAt > maxWaitMs) {
+				if (abortSignal?.aborted) return {
+					status: "error",
+					error: timeoutErrorMessage()
+				};
+				state.deps.requestHeartbeatNow({
+					reason,
+					agentId: job.agentId,
+					sessionKey: targetMainSessionKey
+				});
+				return {
+					status: "ok",
+					summary: text
+				};
+			}
+			await waitWithAbort(retryDelayMs);
+		}
+		if (heartbeatResult.status === "ran") return {
+			status: "ok",
+			summary: text
+		};
+		if (heartbeatResult.status === "skipped") return {
+			status: "skipped",
+			error: heartbeatResult.reason,
+			summary: text
+		};
+		return {
+			status: "error",
+			error: heartbeatResult.reason,
+			summary: text
+		};
+	}
+	if (abortSignal?.aborted) return {
+		status: "error",
+		error: timeoutErrorMessage()
+	};
+	state.deps.requestHeartbeatNow({
+		reason: `cron:${job.id}`,
+		agentId: job.agentId,
+		sessionKey: targetMainSessionKey
+	});
+	return {
+		status: "ok",
+		summary: text
+	};
+}
+async function executeDetachedCronJob(state, job, abortSignal, resolveAbortError) {
+	if (job.payload.kind !== "agentTurn") return {
+		status: "skipped",
+		error: "isolated job requires payload.kind=agentTurn"
+	};
+	if (abortSignal?.aborted) return resolveAbortError();
+	const res = await state.deps.runIsolatedAgentJob({
+		job,
+		message: job.payload.message,
+		abortSignal
+	});
+	if (abortSignal?.aborted) return {
+		status: "error",
+		error: timeoutErrorMessage()
+	};
+	return {
+		status: res.status,
+		error: res.error,
+		summary: res.summary,
+		delivered: res.delivered,
+		deliveryAttempted: res.deliveryAttempted,
+		sessionId: res.sessionId,
+		sessionKey: res.sessionKey,
+		model: res.model,
+		provider: res.provider,
+		usage: res.usage
+	};
+}
+function emitJobFinished(state, job, result, runAtMs) {
+	emit(state, {
+		jobId: job.id,
+		action: "finished",
+		status: result.status,
+		error: result.error,
+		summary: result.summary,
+		delivered: result.delivered,
+		deliveryStatus: job.state.lastDeliveryStatus,
+		deliveryError: job.state.lastDeliveryError,
+		sessionId: result.sessionId,
+		sessionKey: result.sessionKey,
+		runAtMs,
+		durationMs: job.state.lastDurationMs,
+		nextRunAtMs: job.state.nextRunAtMs,
+		model: result.model,
+		provider: result.provider,
+		usage: result.usage
+	});
+}
+function wake(state, opts) {
+	const text = opts.text.trim();
+	if (!text) return { ok: false };
+	state.deps.enqueueSystemEvent(text);
+	if (opts.mode === "now") state.deps.requestHeartbeatNow({ reason: "wake" });
+	return { ok: true };
+}
+function stopTimer(state) {
+	if (state.timer) clearTimeout(state.timer);
+	state.timer = null;
+}
+function emit(state, evt) {
+	try {
+		state.deps.onEvent?.(evt);
+	} catch {}
+}
+//#endregion
+//#region src/cron/service/ops.ts
+function mergeManualRunSnapshotAfterReload(params) {
+	if (!params.state.store) return;
+	if (params.removed) {
+		params.state.store.jobs = params.state.store.jobs.filter((job) => job.id !== params.jobId);
+		return;
+	}
+	if (!params.snapshot) return;
+	const reloaded = params.state.store.jobs.find((job) => job.id === params.jobId);
+	if (!reloaded) return;
+	reloaded.enabled = params.snapshot.enabled;
+	reloaded.updatedAtMs = params.snapshot.updatedAtMs;
+	reloaded.state = params.snapshot.state;
+}
+async function ensureLoadedForRead(state) {
+	await ensureLoaded(state, { skipRecompute: true });
+	if (!state.store) return;
+	if (recomputeNextRunsForMaintenance(state)) await persist(state);
+}
+async function start(state) {
+	if (!state.deps.cronEnabled) {
+		state.deps.log.info({ enabled: false }, "cron: disabled");
+		return;
+	}
+	const startupInterruptedJobIds = /* @__PURE__ */ new Set();
+	await locked(state, async () => {
+		await ensureLoaded(state, { skipRecompute: true });
+		const jobs = state.store?.jobs ?? [];
+		for (const job of jobs) if (typeof job.state.runningAtMs === "number") {
+			state.deps.log.warn({
+				jobId: job.id,
+				runningAtMs: job.state.runningAtMs
+			}, "cron: clearing stale running marker on startup");
+			job.state.runningAtMs = void 0;
+			startupInterruptedJobIds.add(job.id);
+		}
+		if (startupInterruptedJobIds.size > 0) await persist(state);
+	});
+	await runMissedJobs(state, { skipJobIds: startupInterruptedJobIds });
+	await locked(state, async () => {
+		await ensureLoaded(state, { skipRecompute: true });
+		if (recomputeNextRuns(state)) await persist(state);
+		armTimer(state);
+		state.deps.log.info({
+			enabled: true,
+			jobs: state.store?.jobs.length ?? 0,
+			nextWakeAtMs: nextWakeAtMs(state) ?? null
+		}, "cron: started");
+	});
+}
+function stop(state) {
+	stopTimer(state);
+}
+async function status(state) {
+	return await locked(state, async () => {
+		await ensureLoadedForRead(state);
+		return {
+			enabled: state.deps.cronEnabled,
+			storePath: state.deps.storePath,
+			jobs: state.store?.jobs.length ?? 0,
+			nextWakeAtMs: state.deps.cronEnabled ? nextWakeAtMs(state) ?? null : null
+		};
+	});
+}
+async function list(state, opts) {
+	return await locked(state, async () => {
+		await ensureLoadedForRead(state);
+		const includeDisabled = opts?.includeDisabled === true;
+		return (state.store?.jobs ?? []).filter((j) => includeDisabled || isJobEnabled(j)).toSorted((a, b) => (a.state.nextRunAtMs ?? 0) - (b.state.nextRunAtMs ?? 0));
+	});
+}
+function resolveEnabledFilter(opts) {
+	if (opts?.enabled === "all" || opts?.enabled === "enabled" || opts?.enabled === "disabled") return opts.enabled;
+	return opts?.includeDisabled ? "all" : "enabled";
+}
+function sortJobs(jobs, sortBy, sortDir) {
+	const dir = sortDir === "desc" ? -1 : 1;
+	return jobs.toSorted((a, b) => {
+		let cmp = 0;
+		if (sortBy === "name") {
+			const aName = typeof a.name === "string" ? a.name : "";
+			const bName = typeof b.name === "string" ? b.name : "";
+			cmp = aName.localeCompare(bName, void 0, { sensitivity: "base" });
+		} else if (sortBy === "updatedAtMs") cmp = a.updatedAtMs - b.updatedAtMs;
+		else {
+			const aNext = a.state.nextRunAtMs;
+			const bNext = b.state.nextRunAtMs;
+			if (typeof aNext === "number" && typeof bNext === "number") cmp = aNext - bNext;
+			else if (typeof aNext === "number") cmp = -1;
+			else if (typeof bNext === "number") cmp = 1;
+			else cmp = 0;
+		}
+		if (cmp !== 0) return cmp * dir;
+		const aId = typeof a.id === "string" ? a.id : "";
+		const bId = typeof b.id === "string" ? b.id : "";
+		return aId.localeCompare(bId);
+	});
+}
+async function listPage(state, opts) {
+	return await locked(state, async () => {
+		await ensureLoadedForRead(state);
+		const query = opts?.query?.trim().toLowerCase() ?? "";
+		const enabledFilter = resolveEnabledFilter(opts);
+		const sortBy = opts?.sortBy ?? "nextRunAtMs";
+		const sortDir = opts?.sortDir ?? "asc";
+		const sorted = sortJobs((state.store?.jobs ?? []).filter((job) => {
+			if (enabledFilter === "enabled" && !isJobEnabled(job)) return false;
+			if (enabledFilter === "disabled" && isJobEnabled(job)) return false;
+			if (!query) return true;
+			return [
+				job.name,
+				job.description ?? "",
+				job.agentId ?? ""
+			].join(" ").toLowerCase().includes(query);
+		}), sortBy, sortDir);
+		const total = sorted.length;
+		const offset = Math.max(0, Math.min(total, Math.floor(opts?.offset ?? 0)));
+		const defaultLimit = total === 0 ? 50 : total;
+		const limit = Math.max(1, Math.min(200, Math.floor(opts?.limit ?? defaultLimit)));
+		const jobs = sorted.slice(offset, offset + limit);
+		const nextOffset = offset + jobs.length;
+		return {
+			jobs,
+			total,
+			offset,
+			limit,
+			hasMore: nextOffset < total,
+			nextOffset: nextOffset < total ? nextOffset : null
+		};
+	});
+}
+async function add(state, input) {
+	return await locked(state, async () => {
+		warnIfDisabled(state, "add");
+		await ensureLoaded(state);
+		const job = createJob(state, input);
+		state.store?.jobs.push(job);
+		recomputeNextRuns(state);
+		await persist(state);
+		armTimer(state);
+		state.deps.log.info({
+			jobId: job.id,
+			jobName: job.name,
+			nextRunAtMs: job.state.nextRunAtMs,
+			schedulerNextWakeAtMs: nextWakeAtMs(state) ?? null,
+			timerArmed: state.timer !== null,
+			cronEnabled: state.deps.cronEnabled
+		}, "cron: job added");
+		emit(state, {
+			jobId: job.id,
+			action: "added",
+			nextRunAtMs: job.state.nextRunAtMs
+		});
+		return job;
+	});
+}
+async function update(state, id, patch) {
+	return await locked(state, async () => {
+		warnIfDisabled(state, "update");
+		await ensureLoaded(state, { skipRecompute: true });
+		const job = findJobOrThrow(state, id);
+		const now = state.deps.nowMs();
+		applyJobPatch(job, patch, { defaultAgentId: state.deps.defaultAgentId });
+		if (job.schedule.kind === "every") {
+			const anchor = job.schedule.anchorMs;
+			if (typeof anchor !== "number" || !Number.isFinite(anchor)) {
+				const fallbackAnchorMs = patch.schedule?.kind === "every" ? now : typeof job.createdAtMs === "number" && Number.isFinite(job.createdAtMs) ? job.createdAtMs : now;
+				job.schedule = {
+					...job.schedule,
+					anchorMs: Math.max(0, Math.floor(fallbackAnchorMs))
+				};
+			}
+		}
+		const scheduleChanged = patch.schedule !== void 0;
+		const enabledChanged = patch.enabled !== void 0;
+		job.updatedAtMs = now;
+		if (scheduleChanged || enabledChanged) if (isJobEnabled(job)) job.state.nextRunAtMs = computeJobNextRunAtMs(job, now);
+		else {
+			job.state.nextRunAtMs = void 0;
+			job.state.runningAtMs = void 0;
+		}
+		else if (isJobEnabled(job)) {
+			const nextRun = job.state.nextRunAtMs;
+			if (typeof nextRun !== "number" || !Number.isFinite(nextRun)) job.state.nextRunAtMs = computeJobNextRunAtMs(job, now);
+		}
+		await persist(state);
+		armTimer(state);
+		emit(state, {
+			jobId: id,
+			action: "updated",
+			nextRunAtMs: job.state.nextRunAtMs
+		});
+		return job;
+	});
+}
+async function remove(state, id) {
+	return await locked(state, async () => {
+		warnIfDisabled(state, "remove");
+		await ensureLoaded(state);
+		const before = state.store?.jobs.length ?? 0;
+		if (!state.store) return {
+			ok: false,
+			removed: false
+		};
+		state.store.jobs = state.store.jobs.filter((j) => j.id !== id);
+		const removed = (state.store.jobs.length ?? 0) !== before;
+		await persist(state);
+		armTimer(state);
+		if (removed) emit(state, {
+			jobId: id,
+			action: "removed"
+		});
+		return {
+			ok: true,
+			removed
+		};
+	});
+}
+let nextManualRunId = 1;
+function createCronTaskRunId(jobId, startedAt) {
+	return `cron:${jobId}:${startedAt}`;
+}
+function tryCreateManualTaskRun(params) {
+	const runId = createCronTaskRunId(params.job.id, params.startedAt);
+	try {
+		createRunningTaskRun({
+			runtime: "cron",
+			sourceId: params.job.id,
+			ownerKey: "",
+			scopeKind: "system",
+			childSessionKey: params.job.sessionKey,
+			agentId: params.job.agentId,
+			runId,
+			label: params.job.name,
+			task: params.job.name || params.job.id,
+			deliveryStatus: "not_applicable",
+			notifyPolicy: "silent",
+			startedAt: params.startedAt,
+			lastEventAt: params.startedAt
+		});
+		return runId;
+	} catch (error) {
+		params.state.deps.log.warn({
+			jobId: params.job.id,
+			error
+		}, "cron: failed to create task ledger record");
+		return;
+	}
+}
+function tryFinishManualTaskRun(state, params) {
+	if (!params.taskRunId) return;
+	try {
+		if (params.coreResult.status === "ok" || params.coreResult.status === "skipped") {
+			completeTaskRunByRunId({
+				runId: params.taskRunId,
+				runtime: "cron",
+				endedAt: params.endedAt,
+				lastEventAt: params.endedAt,
+				terminalSummary: params.coreResult.summary ?? void 0
+			});
+			return;
+		}
+		failTaskRunByRunId({
+			runId: params.taskRunId,
+			runtime: "cron",
+			status: normalizeCronRunErrorText(params.coreResult.error) === "cron: job execution timed out" ? "timed_out" : "failed",
+			endedAt: params.endedAt,
+			lastEventAt: params.endedAt,
+			error: params.coreResult.status === "error" ? normalizeCronRunErrorText(params.coreResult.error) : void 0,
+			terminalSummary: params.coreResult.summary ?? void 0
+		});
+	} catch (error) {
+		state.deps.log.warn({
+			runId: params.taskRunId,
+			jobStatus: params.coreResult.status,
+			error
+		}, "cron: failed to update task ledger record");
+	}
+}
+async function inspectManualRunPreflight(state, id, mode) {
+	return await locked(state, async () => {
+		warnIfDisabled(state, "run");
+		await ensureLoaded(state, { skipRecompute: true });
+		recomputeNextRunsForMaintenance(state);
+		const job = findJobOrThrow(state, id);
+		if (typeof job.state.runningAtMs === "number") return {
+			ok: true,
+			ran: false,
+			reason: "already-running"
+		};
+		const now = state.deps.nowMs();
+		if (!isJobDue(job, now, { forced: mode === "force" })) return {
+			ok: true,
+			ran: false,
+			reason: "not-due"
+		};
+		return {
+			ok: true,
+			runnable: true,
+			job,
+			now
+		};
+	});
+}
+async function inspectManualRunDisposition(state, id, mode) {
+	const result = await inspectManualRunPreflight(state, id, mode);
+	if (!result.ok) return result;
+	if ("reason" in result) return result;
+	return {
+		ok: true,
+		runnable: true
+	};
+}
+async function prepareManualRun(state, id, mode) {
+	const preflight = await inspectManualRunPreflight(state, id, mode);
+	if (!preflight.ok) return preflight;
+	if ("reason" in preflight) return {
+		ok: true,
+		ran: false,
+		reason: preflight.reason
+	};
+	return await locked(state, async () => {
+		const job = findJobOrThrow(state, id);
+		if (typeof job.state.runningAtMs === "number") return {
+			ok: true,
+			ran: false,
+			reason: "already-running"
+		};
+		job.state.runningAtMs = preflight.now;
+		job.state.lastError = void 0;
+		await persist(state);
+		emit(state, {
+			jobId: job.id,
+			action: "started",
+			runAtMs: preflight.now
+		});
+		const taskRunId = tryCreateManualTaskRun({
+			state,
+			job,
+			startedAt: preflight.now
+		});
+		const executionJob = JSON.parse(JSON.stringify(job));
+		return {
+			ok: true,
+			ran: true,
+			jobId: job.id,
+			taskRunId,
+			startedAt: preflight.now,
+			executionJob
+		};
+	});
+}
+async function finishPreparedManualRun(state, prepared, mode) {
+	const executionJob = prepared.executionJob;
+	const startedAt = prepared.startedAt;
+	const jobId = prepared.jobId;
+	const taskRunId = prepared.taskRunId;
+	let coreResult;
+	try {
+		coreResult = await executeJobCoreWithTimeout(state, executionJob);
+	} catch (err) {
+		coreResult = {
+			status: "error",
+			error: normalizeCronRunErrorText(err)
+		};
+	}
+	const endedAt = state.deps.nowMs();
+	tryFinishManualTaskRun(state, {
+		taskRunId,
+		coreResult,
+		endedAt
+	});
+	await locked(state, async () => {
+		await ensureLoaded(state, { skipRecompute: true });
+		const job = state.store?.jobs.find((entry) => entry.id === jobId);
+		if (!job) return;
+		const shouldDelete = applyJobResult(state, job, {
+			status: coreResult.status,
+			error: coreResult.error,
+			delivered: coreResult.delivered,
+			startedAt,
+			endedAt
+		}, { preserveSchedule: mode === "force" });
+		emit(state, {
+			jobId: job.id,
+			action: "finished",
+			status: coreResult.status,
+			error: coreResult.error,
+			summary: coreResult.summary,
+			delivered: coreResult.delivered,
+			deliveryStatus: job.state.lastDeliveryStatus,
+			deliveryError: job.state.lastDeliveryError,
+			sessionId: coreResult.sessionId,
+			sessionKey: coreResult.sessionKey,
+			runAtMs: startedAt,
+			durationMs: job.state.lastDurationMs,
+			nextRunAtMs: job.state.nextRunAtMs,
+			model: coreResult.model,
+			provider: coreResult.provider,
+			usage: coreResult.usage
+		});
+		if (shouldDelete && state.store) {
+			state.store.jobs = state.store.jobs.filter((entry) => entry.id !== job.id);
+			emit(state, {
+				jobId: job.id,
+				action: "removed"
+			});
+		}
+		const postRunSnapshot = shouldDelete ? null : {
+			enabled: job.enabled,
+			updatedAtMs: job.updatedAtMs,
+			state: structuredClone(job.state)
+		};
+		const postRunRemoved = shouldDelete;
+		await ensureLoaded(state, {
+			forceReload: true,
+			skipRecompute: true
+		});
+		mergeManualRunSnapshotAfterReload({
+			state,
+			jobId,
+			snapshot: postRunSnapshot,
+			removed: postRunRemoved
+		});
+		recomputeNextRunsForMaintenance(state, { recomputeExpired: true });
+		await persist(state);
+		armTimer(state);
+	});
+}
+async function run(state, id, mode) {
+	const prepared = await prepareManualRun(state, id, mode);
+	if (!prepared.ok || !prepared.ran) return prepared;
+	await finishPreparedManualRun(state, prepared, mode);
+	return {
+		ok: true,
+		ran: true
+	};
+}
+async function enqueueRun(state, id, mode) {
+	const disposition = await inspectManualRunDisposition(state, id, mode);
+	if (!disposition.ok || !("runnable" in disposition && disposition.runnable)) return disposition;
+	const runId = `manual:${id}:${state.deps.nowMs()}:${nextManualRunId++}`;
+	enqueueCommandInLane(CommandLane.Cron, async () => {
+		const result = await run(state, id, mode);
+		if (result.ok && "ran" in result && !result.ran) state.deps.log.info({
+			jobId: id,
+			runId,
+			reason: result.reason
+		}, "cron: queued manual run skipped before execution");
+		return result;
+	}, {
+		warnAfterMs: 5e3,
+		onWait: (waitMs, queuedAhead) => {
+			state.deps.log.warn({
+				jobId: id,
+				runId,
+				waitMs,
+				queuedAhead
+			}, "cron: queued manual run waiting for an execution slot");
+		}
+	}).catch((err) => {
+		state.deps.log.error({
+			jobId: id,
+			runId,
+			err: String(err)
+		}, "cron: queued manual run background execution failed");
+	});
+	return {
+		ok: true,
+		enqueued: true,
+		runId
+	};
+}
+function wakeNow(state, opts) {
+	return wake(state, opts);
+}
+//#endregion
+//#region src/cron/service/state.ts
+function createCronServiceState(deps) {
+	return {
+		deps: {
+			...deps,
+			nowMs: deps.nowMs ?? (() => Date.now())
+		},
+		store: null,
+		timer: null,
+		running: false,
+		op: Promise.resolve(),
+		warnedDisabled: false,
+		storeLoadedAtMs: null,
+		storeFileMtimeMs: null
+	};
+}
+//#endregion
+//#region src/cron/service.ts
+var CronService = class {
+	constructor(deps) {
+		this.state = createCronServiceState(deps);
+	}
+	async start() {
+		await start(this.state);
+	}
+	stop() {
+		stop(this.state);
+	}
+	async status() {
+		return await status(this.state);
+	}
+	async list(opts) {
+		return await list(this.state, opts);
+	}
+	async listPage(opts) {
+		return await listPage(this.state, opts);
+	}
+	async add(input) {
+		return await add(this.state, input);
+	}
+	async update(id, patch) {
+		return await update(this.state, id, patch);
+	}
+	async remove(id) {
+		return await remove(this.state, id);
+	}
+	async run(id, mode) {
+		return await run(this.state, id, mode);
+	}
+	async enqueueRun(id, mode) {
+		return await enqueueRun(this.state, id, mode);
+	}
+	getJob(id) {
+		return this.state.store?.jobs.find((job) => job.id === id);
+	}
+	wake(opts) {
+		return wakeNow(this.state, opts);
+	}
+};
+//#endregion
+//#region src/gateway/server-cron.ts
+const CRON_WEBHOOK_TIMEOUT_MS = 1e4;
+function trimToOptionalString(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function redactWebhookUrl(url) {
+	try {
+		const parsed = new URL(url);
+		return `${parsed.origin}${parsed.pathname}`;
+	} catch {
+		return "<invalid-webhook-url>";
+	}
+}
+function resolveCronWebhookTarget(params) {
+	if (params.delivery?.mode?.trim().toLowerCase() === "webhook") {
+		const url = normalizeHttpWebhookUrl(params.delivery?.to);
+		return url ? {
+			url,
+			source: "delivery"
+		} : null;
+	}
+	if (params.legacyNotify) {
+		const legacyUrl = normalizeHttpWebhookUrl(params.legacyWebhook);
+		if (legacyUrl) return {
+			url: legacyUrl,
+			source: "legacy"
+		};
+	}
+	return null;
+}
+function buildCronWebhookHeaders(webhookToken) {
+	const headers = { "Content-Type": "application/json" };
+	if (webhookToken) headers.Authorization = `Bearer ${webhookToken}`;
+	return headers;
+}
+async function postCronWebhook(params) {
+	const abortController = new AbortController();
+	const timeout = setTimeout(() => {
+		abortController.abort();
+	}, CRON_WEBHOOK_TIMEOUT_MS);
+	try {
+		await (await fetchWithSsrFGuard({
+			url: params.webhookUrl,
+			init: {
+				method: "POST",
+				headers: buildCronWebhookHeaders(params.webhookToken),
+				body: JSON.stringify(params.payload),
+				signal: abortController.signal
+			}
+		})).release();
+	} catch (err) {
+		if (err instanceof SsrFBlockedError) params.logger.warn({
+			...params.logContext,
+			reason: formatErrorMessage(err),
+			webhookUrl: redactWebhookUrl(params.webhookUrl)
+		}, params.blockedLog);
+		else params.logger.warn({
+			...params.logContext,
+			err: formatErrorMessage(err),
+			webhookUrl: redactWebhookUrl(params.webhookUrl)
+		}, params.failedLog);
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+function buildGatewayCronService(params) {
+	const cronLogger = getChildLogger({ module: "cron" });
+	const storePath = resolveCronStorePath(params.cfg.cron?.store);
+	const cronEnabled = process.env.OPENCLAW_SKIP_CRON !== "1" && params.cfg.cron?.enabled !== false;
+	const resolveCronAgent = (requested) => {
+		const runtimeConfig = loadConfig();
+		const normalized = typeof requested === "string" && requested.trim() ? normalizeAgentId(requested) : void 0;
+		return {
+			agentId: normalized !== void 0 && Array.isArray(runtimeConfig.agents?.list) && runtimeConfig.agents.list.some((entry) => entry && typeof entry.id === "string" && normalizeAgentId(entry.id) === normalized) ? normalized : resolveDefaultAgentId(runtimeConfig),
+			cfg: runtimeConfig
+		};
+	};
+	const resolveCronSessionKey = (params) => {
+		const requested = params.requestedSessionKey?.trim();
+		if (!requested) return resolveAgentMainSessionKey({
+			cfg: params.runtimeConfig,
+			agentId: params.agentId
+		});
+		const candidate = toAgentStoreSessionKey({
+			agentId: params.agentId,
+			requestKey: requested,
+			mainKey: params.runtimeConfig.session?.mainKey
+		});
+		const canonical = canonicalizeMainSessionAlias({
+			cfg: params.runtimeConfig,
+			agentId: params.agentId,
+			sessionKey: candidate
+		});
+		if (canonical !== "global") {
+			if (normalizeAgentId(resolveAgentIdFromSessionKey(canonical)) !== normalizeAgentId(params.agentId)) return resolveAgentMainSessionKey({
+				cfg: params.runtimeConfig,
+				agentId: params.agentId
+			});
+		}
+		return canonical;
+	};
+	const resolveCronWakeTarget = (opts) => {
+		const runtimeConfig = loadConfig();
+		const agentId = ((opts?.agentId ? resolveCronAgent(opts.agentId).agentId : void 0) ?? (opts?.sessionKey ? normalizeAgentId(resolveAgentIdFromSessionKey(opts.sessionKey)) : void 0)) || void 0;
+		return {
+			runtimeConfig,
+			agentId,
+			sessionKey: opts?.sessionKey && agentId ? resolveCronSessionKey({
+				runtimeConfig,
+				agentId,
+				requestedSessionKey: opts.sessionKey
+			}) : void 0
+		};
+	};
+	const defaultAgentId = resolveDefaultAgentId(params.cfg);
+	const runLogPrune = resolveCronRunLogPruneOptions(params.cfg.cron?.runLog);
+	const resolveSessionStorePath = (agentId) => resolveStorePath(params.cfg.session?.store, { agentId: agentId ?? defaultAgentId });
+	const sessionStorePath = resolveSessionStorePath(defaultAgentId);
+	const warnedLegacyWebhookJobs = /* @__PURE__ */ new Set();
+	const cron = new CronService({
+		storePath,
+		cronEnabled,
+		cronConfig: params.cfg.cron,
+		defaultAgentId,
+		resolveSessionStorePath,
+		sessionStorePath,
+		enqueueSystemEvent: (text, opts) => {
+			const { agentId, cfg: runtimeConfig } = resolveCronAgent(opts?.agentId);
+			enqueueSystemEvent(text, {
+				sessionKey: resolveCronSessionKey({
+					runtimeConfig,
+					agentId,
+					requestedSessionKey: opts?.sessionKey
+				}),
+				contextKey: opts?.contextKey
+			});
+		},
+		requestHeartbeatNow: (opts) => {
+			const { agentId, sessionKey } = resolveCronWakeTarget(opts);
+			requestHeartbeatNow({
+				reason: opts?.reason,
+				agentId,
+				sessionKey
+			});
+		},
+		runHeartbeatOnce: async (opts) => {
+			const { runtimeConfig, agentId, sessionKey } = resolveCronWakeTarget(opts);
+			const agentEntry = Array.isArray(runtimeConfig.agents?.list) && runtimeConfig.agents.list.find((entry) => entry && typeof entry.id === "string" && normalizeAgentId(entry.id) === agentId);
+			const agentHeartbeat = agentEntry && typeof agentEntry === "object" ? agentEntry.heartbeat : void 0;
+			const baseHeartbeat = {
+				...runtimeConfig.agents?.defaults?.heartbeat,
+				...agentHeartbeat
+			};
+			const heartbeatOverride = opts?.heartbeat ? {
+				...baseHeartbeat,
+				...opts.heartbeat
+			} : void 0;
+			return await runHeartbeatOnce({
+				cfg: runtimeConfig,
+				reason: opts?.reason,
+				agentId,
+				sessionKey,
+				heartbeat: heartbeatOverride,
+				deps: {
+					...params.deps,
+					runtime: defaultRuntime
+				}
+			});
+		},
+		runIsolatedAgentJob: async ({ job, message, abortSignal }) => {
+			const { agentId, cfg: runtimeConfig } = resolveCronAgent(job.agentId);
+			let sessionKey = `cron:${job.id}`;
+			if (job.sessionTarget.startsWith("session:")) {
+				const customSessionId = job.sessionTarget.slice(8).trim();
+				if (customSessionId) sessionKey = customSessionId;
+			}
+			return await runCronIsolatedAgentTurn({
+				cfg: runtimeConfig,
+				deps: params.deps,
+				job,
+				message,
+				abortSignal,
+				agentId,
+				sessionKey,
+				lane: "cron"
+			});
+		},
+		sendCronFailureAlert: async ({ job, text, channel, to, mode, accountId }) => {
+			const { agentId, cfg: runtimeConfig } = resolveCronAgent(job.agentId);
+			const webhookToken = trimToOptionalString(params.cfg.cron?.webhookToken);
+			if (mode === "webhook" && !to) {
+				cronLogger.warn({ jobId: job.id }, "cron: failure alert webhook mode requires URL, skipping");
+				return;
+			}
+			if (mode === "webhook" && to) {
+				const webhookUrl = normalizeHttpWebhookUrl(to);
+				if (webhookUrl) await postCronWebhook({
+					webhookUrl,
+					webhookToken,
+					payload: {
+						jobId: job.id,
+						jobName: job.name,
+						message: text
+					},
+					logContext: { jobId: job.id },
+					blockedLog: "cron: failure alert webhook blocked by SSRF guard",
+					failedLog: "cron: failure alert webhook failed",
+					logger: cronLogger
+				});
+				else cronLogger.warn({
+					jobId: job.id,
+					webhookUrl: redactWebhookUrl(to)
+				}, "cron: failure alert webhook URL is invalid, skipping");
+				return;
+			}
+			const target = await resolveDeliveryTarget(runtimeConfig, agentId, {
+				channel,
+				to,
+				accountId
+			});
+			if (!target.ok) throw target.error;
+			await deliverOutboundPayloads({
+				cfg: runtimeConfig,
+				channel: target.channel,
+				to: target.to,
+				accountId: target.accountId,
+				threadId: target.threadId,
+				payloads: [{ text }],
+				deps: createOutboundSendDeps(params.deps)
+			});
+		},
+		log: getChildLogger({
+			module: "cron",
+			storePath
+		}),
+		onEvent: (evt) => {
+			params.broadcast("cron", evt, { dropIfSlow: true });
+			if (evt.action === "finished") {
+				const webhookToken = trimToOptionalString(params.cfg.cron?.webhookToken);
+				const legacyWebhook = trimToOptionalString(params.cfg.cron?.webhook);
+				const job = cron.getJob(evt.jobId);
+				const legacyNotify = job?.notify === true;
+				const webhookTarget = resolveCronWebhookTarget({
+					delivery: job?.delivery && typeof job.delivery.mode === "string" ? {
+						mode: job.delivery.mode,
+						to: job.delivery.to
+					} : void 0,
+					legacyNotify,
+					legacyWebhook
+				});
+				if (!webhookTarget && job?.delivery?.mode === "webhook") cronLogger.warn({
+					jobId: evt.jobId,
+					deliveryTo: job.delivery.to
+				}, "cron: skipped webhook delivery, delivery.to must be a valid http(s) URL");
+				if (webhookTarget?.source === "legacy" && !warnedLegacyWebhookJobs.has(evt.jobId)) {
+					warnedLegacyWebhookJobs.add(evt.jobId);
+					cronLogger.warn({
+						jobId: evt.jobId,
+						legacyWebhook: redactWebhookUrl(webhookTarget.url)
+					}, "cron: deprecated notify+cron.webhook fallback in use, migrate to delivery.mode=webhook with delivery.to");
+				}
+				if (webhookTarget && evt.summary) (async () => {
+					await postCronWebhook({
+						webhookUrl: webhookTarget.url,
+						webhookToken,
+						payload: evt,
+						logContext: { jobId: evt.jobId },
+						blockedLog: "cron: webhook delivery blocked by SSRF guard",
+						failedLog: "cron: webhook delivery failed",
+						logger: cronLogger
+					});
+				})();
+				if (evt.status === "error" && job) {
+					const failureDest = resolveFailureDestination(job, params.cfg.cron?.failureDestination);
+					if (failureDest) {
+						if (!(job.delivery?.bestEffort === true)) {
+							const failureMessage = `Cron job "${job.name}" failed: ${evt.error ?? "unknown error"}`;
+							const failurePayload = {
+								jobId: job.id,
+								jobName: job.name,
+								message: failureMessage,
+								status: evt.status,
+								error: evt.error,
+								runAtMs: evt.runAtMs,
+								durationMs: evt.durationMs,
+								nextRunAtMs: evt.nextRunAtMs
+							};
+							if (failureDest.mode === "webhook" && failureDest.to) {
+								const webhookUrl = normalizeHttpWebhookUrl(failureDest.to);
+								if (webhookUrl) (async () => {
+									await postCronWebhook({
+										webhookUrl,
+										webhookToken,
+										payload: failurePayload,
+										logContext: { jobId: evt.jobId },
+										blockedLog: "cron: failure destination webhook blocked by SSRF guard",
+										failedLog: "cron: failure destination webhook failed",
+										logger: cronLogger
+									});
+								})();
+								else cronLogger.warn({
+									jobId: evt.jobId,
+									webhookUrl: redactWebhookUrl(failureDest.to)
+								}, "cron: failure destination webhook URL is invalid, skipping");
+							} else if (failureDest.mode === "announce") {
+								const { agentId, cfg: runtimeConfig } = resolveCronAgent(job.agentId);
+								sendFailureNotificationAnnounce(params.deps, runtimeConfig, agentId, job.id, {
+									channel: failureDest.channel,
+									to: failureDest.to,
+									accountId: failureDest.accountId
+								}, `[Cron Failure] ${failureMessage}`);
+							}
+						}
+					}
+				}
+				const logPath = resolveCronRunLogPath({
+					storePath,
+					jobId: evt.jobId
+				});
+				appendCronRunLog(logPath, {
+					ts: Date.now(),
+					jobId: evt.jobId,
+					action: "finished",
+					status: evt.status,
+					error: evt.error,
+					summary: evt.summary,
+					delivered: evt.delivered,
+					deliveryStatus: evt.deliveryStatus,
+					deliveryError: evt.deliveryError,
+					sessionId: evt.sessionId,
+					sessionKey: evt.sessionKey,
+					runAtMs: evt.runAtMs,
+					durationMs: evt.durationMs,
+					nextRunAtMs: evt.nextRunAtMs,
+					model: evt.model,
+					provider: evt.provider,
+					usage: evt.usage
+				}, runLogPrune).catch((err) => {
+					cronLogger.warn({
+						err: String(err),
+						logPath
+					}, "cron: run log append failed");
+				});
+			}
+		}
+	});
+	return {
+		cron,
+		storePath,
+		cronEnabled
+	};
+}
+//#endregion
+export { runCronIsolatedAgentTurn as n, buildGatewayCronService as t };