@agent-native/core 0.0.0-beta-20260820214042 → 0.0.0-beta-20260820220930

package/dist/client/agent-page/AgentJobsTab.js

@@ -11,7 +11,9 @@ import { AgentEmptyState } from "./AgentEmptyState.js";
 import { AgentTabFrame } from "./AgentTabFrame.js";
 import { AutomationDetailsDialog, } from "./AutomationDetailsDialog.js";
 import { AutomationScheduleDialog } from "./AutomationScheduleDialog.js";
-import { useAutomations, useManageAutomation, useManageRecurringJob, useRunAutomationNow, useRecurringJobs, } from "./use-jobs.js";
+import { scheduleFiringFor, } from "./scheduled-trigger-state.js";
+import { ScheduledTriggerNotice } from "./ScheduledTriggerNotice.js";
+import { useAutomations, useManageAutomation, useManageRecurringJob, useRunAutomationNow, useRecurringJobs, useScheduledTriggerState, } from "./use-jobs.js";
 function listRecurringJobs(jobs) {
     return jobs.map((resource) => ({
         kind: "recurring",
@@ -37,7 +39,33 @@ function describeTrigger(entry, t) {
         entry.resource.schedule ||
         t("jobs.scheduledTrigger", { defaultValue: "Scheduled" }));
 }
-function detailsFields(entry, t, formatDateTime) {
+/**
+ * `nextRun` is computed from the cron expression, not from anything that
+ * promises to run it, so it must never be presented with more confidence than
+ * the scheduler check earned. Three answers, three phrasings: a known-dead
+ * scheduler replaces the date, an unverified one qualifies it, and a confirmed
+ * one shows it plainly.
+ */
+function nextRunValue(entry, t, formatDateTime, scheduleFiring, unset) {
+    const formatted = formatDateTime(entry.resource.nextRun);
+    if (entry.triggerType !== "schedule" || scheduleFiring === "fires") {
+        return formatted ?? unset;
+    }
+    if (scheduleFiring === "never") {
+        return t("jobs.nextRunNeverScheduler", {
+            defaultValue: "Never — no scheduler in this deploy",
+        });
+    }
+    return formatted
+        ? t("jobs.nextRunSchedulerUnknown", {
+            defaultValue: "{{date}} — unconfirmed, the scheduler check failed",
+            date: formatted,
+        })
+        : t("jobs.nextRunSchedulerUnknownNoDate", {
+            defaultValue: "Unknown — the scheduler check failed",
+        });
+}
+function detailsFields(entry, t, formatDateTime, scheduleFiring) {
     const resource = entry.resource;
     const unset = t("jobs.notSet", { defaultValue: "—" });
     const fields = [
@@ -66,7 +94,7 @@ function detailsFields(entry, t, formatDateTime) {
     }
     fields.push({
         label: t("jobs.nextRun", { defaultValue: "Next run" }),
-        value: formatDateTime(resource.nextRun) ?? unset,
+        value: nextRunValue(entry, t, formatDateTime, scheduleFiring, unset),
     }, {
         label: t("jobs.lastRun", { defaultValue: "Last run" }),
         value: formatDateTime(resource.lastRun) ??
@@ -104,6 +132,11 @@ export function AgentJobsTab({ canManageOrg = false, hideHeader = false, }) {
     const personalAutomationsQuery = useAutomations("user");
     const organizationJobsQuery = useRecurringJobs("org");
     const organizationAutomationsQuery = useAutomations("org");
+    const scheduledTriggerState = useScheduledTriggerState();
+    // Three states, not `!== false`: that expression also swallowed a FAILED
+    // status query, which then licensed a confident "Next run" forever. See
+    // `scheduleFiringFor` for which way each state leans and why.
+    const scheduleFiring = scheduleFiringFor(scheduledTriggerState);
     const personalJobsMutation = useManageRecurringJob("user");
     const personalAutomationsMutation = useManageAutomation("user");
     const organizationJobsMutation = useManageRecurringJob("org");
@@ -240,7 +273,7 @@ export function AgentJobsTab({ canManageOrg = false, hideHeader = false, }) {
                 defaultValue: "Create an automation",
             }), label: t("jobs.newAutomation", {
                 defaultValue: "New automation",
-            }) }), children: [_jsxs("div", { className: "space-y-7", children: [hideHeader ? (_jsx("div", { className: "flex justify-end", children: _jsx(AgentAskPopover, { context: automationCreationContext(), prompt: t("jobs.automationPrompt", {
+            }) }), children: [_jsxs("div", { className: "space-y-7", children: [_jsx(ScheduledTriggerNotice, { state: scheduledTriggerState }), hideHeader ? (_jsx("div", { className: "flex justify-end", children: _jsx(AgentAskPopover, { context: automationCreationContext(), prompt: t("jobs.automationPrompt", {
                                 defaultValue: "Create an automation that does this: ",
                             }), title: t("jobs.automationsCreateTitle", {
                                 defaultValue: "Create an automation",
@@ -296,9 +329,9 @@ export function AgentJobsTab({ canManageOrg = false, hideHeader = false, }) {
                                             name: runTarget.resource.name,
                                             scope: runTarget.resource.scope,
                                         }, { onSuccess: () => setRunTarget(null) });
-                                    }, children: [runAutomationMutation.isPending ? (_jsx(IconLoader2, { className: "size-4 animate-spin" })) : (_jsx(IconPlayerPlay, { className: "size-4" })), t("jobs.runNow", { defaultValue: "Run now" })] })] })] }) }), detailsTarget ? (_jsx(AutomationDetailsDialog, { open: true, name: detailsTarget.resource.name, scope: detailsTarget.resource.scope === "organization" ? "org" : "user", triggerSummary: describeTrigger(detailsTarget, t), fields: detailsFields(detailsTarget, t, formatDateTime), condition: detailsTarget.kind === "automation"
+                                    }, children: [runAutomationMutation.isPending ? (_jsx(IconLoader2, { className: "size-4 animate-spin" })) : (_jsx(IconPlayerPlay, { className: "size-4" })), t("jobs.runNow", { defaultValue: "Run now" })] })] })] }) }), detailsTarget ? (_jsx(AutomationDetailsDialog, { open: true, name: detailsTarget.resource.name, scope: detailsTarget.resource.scope === "organization" ? "org" : "user", triggerSummary: describeTrigger(detailsTarget, t), fields: detailsFields(detailsTarget, t, formatDateTime, scheduleFiring), condition: detailsTarget.kind === "automation"
                     ? detailsTarget.resource.condition
                     : null, instructions: detailsTarget.kind === "automation"
                     ? detailsTarget.resource.body
-                    : detailsTarget.resource.instructions, mcpTools: detailsTarget.resource.mcpTools ?? [], lastError: detailsTarget.resource.lastError, formatTimestamp: (value) => formatDateTime(new Date(value).toISOString()) ?? String(value), onClose: () => setDetailsTarget(null) })) : null, scheduleTarget ? (_jsx(AutomationScheduleDialog, { open: true, name: scheduleTarget.resource.name, schedule: scheduleTarget.resource.schedule ?? "", timezone: scheduleTarget.resource.timezone ?? null, saving: mutationPending, error: mutationError ? mutationError.message : null, onCancel: () => setScheduleTarget(null), onSave: (next) => mutateEntry(scheduleTarget, "update", next, () => setScheduleTarget(null)) })) : null] }));
+                    : detailsTarget.resource.instructions, mcpTools: detailsTarget.resource.mcpTools ?? [], lastError: detailsTarget.resource.lastError, formatTimestamp: (value) => formatDateTime(new Date(value).toISOString()) ?? String(value), onClose: () => setDetailsTarget(null) })) : null, scheduleTarget ? (_jsx(AutomationScheduleDialog, { open: true, name: scheduleTarget.resource.name, schedule: scheduleTarget.resource.schedule ?? "", timezone: scheduleTarget.resource.timezone ?? null, saving: mutationPending, error: mutationError ? mutationError.message : null, scheduledTriggerState: scheduledTriggerState, onCancel: () => setScheduleTarget(null), onSave: (next) => mutateEntry(scheduleTarget, "update", next, () => setScheduleTarget(null)) })) : null] }));
 }

package/dist/client/agent-page/AutomationScheduleDialog.d.ts

@@ -1,3 +1,4 @@
+import type { ScheduledTriggerState } from "./scheduled-trigger-state.js";
 export interface AutomationScheduleDialogProps {
     open: boolean;
     name: string;
@@ -5,10 +6,18 @@ export interface AutomationScheduleDialogProps {
     timezone: string | null;
     saving: boolean;
     error?: string | null;
+    /**
+     * Passed in rather than queried here so this dialog stays presentational, the
+     * way the rest of its props already are. Carries the whole query state so a
+     * failed check is distinguishable from a healthy one — this dialog is where
+     * someone is actively picking a cadence, so an unverified scheduler is exactly
+     * what they need told.
+     */
+    scheduledTriggerState: ScheduledTriggerState;
     onCancel: () => void;
     onSave: (next: {
         schedule: string;
         timezone: string;
     }) => void;
 }
-export declare function AutomationScheduleDialog({ open, name, schedule, timezone, saving, error, onCancel, onSave, }: AutomationScheduleDialogProps): import("react").JSX.Element;
+export declare function AutomationScheduleDialog({ open, name, schedule, timezone, saving, error, scheduledTriggerState, onCancel, onSave, }: AutomationScheduleDialogProps): import("react").JSX.Element;

package/dist/client/agent-page/AutomationScheduleDialog.js

@@ -5,6 +5,7 @@ import { IconLoader2 } from "@tabler/icons-react";
 import { useEffect, useState } from "react";
 import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, } from "../components/ui/dialog.js";
 import { useT } from "../i18n.js";
+import { ScheduledTriggerNotice } from "./ScheduledTriggerNotice.js";
 import { TimezoneSelect, browserTimezone } from "./TimezoneSelect.js";
 const PRESETS = [
     { label: "Every hour", cron: "0 * * * *" },
@@ -16,7 +17,7 @@ const CRON_FIELD_COUNT = 5;
 function looksLikeCron(value) {
     return value.trim().split(/\s+/).length === CRON_FIELD_COUNT;
 }
-export function AutomationScheduleDialog({ open, name, schedule, timezone, saving, error, onCancel, onSave, }) {
+export function AutomationScheduleDialog({ open, name, schedule, timezone, saving, error, scheduledTriggerState, onCancel, onSave, }) {
     const t = useT();
     const [value, setValue] = useState(schedule);
     const [zone, setZone] = useState(timezone || browserTimezone());
@@ -37,7 +38,7 @@ export function AutomationScheduleDialog({ open, name, schedule, timezone, savin
                                 name: name.replace(/-/g, " "),
                             }) }), _jsx(DialogDescription, { children: t("jobs.editScheduleDescription", {
                                 defaultValue: "The clock time below is read in the timezone you pick, so 8:00 means 8:00 there.",
-                            }) })] }), _jsxs("div", { className: "space-y-3", children: [_jsxs("div", { children: [_jsx("label", { className: "text-xs font-medium text-foreground", htmlFor: "automation-schedule", children: t("jobs.cronExpression", { defaultValue: "Cron expression" }) }), _jsx(Input, { id: "automation-schedule", className: "mt-1 font-mono text-sm", value: value, spellCheck: false, autoComplete: "off", disabled: saving, onChange: (event) => setValue(event.target.value) }), _jsx("p", { className: "mt-1 text-[11px] text-muted-foreground", children: t("jobs.cronFormatHint", {
+                            }) })] }), _jsxs("div", { className: "space-y-3", children: [_jsx(ScheduledTriggerNotice, { state: scheduledTriggerState, variant: "inline" }), _jsxs("div", { children: [_jsx("label", { className: "text-xs font-medium text-foreground", htmlFor: "automation-schedule", children: t("jobs.cronExpression", { defaultValue: "Cron expression" }) }), _jsx(Input, { id: "automation-schedule", className: "mt-1 font-mono text-sm", value: value, spellCheck: false, autoComplete: "off", disabled: saving, onChange: (event) => setValue(event.target.value) }), _jsx("p", { className: "mt-1 text-[11px] text-muted-foreground", children: t("jobs.cronFormatHint", {
                                         defaultValue: "minute hour day-of-month month day-of-week",
                                     }) })] }), _jsx("div", { className: "flex flex-wrap gap-1.5", children: PRESETS.map((preset) => (_jsx(Button, { type: "button", variant: "outline", size: "sm", className: "h-7 cursor-pointer text-[11px]", disabled: saving, onClick: () => setValue(preset.cron), children: preset.label }, preset.cron))) }), _jsxs("div", { children: [_jsx("label", { className: "text-xs font-medium text-foreground", htmlFor: "automation-timezone", children: t("jobs.timezone", { defaultValue: "Timezone" }) }), _jsx("div", { className: "mt-1", children: _jsx(TimezoneSelect, { id: "automation-timezone", value: zone, disabled: saving, onChange: setZone, suggested: [browserTimezone()] }) })] }), trimmed && !valid ? (_jsx("p", { className: "text-xs text-destructive", children: t("jobs.cronFieldCount", {
                                 defaultValue: "A cron expression needs exactly 5 fields.",

package/dist/client/agent-page/ScheduledTriggerNotice.d.ts

@@ -0,0 +1,22 @@
+import type { ScheduledTriggerState } from "./scheduled-trigger-state.js";
+export interface ScheduledTriggerNoticeProps {
+    state: ScheduledTriggerState;
+    /** `banner` heads the page; `inline` sits inside the schedule dialog. */
+    variant?: "banner" | "inline";
+}
+/**
+ * Warns that schedule-triggered automations will not fire in this deploy.
+ *
+ * Worth a persistent surface rather than a one-time toast: whether a schedule
+ * fires is decided by the BUILD, while automations are created at runtime, so
+ * the mismatch is invisible at the moment it bites. Without this, a scheduled
+ * automation reports "Enabled" with a plausible "Next run" and silently never
+ * runs. Shown on the Automations page and again inside the schedule editor,
+ * which is the one place a user is actively choosing a cadence.
+ *
+ * Takes the whole query state, not just a resolved status, because a status
+ * check that FAILED has to look different from one that came back healthy: the
+ * failure is why the next-run dates alongside it are unverified, and silently
+ * rendering nothing would present them as confirmed.
+ */
+export declare function ScheduledTriggerNotice({ state, variant, }: ScheduledTriggerNoticeProps): import("react").JSX.Element | null;

package/dist/client/agent-page/ScheduledTriggerNotice.js

@@ -0,0 +1,84 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { IconAlertCircle, IconAlertTriangle, IconChevronRight, } from "@tabler/icons-react";
+import { useT } from "../i18n.js";
+/**
+ * Warns that schedule-triggered automations will not fire in this deploy.
+ *
+ * Worth a persistent surface rather than a one-time toast: whether a schedule
+ * fires is decided by the BUILD, while automations are created at runtime, so
+ * the mismatch is invisible at the moment it bites. Without this, a scheduled
+ * automation reports "Enabled" with a plausible "Next run" and silently never
+ * runs. Shown on the Automations page and again inside the schedule editor,
+ * which is the one place a user is actively choosing a cadence.
+ *
+ * Takes the whole query state, not just a resolved status, because a status
+ * check that FAILED has to look different from one that came back healthy: the
+ * failure is why the next-run dates alongside it are unverified, and silently
+ * rendering nothing would present them as confirmed.
+ */
+export function ScheduledTriggerNotice({ state, variant = "banner", }) {
+    const t = useT();
+    // Still in flight: resolves in milliseconds, so say nothing rather than
+    // flash a caveat at every reader on a perfectly healthy deploy.
+    if (state.kind === "loading")
+        return null;
+    const shell = variant === "banner"
+        ? "flex items-start gap-2.5 rounded-xl border px-4 py-3"
+        : "flex items-start gap-2 rounded-lg border px-3 py-2";
+    // Muted rather than amber: "we could not check" is a weaker claim than "this
+    // will not run", and dressing it identically would teach readers to discount
+    // the one that means something.
+    if (state.kind === "unknown") {
+        return (_jsxs("div", { role: "status", "data-testid": "scheduled-trigger-notice", "data-reason": "check-failed", className: `${shell} border-border/70 bg-muted/50`, children: [_jsx(IconAlertCircle, { className: "mt-px size-4 shrink-0 text-muted-foreground" }), _jsxs("div", { className: "min-w-0", children: [_jsx("p", { className: "text-xs font-medium text-foreground", children: t("jobs.scheduleUnknownTitle", {
+                                defaultValue: "Couldn't check whether schedules run here",
+                            }) }), _jsx("p", { className: "mt-0.5 text-[11px] leading-4 text-muted-foreground", children: t("jobs.scheduleUnknownDetail", {
+                                defaultValue: "The scheduler status check failed, so the next run times below " +
+                                    "are unconfirmed. Reload to check again.",
+                            }) })] })] }));
+    }
+    const status = state.status;
+    if (status.available)
+        return null;
+    const headline = status.reason === "local-development"
+        ? t("jobs.scheduleUnavailableLocalTitle", {
+            defaultValue: "Schedules don't run in local development",
+        })
+        : t("jobs.scheduleUnavailableTitle", {
+            defaultValue: "Schedules won't run in this deploy",
+        });
+    const detail = status.reason === "disabled-by-env"
+        ? t("jobs.scheduleUnavailableDisabled", {
+            defaultValue: "This app was built with recurring jobs turned off, so no scheduled " +
+                "automation will fire. Event-triggered automations and Run now still work.",
+        })
+        : status.reason === "no-platform-scheduler"
+            ? t("jobs.scheduleUnavailableNoScheduler", {
+                defaultValue: "This hosting target has no durable scheduler, so no scheduled automation will fire. Event-triggered automations and Run now still work.",
+            })
+            : t("jobs.scheduleUnavailableLocal", {
+                defaultValue: "Schedules stay off on a dev machine unless you opt in. " +
+                    "Event-triggered automations and Run now still work.",
+            });
+    /**
+     * Recovery steps, collapsed by default: the notice has to say what is wrong
+     * before it says how to change it, and the how is longer than the what. Null
+     * where nothing is actually toggleable — `no-platform-scheduler` means the
+     * host has no scheduler to enable, so an empty disclosure would promise a fix
+     * that does not exist.
+     */
+    const fix = status.reason === "disabled-by-env"
+        ? t("jobs.scheduleUnavailableDisabledFix", {
+            defaultValue: "To enable recurring jobs, set AGENT_NATIVE_DISABLE_RECURRING_JOBS=false in the build environment.",
+        })
+        : status.reason === "local-development"
+            ? t("jobs.scheduleUnavailableLocalFix", {
+                defaultValue: "Set AGENT_NATIVE_ENABLE_LOCAL_RECURRING_JOBS=true to run " +
+                    "schedules on this machine.",
+            })
+            : null;
+    return (_jsxs("div", { role: "status", "data-testid": "scheduled-trigger-notice", "data-reason": status.reason, className: `${shell} border-amber-500/40 bg-amber-500/10`, children: [_jsx(IconAlertTriangle, { className: "mt-px size-4 shrink-0 text-amber-600 dark:text-amber-400" }), _jsxs("div", { className: "min-w-0", children: [_jsx("p", { className: "text-xs font-medium text-amber-700 dark:text-amber-300", children: headline }), _jsx("p", { className: "mt-0.5 text-[11px] leading-4 text-amber-700/90 dark:text-amber-300/90", children: detail }), fix ? (_jsxs("details", { className: "group mt-1", children: [_jsxs("summary", { className: "-ml-1.5 inline-flex w-fit cursor-pointer select-none list-none items-center gap-1 rounded-md px-1.5 py-1 text-[11px] font-medium text-amber-700 transition-colors hover:bg-amber-500/15 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-amber-500/40 dark:text-amber-300 dark:hover:bg-amber-400/15 [&::-webkit-details-marker]:hidden", children: [_jsx(IconChevronRight, { className: "size-3 shrink-0 transition-transform duration-150 group-open:rotate-90" }), _jsx("span", { className: "group-open:hidden", children: t("jobs.scheduleUnavailableFixLabel", {
+                                            defaultValue: "Show more",
+                                        }) }), _jsx("span", { className: "hidden group-open:inline", children: t("jobs.scheduleUnavailableFixLabelOpen", {
+                                            defaultValue: "Show less",
+                                        }) })] }), _jsx("p", { className: "mt-1 whitespace-pre-line text-[11px] leading-4 text-amber-700/90 dark:text-amber-300/90", children: fix })] })) : null] })] }));
+}

package/dist/client/agent-page/scheduled-trigger-state.d.ts

@@ -0,0 +1,28 @@
+import type { ScheduledTriggerStatus } from "../../jobs/actions/get-scheduled-trigger-status.js";
+export type { ScheduledTriggerStatus };
+/**
+ * Three-state view of the scheduler status query.
+ *
+ * `unknown` exists so a FAILED check cannot pass for a healthy one. The status
+ * action can 404 on an older deploy, 403 behind an auth boundary, or fail
+ * discovery — none of which say anything about whether schedules fire, and all
+ * of which read as "fine" under a plain `data?.available !== false`. `loading`
+ * stays separate because it resolves on its own in milliseconds; an error does
+ * not.
+ *
+ * Deliberately kept in its own module, free of the query hook: the pure
+ * state→consequence mapping below is what the UI branches on, and it stays real
+ * in tests that mock the data layer.
+ */
+export type ScheduledTriggerState = {
+    kind: "loading";
+} | {
+    kind: "unknown";
+    error: Error | null;
+} | {
+    kind: "resolved";
+    status: ScheduledTriggerStatus;
+};
+/** Whether a schedule-triggered automation will fire, as far as the UI knows. */
+export type ScheduleFiring = "fires" | "never" | "unknown";
+export declare function scheduleFiringFor(state: ScheduledTriggerState): ScheduleFiring;

package/dist/client/agent-page/scheduled-trigger-state.js

@@ -0,0 +1,10 @@
+export function scheduleFiringFor(state) {
+    if (state.kind === "resolved") {
+        return state.status.available ? "fires" : "never";
+    }
+    // Loading leans optimistic on purpose: accusing a working deploy of being
+    // broken mid-flight is worse than showing the warning a beat late. An errored
+    // check gets no such benefit — it never resolves, so the optimism would be
+    // permanent and would license a confident "Next run" forever.
+    return state.kind === "unknown" ? "unknown" : "fires";
+}

package/dist/client/agent-page/use-jobs.d.ts

@@ -1,3 +1,4 @@
+import type { ScheduledTriggerState, ScheduledTriggerStatus } from "./scheduled-trigger-state.js";
 export type JobsScope = "user" | "org";
 export interface RecurringJob {
     id: string;
@@ -75,6 +76,12 @@ export interface AutomationRun {
     finishedAt: number | null;
     error: string | null;
 }
+export type { ScheduledTriggerState, ScheduledTriggerStatus };
+/**
+ * Deploy-scoped and fixed for the life of the process, so it is cached far
+ * longer than the automation lists.
+ */
+export declare function useScheduledTriggerState(): ScheduledTriggerState;
 export declare function useRecurringJobs(scope: JobsScope): import("@tanstack/react-query").UseQueryResult<NoInfer<RecurringJob[]>, Error>;
 export declare function useAutomations(scope: JobsScope): import("@tanstack/react-query").UseQueryResult<NoInfer<Automation[]>, Error>;
 export declare function useManageRecurringJob(scope: JobsScope): import("@tanstack/react-query").UseMutationResult<{

package/dist/client/agent-page/use-jobs.js

@@ -6,6 +6,20 @@ function recurringParams(scope) {
 function automationParams(scope) {
     return { scope: scope === "org" ? "organization" : "personal" };
 }
+/**
+ * Deploy-scoped and fixed for the life of the process, so it is cached far
+ * longer than the automation lists.
+ */
+export function useScheduledTriggerState() {
+    const query = useActionQuery("get-scheduled-trigger-status", {}, { staleTime: 5 * 60_000 });
+    // Data first: a cached answer with a failing background refetch is still an
+    // answer, and downgrading it to `unknown` would flicker the warning off.
+    if (query.data)
+        return { kind: "resolved", status: query.data };
+    if (query.error)
+        return { kind: "unknown", error: query.error };
+    return { kind: "loading" };
+}
 export function useRecurringJobs(scope) {
     return useActionQuery("list-recurring-jobs", recurringParams(scope), { staleTime: 5_000 });
 }

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/deploy/build.d.ts

@@ -101,6 +101,11 @@ export declare function isDurableBackgroundDeployEnabled(): boolean;
 export declare const NETLIFY_INTEGRATION_RECOVERY_FUNCTION_NAME = "server-integration-recovery";
 export declare function isIntegrationDurableDispatchDeployEnabled(): boolean;
 export declare const NETLIFY_RECURRING_JOBS_FUNCTION_NAME = "agent-native-recurring-jobs";
+/**
+ * Routed through the same resolver that produces the runtime marker, so the gate
+ * that emits the scheduled function and the value the deployed app reports
+ * cannot drift: a build that skips the emit always ships `"disabled"`.
+ */
 export declare function isRecurringJobsDeployEnabled(): boolean;
 /**
  * Keep-warm is opt-in because a once-a-minute wake prevents autosuspend on

package/dist/deploy/build.js

@@ -24,6 +24,7 @@ import { INTEGRATION_RECOVERY_RUNTIME_MARKER, INTEGRATION_RETRY_SWEEP_PATH, INTE
 import { isValidCron } from "../jobs/cron.js";
 import { RECURRING_JOBS_SWEEP_PATH, RECURRING_JOBS_SWEEP_TOKEN_SUBJECT, } from "../jobs/scheduler-dispatch.js";
 import { findWorkspaceRoot as findAgentNativeWorkspaceRoot } from "../scripts/utils.js";
+import { RECURRING_JOBS_BUILD_MARKER_ENV_VAR, resolveRecurringJobsBuildMarker, } from "../server/agent-chat/recurring-jobs-runtime.js";
 import { normalizeAppBasePath } from "../server/app-base-path.js";
 import { DEFAULT_SPECULATION_RULES_PATH, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, SSR_QUERY_CACHE_KEY_HEADER, } from "../shared/cache-control.js";
 import { mcpEmbedStaticAssetRouteRules } from "../shared/mcp-embed-headers.js";
@@ -2407,8 +2408,13 @@ function isTruthyEnv(name) {
 function isDisabledByEnv(name) {
     return isTruthyEnv(name);
 }
+/**
+ * Routed through the same resolver that produces the runtime marker, so the gate
+ * that emits the scheduled function and the value the deployed app reports
+ * cannot drift: a build that skips the emit always ships `"disabled"`.
+ */
 export function isRecurringJobsDeployEnabled() {
-    return !isDisabledByEnv("AGENT_NATIVE_DISABLE_RECURRING_JOBS");
+    return resolveRecurringJobsBuildMarker(process.env) === "enabled";
 }
 /**
  * Keep-warm is opt-in because a once-a-minute wake prevents autosuspend on
@@ -3887,6 +3893,11 @@ export function resolveNitroBuildReplacements(env = process.env, deploymentEnvir
         // well as in the Vite server bundle.
         "process.env.AGENT_NATIVE_RELEASE_MIGRATIONS": JSON.stringify(env.AGENT_NATIVE_RELEASE_MIGRATIONS?.trim() || ""),
         "process.env.AGENT_NATIVE_BUILD_DEPLOY_CONTEXT": JSON.stringify(env.CONTEXT?.trim() || env.NETLIFY_CONTEXT?.trim() || ""),
+        // Whether the recurring-jobs scheduled function exists is decided HERE, by
+        // the build env. `scheduledTriggerAvailability` cannot re-derive it later —
+        // a pipeline that sets the kill switch only for the build leaves no runtime
+        // trace of it — so hand the decision to the runtime explicitly.
+        [`process.env.${RECURRING_JOBS_BUILD_MARKER_ENV_VAR}`]: JSON.stringify(resolveRecurringJobsBuildMarker(env)),
         ...(configuredDeploymentEnvironment
             ? {
                 "process.env.AGENT_NATIVE_DEPLOYMENT_ENVIRONMENT": JSON.stringify(configuredDeploymentEnvironment),

package/dist/framework-tools.js

@@ -126,6 +126,7 @@ export const CORE_ACTION_GROUPS = {
     "manage-recurring-job": "automation",
     "run-automation-now": "automation",
     "list-automation-runs": "automation",
+    "get-scheduled-trigger-status": "automation",
     "list-automations": "automation",
     "manage-automation": "automation",
     "get-usage-alerts": "automation",

package/dist/jobs/actions/get-scheduled-trigger-status.d.ts

@@ -0,0 +1,13 @@
+import { type ScheduledTriggerAvailability } from "../../server/agent-chat/recurring-jobs-runtime.js";
+export type ScheduledTriggerStatus = ScheduledTriggerAvailability;
+/**
+ * Read surface for "will a schedule-triggered automation actually fire here".
+ *
+ * A separate action rather than a field on `list-automations` / `list-recurring-jobs`:
+ * both of those return bare arrays that several callers map over directly, so
+ * adding a sibling field means an envelope and a breaking change at every call
+ * site. This is deploy-scoped rather than per-automation data anyway — it never
+ * varies by row — so it caches independently and for much longer.
+ */
+declare const _default: import("../../action.js").ActionDefinition<Record<string, never>, ScheduledTriggerAvailability>;
+export default _default;

package/dist/jobs/actions/get-scheduled-trigger-status.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { defineAction } from "../../action.js";
+import { scheduledTriggerAvailability, } from "../../server/agent-chat/recurring-jobs-runtime.js";
+/**
+ * Read surface for "will a schedule-triggered automation actually fire here".
+ *
+ * A separate action rather than a field on `list-automations` / `list-recurring-jobs`:
+ * both of those return bare arrays that several callers map over directly, so
+ * adding a sibling field means an envelope and a breaking change at every call
+ * site. This is deploy-scoped rather than per-automation data anyway — it never
+ * varies by row — so it caches independently and for much longer.
+ */
+export default defineAction({
+    description: "Report whether schedule-triggered automations can actually fire in this deploy, and which driver (or missing driver) decides that. Used by the Agent Automations page to warn that a schedule will never run.",
+    agentTool: false,
+    schema: z.object({}),
+    http: { method: "GET" },
+    readOnly: true,
+    parallelSafe: true,
+    run: async () => scheduledTriggerAvailability(),
+});

package/dist/localization/default-messages.d.ts

@@ -667,6 +667,20 @@ declare const messages: {
         organization: string;
         settingsSummary: string;
         openAutomations: string;
+        nextRunNeverScheduler: string;
+        nextRunSchedulerUnknown: string;
+        nextRunSchedulerUnknownNoDate: string;
+        scheduleUnknownTitle: string;
+        scheduleUnknownDetail: string;
+        scheduleUnavailableTitle: string;
+        scheduleUnavailableLocalTitle: string;
+        scheduleUnavailableDisabled: string;
+        scheduleUnavailableNoScheduler: string;
+        scheduleUnavailableLocal: string;
+        scheduleUnavailableDisabledFix: string;
+        scheduleUnavailableLocalFix: string;
+        scheduleUnavailableFixLabel: string;
+        scheduleUnavailableFixLabelOpen: string;
     };
     share: {
         titleWithResource: string;

package/dist/localization/default-messages.js

@@ -673,6 +673,20 @@ const messages = {
         organization: "Organization",
         settingsSummary: "Manage scheduled and event-triggered agent tasks together from the Automations page.",
         openAutomations: "Open Automations",
+        nextRunNeverScheduler: "Never — no scheduler in this deploy",
+        nextRunSchedulerUnknown: "{{date}} — unconfirmed, the scheduler check failed",
+        nextRunSchedulerUnknownNoDate: "Unknown — the scheduler check failed",
+        scheduleUnknownTitle: "Couldn't check whether schedules run here",
+        scheduleUnknownDetail: "The scheduler status check failed, so the next run times below are unconfirmed. Reload to check again.",
+        scheduleUnavailableTitle: "Schedules won't run in this deploy",
+        scheduleUnavailableLocalTitle: "Schedules don't run in local development",
+        scheduleUnavailableDisabled: "This app was built with recurring jobs turned off, so no scheduled automation will fire. Event-triggered automations and Run now still work.",
+        scheduleUnavailableNoScheduler: "This hosting target has no durable scheduler, so no scheduled automation will fire. Event-triggered automations and Run now still work.",
+        scheduleUnavailableLocal: "Schedules stay off on a dev machine unless you opt in. Event-triggered automations and Run now still work.",
+        scheduleUnavailableDisabledFix: "To enable recurring jobs, set AGENT_NATIVE_DISABLE_RECURRING_JOBS=false in the build environment.",
+        scheduleUnavailableLocalFix: "Set AGENT_NATIVE_ENABLE_LOCAL_RECURRING_JOBS=true to run schedules on this machine.",
+        scheduleUnavailableFixLabel: "Show more",
+        scheduleUnavailableFixLabelOpen: "Show less",
     },
     share: {
         titleWithResource: 'Share "{{title}}"',

package/dist/mcp/screen-memory-stdio.d.ts

@@ -137,13 +137,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
     inputSchema: {
         type: string;
         properties: {
-            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
+            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -159,7 +159,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
     inputSchema: {
         type: string;
         properties: {
-            count?: undefined;
             query: {
                 type: string;
                 description: string;
@@ -175,6 +174,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
+            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -190,7 +190,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
     inputSchema: {
         type: string;
         properties: {
-            count?: undefined;
             minutes: {
                 type: string;
                 description: string;
@@ -200,6 +199,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
+            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -216,7 +216,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
-            count?: undefined;
             query: {
                 type: string;
                 description: string;
@@ -235,6 +234,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             };
             timestamp?: undefined;
             chapterId?: undefined;
+            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -250,7 +250,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
-            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
@@ -264,6 +263,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
                 description: string;
             };
             chapterId?: undefined;
+            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             includeMicrophone?: undefined;
@@ -314,13 +314,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
-            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
+            count?: undefined;
             startAt: {
                 type: string;
                 description: string;
@@ -349,13 +349,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
-            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
+            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;

package/dist/notifications/routes.d.ts

@@ -13,13 +13,13 @@
 export declare function createNotificationsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<"" | import("./types.js").Notification[] | {
     count: number;
     updated?: undefined;
-    error?: undefined;
     ok?: undefined;
+    error?: undefined;
 } | {
     count?: undefined;
     updated: number;
-    error?: undefined;
     ok?: undefined;
+    error?: undefined;
 } | {
     count?: undefined;
     updated?: undefined;
@@ -28,6 +28,6 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
 } | {
     count?: undefined;
     updated?: undefined;
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;

package/dist/observability/routes.d.ts

@@ -41,16 +41,16 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
-    error?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     id?: undefined;
+    error?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     summary?: undefined;
     spans?: undefined;
     id: string;
+    error?: undefined;
     ok?: undefined;
 } | {
     summary?: undefined;
@@ -59,9 +59,9 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     error: any;
     ok?: undefined;
 } | {
-    error?: undefined;
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
+    error?: undefined;
     ok: boolean;
 }>>;

package/dist/provider-api/actions/custom-provider-registration.d.ts

@@ -94,28 +94,28 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     message?: undefined;
 } | {
     id?: undefined;
-    count?: undefined;
     deleted?: undefined;
     providers?: undefined;
+    count?: undefined;
     found: boolean;
     provider: import("../custom-registry.js").CustomProviderConfig;
     registered?: undefined;
     label?: undefined;
     message?: undefined;
 } | {
-    count?: undefined;
     provider?: undefined;
     deleted?: undefined;
     providers?: undefined;
+    count?: undefined;
     found: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
     message?: undefined;
 } | {
-    count?: undefined;
     provider?: undefined;
     providers?: undefined;
+    count?: undefined;
     found?: undefined;
     deleted: boolean;
     id: string;
@@ -123,10 +123,10 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     label?: undefined;
     message?: undefined;
 } | {
-    count?: undefined;
     provider?: undefined;
     deleted?: undefined;
     providers?: undefined;
+    count?: undefined;
     found?: undefined;
     registered: boolean;
     id: string;

package/dist/provider-api/actions/provider-api.d.ts

@@ -311,9 +311,9 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         notes?: string | undefined;
         scope?: "org" | "user" | undefined;
     }, {
-        message?: undefined;
-        deleted?: undefined;
         id?: undefined;
+        provider?: undefined;
+        deleted?: undefined;
         providers: {
             id: string;
             label: string;
@@ -324,45 +324,45 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
             updatedAt: number;
         }[];
         count: number;
-        provider?: undefined;
         found?: undefined;
         registered?: undefined;
         label?: undefined;
-    } | {
         message?: undefined;
-        deleted?: undefined;
+    } | {
+        count?: undefined;
         id?: undefined;
+        deleted?: undefined;
         providers?: undefined;
-        count?: undefined;
         found: boolean;
         provider: import("../custom-registry.js").CustomProviderConfig;
         registered?: undefined;
         label?: undefined;
-    } | {
         message?: undefined;
-        deleted?: undefined;
-        providers?: undefined;
+    } | {
         count?: undefined;
         provider?: undefined;
+        deleted?: undefined;
+        providers?: undefined;
         found: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
-    } | {
         message?: undefined;
-        providers?: undefined;
+    } | {
         count?: undefined;
         provider?: undefined;
+        providers?: undefined;
         found?: undefined;
         deleted: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
+        message?: undefined;
     } | {
-        deleted?: undefined;
-        providers?: undefined;
         count?: undefined;
         provider?: undefined;
+        deleted?: undefined;
+        providers?: undefined;
         found?: undefined;
         registered: boolean;
         id: string;

package/dist/provider-api/corpus-jobs.d.ts

@@ -73,7 +73,6 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
     offset?: unknown;
     limit?: unknown;
 }, {
-    deleted?: undefined;
     jobs: {
         id: string;
         name: string;
@@ -84,6 +83,7 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
         updatedAt: string;
     }[];
     total: number;
+    deleted?: undefined;
     jobId?: undefined;
 } | {
     jobs?: undefined;
@@ -91,9 +91,9 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
     deleted: boolean;
     jobId: string;
 } | {
-    deleted?: undefined;
     jobs?: undefined;
     total?: undefined;
+    deleted?: undefined;
     jobId?: undefined;
     hits: Record<string, unknown>[];
     offset: number;

package/dist/resources/handlers.d.ts

@@ -51,8 +51,8 @@ export declare function handleDeleteResource(event: any): Promise<{
     error: string;
     ok?: undefined;
 } | {
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>;
 /** POST /_agent-native/resources/upload — upload a file as a resource */
 export declare function handleUploadResource(event: any): Promise<import("./store.js").Resource | {
@@ -73,10 +73,10 @@ export declare function handleUploadResource(event: any): Promise<import("./stor
     runId: string | null;
     expiresAt: number | null;
     metadata: string | null;
+    error?: undefined;
     url: string;
     provider: string;
     storageSetupRequired?: undefined;
-    error?: undefined;
 } | {
     error: string;
     storageSetupRequired: boolean;

package/dist/server/action-discovery.js

@@ -626,6 +626,10 @@ export async function mergeCoreSharingActions(registry) {
             "list-automation-runs",
             () => import("../jobs/actions/list-automation-runs.js"),
         ],
+        [
+            "get-scheduled-trigger-status",
+            () => import("../jobs/actions/get-scheduled-trigger-status.js"),
+        ],
         [
             "list-automations",
             () => import("../triggers/actions/list-automations.js"),

package/dist/server/agent-chat/recurring-jobs-runtime.d.ts

@@ -1,4 +1,4 @@
-type RecurringJobsRuntimeEnvKey = "AGENT_NATIVE_DISABLE_RECURRING_JOBS" | "AGENT_NATIVE_ENABLE_LOCAL_RECURRING_JOBS" | "APP_URL" | "BETTER_AUTH_URL" | "CF_PAGES" | "DEPLOY_URL" | "AWS_EXECUTION_ENV" | "AWS_LAMBDA_FUNCTION_NAME" | "NETLIFY" | "NETLIFY_LOCAL" | "NITRO_PRESET" | "NODE_ENV" | "SITE_ID" | "URL" | "VERCEL" | "VITE_APP_URL" | "VITE_WORKSPACE_GATEWAY_URL" | "WORKSPACE_GATEWAY_URL";
+type RecurringJobsRuntimeEnvKey = "AGENT_NATIVE_BUILD_RECURRING_JOBS" | "AGENT_NATIVE_DISABLE_RECURRING_JOBS" | "AGENT_NATIVE_ENABLE_LOCAL_RECURRING_JOBS" | "APP_URL" | "BETTER_AUTH_URL" | "CF_PAGES" | "DEPLOY_URL" | "AWS_EXECUTION_ENV" | "AWS_LAMBDA_FUNCTION_NAME" | "NETLIFY" | "NETLIFY_LOCAL" | "NITRO_PRESET" | "NODE_ENV" | "SITE_ID" | "URL" | "VERCEL" | "VITE_APP_URL" | "VITE_WORKSPACE_GATEWAY_URL" | "WORKSPACE_GATEWAY_URL";
 type RecurringJobsRuntimeEnv = Partial<Record<RecurringJobsRuntimeEnvKey, string | undefined>>;
 export declare function shouldDisableRecurringJobsRuntime(env?: RecurringJobsRuntimeEnv): boolean;
 /**
@@ -7,4 +7,45 @@ export declare function shouldDisableRecurringJobsRuntime(env?: RecurringJobsRun
  * that timer, which is exactly the failure mode the emitted sweep fixes.
  */
 export declare function isNetlifyRecurringJobsRuntime(env?: RecurringJobsRuntimeEnv): boolean;
+/** What the BUILD decided about recurring jobs, as carried into the runtime. */
+export type RecurringJobsBuildMarker = "enabled" | "disabled";
+/**
+ * Env name the build embeds its recurring-jobs decision under.
+ *
+ * Netlify's scheduled function is emitted — or omitted — while the build runs,
+ * and a deployed serverless runtime never sees the build environment. So the
+ * build has to hand the decision over explicitly; nothing observable at runtime
+ * can reconstruct it. Consumed below as a LITERAL `process.env.<name>` member
+ * expression because that is the only form Vite's `define` and Nitro's
+ * `replace` inline at build time.
+ */
+export declare const RECURRING_JOBS_BUILD_MARKER_ENV_VAR = "AGENT_NATIVE_BUILD_RECURRING_JOBS";
+/**
+ * Build-side resolver: what the build environment decided. Shared with
+ * `isRecurringJobsDeployEnabled` in the deploy build so the gate that emits the
+ * scheduled function and the marker that reports it cannot disagree.
+ */
+export declare function resolveRecurringJobsBuildMarker(env?: RecurringJobsRuntimeEnv): RecurringJobsBuildMarker;
+export type ScheduledTriggerAvailability = {
+    available: true;
+    driver: "netlify-scheduled-function" | "in-process";
+} | {
+    available: false;
+    reason: "disabled-by-env" | "no-platform-scheduler" | "local-development";
+};
+/**
+ * Whether ANY driver will actually fire a schedule-triggered automation in this
+ * deploy. Distinct from `shouldDisableRecurringJobsRuntime`, which answers the
+ * narrower "should THIS process run an in-process timer" and is therefore `true`
+ * on hosted Netlify even though schedules do fire there via the emitted
+ * scheduled function — reporting that value to a user would call the one
+ * working production runtime broken.
+ *
+ * Each branch reads the scope that actually decides its driver. The Netlify
+ * driver is a BUILD artifact, so it is answered by the build marker; every other
+ * driver is an in-process timer started from the RUNTIME env, so it is answered
+ * by the runtime flag. Reading runtime-only platform markers for the Netlify
+ * branch would report `available` off a build that emitted no trigger at all.
+ */
+export declare function scheduledTriggerAvailability(env?: RecurringJobsRuntimeEnv): ScheduledTriggerAvailability;
 export {};

package/dist/server/agent-chat/recurring-jobs-runtime.js

@@ -30,20 +30,27 @@ function isLoopbackAppUrl(value) {
     }
     return false;
 }
-export function shouldDisableRecurringJobsRuntime(env = process.env) {
-    if (isTruthyEnv(env.AGENT_NATIVE_DISABLE_RECURRING_JOBS))
-        return true;
-    // A serverless isolate is not a durable scheduler. Keep this check separate
-    // from the platform-specific scheduler branch below so a new sweep cannot
-    // accidentally start an in-process timer before its platform trigger exists.
-    const isServerlessRuntime = env.NETLIFY_LOCAL !== "true" &&
+/**
+ * A serverless isolate is not a durable scheduler. Shared so
+ * `shouldDisableRecurringJobsRuntime` and `scheduledTriggerAvailability` cannot
+ * drift on what counts as serverless.
+ */
+function isServerlessRecurringJobsRuntime(env) {
+    return (env.NETLIFY_LOCAL !== "true" &&
         (isTruthyEnv(env.NETLIFY) ||
             env.NITRO_PRESET === "netlify" ||
             Boolean(env.AWS_LAMBDA_FUNCTION_NAME) ||
             env.AWS_EXECUTION_ENV?.startsWith("AWS_Lambda") === true ||
             isTruthyEnv(env.CF_PAGES) ||
-            isTruthyEnv(env.VERCEL));
-    if (isServerlessRuntime)
+            isTruthyEnv(env.VERCEL)));
+}
+export function shouldDisableRecurringJobsRuntime(env = process.env) {
+    if (isTruthyEnv(env.AGENT_NATIVE_DISABLE_RECURRING_JOBS))
+        return true;
+    // Keep this check separate from the platform-specific scheduler branch below
+    // so a new sweep cannot accidentally start an in-process timer before its
+    // platform trigger exists.
+    if (isServerlessRecurringJobsRuntime(env))
         return true;
     const isLocalRuntime = env.NODE_ENV === "development" ||
         env.NODE_ENV === "test" ||
@@ -74,3 +81,89 @@ export function isNetlifyRecurringJobsRuntime(env = process.env) {
         return false;
     return Boolean((env.NETLIFY && env.NETLIFY !== "false") || env.SITE_ID);
 }
+/**
+ * Env name the build embeds its recurring-jobs decision under.
+ *
+ * Netlify's scheduled function is emitted — or omitted — while the build runs,
+ * and a deployed serverless runtime never sees the build environment. So the
+ * build has to hand the decision over explicitly; nothing observable at runtime
+ * can reconstruct it. Consumed below as a LITERAL `process.env.<name>` member
+ * expression because that is the only form Vite's `define` and Nitro's
+ * `replace` inline at build time.
+ */
+export const RECURRING_JOBS_BUILD_MARKER_ENV_VAR = "AGENT_NATIVE_BUILD_RECURRING_JOBS";
+/**
+ * Build-side resolver: what the build environment decided. Shared with
+ * `isRecurringJobsDeployEnabled` in the deploy build so the gate that emits the
+ * scheduled function and the marker that reports it cannot disagree.
+ */
+export function resolveRecurringJobsBuildMarker(env = process.env) {
+    return isTruthyEnv(env.AGENT_NATIVE_DISABLE_RECURRING_JOBS)
+        ? "disabled"
+        : "enabled";
+}
+function readRecurringJobsBuildMarker(env) {
+    const raw = env.AGENT_NATIVE_BUILD_RECURRING_JOBS ??
+        // config-ok: this value is INLINED at build time by Vite's `define` /
+        // Nitro's `replace`, which rewrite the literal `process.env.<NAME>` member
+        // expression and nothing else. A declared app-config field is read at
+        // runtime from the deployed environment, which is precisely the scope that
+        // cannot see the build's decision — the bug this marker exists to fix.
+        // Reading through the aliased `env` parameter would also survive the build
+        // unreplaced, so the literal form is load-bearing.
+        process.env.AGENT_NATIVE_BUILD_RECURRING_JOBS;
+    const value = raw?.trim();
+    return value === "enabled" || value === "disabled" ? value : undefined;
+}
+/**
+ * Whether ANY driver will actually fire a schedule-triggered automation in this
+ * deploy. Distinct from `shouldDisableRecurringJobsRuntime`, which answers the
+ * narrower "should THIS process run an in-process timer" and is therefore `true`
+ * on hosted Netlify even though schedules do fire there via the emitted
+ * scheduled function — reporting that value to a user would call the one
+ * working production runtime broken.
+ *
+ * Each branch reads the scope that actually decides its driver. The Netlify
+ * driver is a BUILD artifact, so it is answered by the build marker; every other
+ * driver is an in-process timer started from the RUNTIME env, so it is answered
+ * by the runtime flag. Reading runtime-only platform markers for the Netlify
+ * branch would report `available` off a build that emitted no trigger at all.
+ */
+export function scheduledTriggerAvailability(env = process.env) {
+    const buildMarker = readRecurringJobsBuildMarker(env);
+    // Netlify: the driver IS the emitted scheduled function. It fires on the
+    // platform's clock without consulting the deployed env, and no runtime value
+    // can conjure it back once the build omitted it — so the build marker is the
+    // only honest input here, in both directions.
+    if (isNetlifyRecurringJobsRuntime(env)) {
+        if (buildMarker === "disabled") {
+            return { available: false, reason: "disabled-by-env" };
+        }
+        if (buildMarker === "enabled") {
+            return { available: true, driver: "netlify-scheduled-function" };
+        }
+        // No marker: a build predating it, or a caller passing a synthetic env.
+        // Fall back to the runtime flag, which only agrees with the build when the
+        // pipeline sets the same value in both scopes.
+        return isTruthyEnv(env.AGENT_NATIVE_DISABLE_RECURRING_JOBS)
+            ? { available: false, reason: "disabled-by-env" }
+            : { available: true, driver: "netlify-scheduled-function" };
+    }
+    // Everything below is driven by an in-process timer, and the runtime flag is
+    // what `shouldDisableRecurringJobsRuntime` reads before starting it. A build
+    // marker cannot speak for this branch: a build with recurring jobs turned off
+    // still starts the timer if the deployed env does not repeat the switch.
+    if (isTruthyEnv(env.AGENT_NATIVE_DISABLE_RECURRING_JOBS)) {
+        return { available: false, reason: "disabled-by-env" };
+    }
+    // Every other serverless host: the build emits a scheduled trigger only for
+    // Netlify, and a frozen isolate cannot hold a timer.
+    if (isServerlessRecurringJobsRuntime(env)) {
+        return { available: false, reason: "no-platform-scheduler" };
+    }
+    // Long-lived host. Whatever is left of the runtime gate here is the
+    // local/loopback branch, which needs AGENT_NATIVE_ENABLE_LOCAL_RECURRING_JOBS.
+    return shouldDisableRecurringJobsRuntime(env)
+        ? { available: false, reason: "local-development" }
+        : { available: true, driver: "in-process" };
+}

package/dist/server/agent-chat-plugin.d.ts

@@ -9,7 +9,7 @@ import { _agentChatPromptSectionsForTests } from "./agent-chat/framework-prompts
 import { type AgentChatPluginOptions, type NitroPluginDef } from "./agent-chat/plugin-options.js";
 import { finalizeClaimedAgentChatProcessRunFailure } from "./agent-chat/process-run-failure.js";
 import { loadResourcesForPrompt } from "./agent-chat/prompt-resources.js";
-import { isNetlifyRecurringJobsRuntime, shouldDisableRecurringJobsRuntime } from "./agent-chat/recurring-jobs-runtime.js";
+import { isNetlifyRecurringJobsRuntime, resolveRecurringJobsBuildMarker, scheduledTriggerAvailability, shouldDisableRecurringJobsRuntime } from "./agent-chat/recurring-jobs-runtime.js";
 import { shouldBlockInProductCodeEditingSurface } from "./agent-chat/request-surface.js";
 import { loadRunCodeToolEntries } from "./agent-chat/run-code-tools.js";
 export { loadResourcesForPrompt };
@@ -34,6 +34,8 @@ export { DEFAULT_DELEGATED_MAX_ITERATIONS, DEFAULT_DELEGATED_MAX_RUN_INPUT_TOKEN
 export { shouldBlockInProductCodeEditingSurface };
 export { loadRunCodeToolEntries };
 export { isNetlifyRecurringJobsRuntime };
+export { resolveRecurringJobsBuildMarker };
+export { scheduledTriggerAvailability };
 export { shouldDisableRecurringJobsRuntime };
 export { finalizeClaimedAgentChatProcessRunFailure };
 export declare function resolveInteractiveAgentRunOptions(options?: Pick<AgentChatPluginOptions, "runSoftTimeoutMs" | "runNoProgressTimeoutMs" | "durableBackgroundRuns">): {

package/dist/server/agent-chat-plugin.js

@@ -120,7 +120,7 @@ import { resolveAgentChatMcpOptions } from "./agent-chat/mcp-options.js";
 import { resolveA2AAgentDelegationEnabled, } from "./agent-chat/plugin-options.js";
 import { finalizeClaimedAgentChatProcessRunFailure } from "./agent-chat/process-run-failure.js";
 import { loadResourcesForPrompt, promptResourceManifestSections, resourceScopeForOwner, } from "./agent-chat/prompt-resources.js";
-import { isNetlifyRecurringJobsRuntime, shouldDisableRecurringJobsRuntime, } from "./agent-chat/recurring-jobs-runtime.js";
+import { isNetlifyRecurringJobsRuntime, resolveRecurringJobsBuildMarker, scheduledTriggerAvailability, shouldDisableRecurringJobsRuntime, } from "./agent-chat/recurring-jobs-runtime.js";
 import { isLocalhost, shouldBlockInProductCodeEditingSurface, } from "./agent-chat/request-surface.js";
 import { loadRunCodeToolEntries } from "./agent-chat/run-code-tools.js";
 import { createAgentEngineScriptEntries, createAgentLoopSettingsScriptEntries, createCallAgentScriptEntry, createChatScriptEntries, createDbScriptEntries, createDocsScriptEntries, createResourceScriptEntries, } from "./agent-chat/script-entries.js";
@@ -147,6 +147,8 @@ export { DEFAULT_DELEGATED_MAX_ITERATIONS, DEFAULT_DELEGATED_MAX_RUN_INPUT_TOKEN
 export { shouldBlockInProductCodeEditingSurface };
 export { loadRunCodeToolEntries };
 export { isNetlifyRecurringJobsRuntime };
+export { resolveRecurringJobsBuildMarker };
+export { scheduledTriggerAvailability };
 export { shouldDisableRecurringJobsRuntime };
 export { finalizeClaimedAgentChatProcessRunFailure };
 export function resolveInteractiveAgentRunOptions(options) {

package/dist/server/agent-engine-api-key-route.d.ts

@@ -27,10 +27,10 @@ export declare function resolveAgentEngineApiKeyWriteTarget(event: H3Event, scop
 export declare function createAgentEngineApiKeyHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: any;
 } | {
-    error?: undefined;
     ok: boolean;
     key: string;
     baseUrlKey?: string;
     scope: AgentEngineApiKeyScope;
+    error?: undefined;
 }>>;
 export {};

package/dist/server/realtime-token.d.ts

@@ -26,8 +26,8 @@ export declare function createRealtimeTokenHandler(): import("h3").EventHandlerW
     expiresAt?: undefined;
     ttlSeconds?: undefined;
 } | {
-    error?: undefined;
     token: string;
     expiresAt: string;
     ttlSeconds: number;
+    error?: undefined;
 }>>;

package/dist/server/transcribe-voice.d.ts

@@ -20,6 +20,6 @@ export declare function createTranscribeVoiceHandler(): import("h3").EventHandle
     error: string;
     text?: undefined;
 } | {
-    error?: undefined;
     text: string;
+    error?: undefined;
 }>>;

package/dist/vite/client.js

@@ -10,6 +10,7 @@ import { getViteDevRecoveryScript } from "../client/vite-dev-recovery-script.js"
 import { inferAgentNativeDeploymentEnvironment, mergeAgentNativeConfigs, readAgentNativeConfigEnv, resolveAgentNativeConfig, } from "../config.js";
 import { writeAgentNativeNitroPresetMarker } from "../deploy/nitro-preset.js";
 import { findWorkspaceRoot } from "../scripts/utils.js";
+import { RECURRING_JOBS_BUILD_MARKER_ENV_VAR, resolveRecurringJobsBuildMarker, } from "../server/agent-chat/recurring-jobs-runtime.js";
 import { verifyEmbedSessionToken } from "../server/embed-session.js";
 import { EMBED_SESSION_COOKIE, EMBED_TOKEN_QUERY_PARAM, MCP_APP_CHAT_BRIDGE_QUERY_PARAM, } from "../shared/embed-auth.js";
 import { isMcpEmbedCorsOrigin, MCP_EMBED_CORS_ALLOW_HEADERS, MCP_EMBED_STATIC_ASSET_HEADERS, mcpEmbedStaticAssetRouteRules, shouldAllowMcpEmbedCredentials, } from "../shared/mcp-embed-headers.js";
@@ -2561,6 +2562,10 @@ function createNitroDevPlugin(options, appBasePath) {
             // injected into deployed Functions. Nitro is a separate server build,
             // so it needs the release ownership decision in its own replacement map.
             "process.env.AGENT_NATIVE_RELEASE_MIGRATIONS": JSON.stringify(process.env.AGENT_NATIVE_RELEASE_MIGRATIONS?.trim() || ""),
+            // Same reason as the release owner above: the recurring-jobs decision
+            // belongs to the build env, and Nitro is a separate server build with its
+            // own replacement map.
+            [`process.env.${RECURRING_JOBS_BUILD_MARKER_ENV_VAR}`]: JSON.stringify(resolveRecurringJobsBuildMarker(process.env)),
         },
         // Never auto-load test files as server handlers/plugins/middleware.
         // Nitro scans server/{plugins,middleware,routes,api}/*; a co-located
@@ -2913,6 +2918,11 @@ function createAgentNativeConfig(options = {}, command, userConfig = {}, mode =
             // netlify.toml environment is available to the build but not injected
             // into deployed Functions, so embed the decision in the server bundle.
             "process.env.AGENT_NATIVE_RELEASE_MIGRATIONS": JSON.stringify(process.env.AGENT_NATIVE_RELEASE_MIGRATIONS?.trim() || ""),
+            // Recurring jobs are turned off (and their platform scheduled trigger
+            // omitted) by the BUILD environment, which a deployed serverless runtime
+            // never sees. Embed the decision so the Automations page reports what
+            // will actually fire instead of inferring it from runtime-only markers.
+            [`process.env.${RECURRING_JOBS_BUILD_MARKER_ENV_VAR}`]: JSON.stringify(resolveRecurringJobsBuildMarker(process.env)),
             ...(resolvedAppConfig.deployment?.environment
                 ? {
                     "process.env.AGENT_NATIVE_DEPLOYMENT_ENVIRONMENT": JSON.stringify(resolvedAppConfig.deployment.environment),

package/docs/content/recurring-jobs.mdx

@@ -233,6 +233,12 @@ The scheduler is a framework plugin (the internal `processRecurringJobs()` routi
 
 </Callout>
 
+<Callout id="doc-block-rj3" tone="warning">
+
+**`AGENT_NATIVE_DISABLE_RECURRING_JOBS` is read in two scopes.** In the **build** environment it decides whether the platform's scheduled trigger is emitted at all — on Netlify that emitted function is the only durable driver, so a build with the switch on ships an app where no schedule can fire, whatever the deployed environment says. In the **runtime** environment it gates the in-process `setInterval` loop. Set it in the build environment to turn recurring jobs off for a deploy; the build records its decision so the **Automations** page can say schedules will never run instead of showing a next-run date nothing will honour.
+
+</Callout>
+
 ## Debugging a job {#debugging}
 
 - Open the automation's details in **Automations**, or inspect

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.0.0-beta-20260820214042",
+  "version": "0.0.0-beta-20260820220930",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -427,8 +427,8 @@
     "y-protocols": "^1.0.7",
     "yjs": "^13.6.32",
     "zod": "^4.3.6",
-    "@agent-native/toolkit": "^0.16.9",
-    "@agent-native/recap-cli": "0.5.6"
+    "@agent-native/recap-cli": "0.0.0-beta-20260820220930",
+    "@agent-native/toolkit": "^0.16.9"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^3.0.71",