/** Builds stable identities for cron scheduling inputs. */

import { normalizeOptionalString } from "@openclaw/normalization-core/string-coerce";

import { coerceFiniteScheduleNumber } from "./schedule-number.js";

import { normalizeCronStaggerMs } from "./stagger.js";

const tz = readString(schedule, "tz");

const staggerMs = readStaggerMs(schedule);

const kind =

// Infer legacy shorthand schedule shapes when kind is missing so timer

// identity remains stable across old persisted jobs and normalized jobs.

rawKind === "at" || rawKind === "every" || rawKind === "cron"

? rawKind

: at

/** Coerces cron schedule number fields with strict finite-number parsing. */

import { parseStrictFiniteNumber } from "@openclaw/normalization-core/number-coercion";

/** Coerces schedule numeric fields without accepting partial or non-finite numbers. */

/** Computes at/every/cron schedule timestamps with bounded Croner caching. */

import { normalizeOptionalString } from "@openclaw/normalization-core/string-coerce";

import { Cron } from "croner";

import { parseAbsoluteTimeMs } from "./parse.js";

return cached;

}

if (cronEvalCache.size >= CRON_EVAL_CACHE_MAX) {

// Expression parsing is expensive enough to cache, but cron jobs can be

// edited dynamically; keep the cache bounded and LRU-like.

const oldest = cronEvalCache.keys().next().value;

if (oldest) {

cronEvalCache.delete(oldest);

/** Timeout watchdogs for isolated cron agent setup and execution phases. */

import type {

CronAgentExecutionPhase,

CronAgentExecutionPhaseUpdate,

const previousPhase = activeExecution?.phase;

activeExecution = { ...activeExecution, ...info };

const stage = info.phase ? CRON_AGENT_PHASE_WATCHDOG_STAGE[info.phase] : undefined;

// A fallback attempt can return to setup-like phases after execution began;

// re-arm pre-execution timing so the fallback path cannot stall silently.

if (

state === "executing" &&

previousPhase === "before_agent_reply" &&

/** Formats stable cron timeout and execution error messages. */

import { formatEmbeddedAgentExecutionPhase } from "../../agents/embedded-agent-runner/execution-phase.js";

import type { CronAgentExecutionStarted } from "../types.js";

/** Resolves and emits cron failure-alert notifications. */

import { normalizeOptionalLowercaseString } from "@openclaw/normalization-core/string-coerce";

import { resolveFailoverReasonFromError } from "../../agents/failover-error.js";

import type { CronFailureNotificationDelivery, CronJob, CronMessageChannel } from "../types.js";

const mode = jobConfig?.mode ?? globalConfig?.mode;

const explicitTo = normalizeTo(jobConfig?.to);

// Announce alerts inherit the job delivery target; webhook alerts require an

// explicit alert target so chat recipients are not reused as URLs.

return {

after: clampPositiveInt(jobConfig?.after ?? globalConfig?.after, DEFAULT_FAILURE_ALERT_AFTER),

cooldownMs: clampNonNegativeInt(

/** Resolves create-time default delivery for new cron jobs. */

import type { CronDelivery, CronJobCreate } from "../types.js";

/** Resolves default cron delivery for new jobs when callers omit explicit delivery config. */

/** Cron job scheduling, validation, creation, and patch helpers. */

import crypto from "node:crypto";

import {

normalizeOptionalString,

return;

}

if (job.delivery.mode === "webhook") {

// Webhook delivery is standalone and does not need an isolated chat target.

return;

}

const isIsolatedLike =

);

}

if (job.sessionTarget === "main" && job.delivery?.mode !== "webhook") {

// Main-session jobs cannot auto-announce; keep only an empty failure

// destination object when the patch is clearing nested fields.

const failureDestination = job.delivery?.failureDestination;

job.delivery =

failureDestination && !hasConcreteFailureDestination(failureDestination)