@agent-native/core 0.134.1 → 0.135.1

package/corpus/core/src/jobs/run-history.ts

@@ -0,0 +1,242 @@
+import { randomUUID } from "node:crypto";
+
+import { getDbExec, intType, isPostgres } from "../db/client.js";
+import { ensureIndexExists, ensureTableExists } from "../db/ddl-guard.js";
+
+/**
+ * "interrupted" is derived at read time, never stored: a process killed
+ * mid-run cannot write its own outcome, so a row left running long past the
+ * point a run could still be alive is reported as interrupted rather than
+ * shown as permanently in-flight.
+ */
+export type AutomationRunStatus =
+  | "running"
+  | "success"
+  | "error"
+  | "interrupted";
+
+export interface AutomationRun {
+  id: string;
+  owner: string;
+  automation: string;
+  path: string;
+  scope: string | null;
+  orgId: string | null;
+  runId: string | null;
+  threadId: string | null;
+  status: AutomationRunStatus;
+  startedAt: number;
+  finishedAt: number | null;
+  error: string | null;
+}
+
+export interface StartAutomationRunInput {
+  owner: string;
+  automation: string;
+  path: string;
+  scope?: string | null;
+  orgId?: string | null;
+  runId?: string | null;
+  threadId?: string | null;
+}
+
+const TABLE = "automation_runs";
+const MAX_ERROR_LENGTH = 500;
+
+/**
+ * Generous multiple of the runner's own 5 minute hard abort
+ * (BACKGROUND_RUN_HARD_TIMEOUT_MS). Past this, no run is still alive.
+ */
+const RUN_LIVENESS_CEILING_MS = 15 * 60_000;
+
+/** Rows kept per automation, so a per-minute schedule cannot grow forever. */
+const RUNS_RETAINED_PER_AUTOMATION = 50;
+
+let _initPromise: Promise<void> | undefined;
+
+async function ensureTable(): Promise<void> {
+  if (!_initPromise) {
+    _initPromise = (async () => {
+      const client = getDbExec();
+      const createSql = `
+        CREATE TABLE IF NOT EXISTS ${TABLE} (
+          id TEXT PRIMARY KEY,
+          owner TEXT NOT NULL,
+          automation TEXT NOT NULL,
+          path TEXT NOT NULL,
+          scope TEXT,
+          org_id TEXT,
+          run_id TEXT,
+          thread_id TEXT,
+          status TEXT NOT NULL DEFAULT 'running',
+          started_at ${intType()} NOT NULL,
+          finished_at ${intType()},
+          error TEXT
+        )
+      `;
+      const indexSql = `CREATE INDEX IF NOT EXISTS idx_${TABLE}_owner_automation ON ${TABLE} (owner, automation, started_at)`;
+
+      if (isPostgres()) {
+        await ensureTableExists(TABLE, createSql);
+        await ensureIndexExists(`idx_${TABLE}_owner_automation`, indexSql);
+        return;
+      }
+
+      await client.execute(createSql);
+      await client.execute(indexSql);
+    })().catch((err) => {
+      _initPromise = undefined;
+      throw err;
+    });
+  }
+  return _initPromise;
+}
+
+function toRun(row: Record<string, unknown>, now: number): AutomationRun {
+  const stored = String(row.status) as AutomationRunStatus;
+  const startedAt = Number(row.started_at);
+  const status: AutomationRunStatus =
+    stored === "running" && now - startedAt > RUN_LIVENESS_CEILING_MS
+      ? "interrupted"
+      : stored;
+  return {
+    id: String(row.id),
+    owner: String(row.owner),
+    automation: String(row.automation),
+    path: String(row.path),
+    scope: row.scope == null ? null : String(row.scope),
+    orgId: row.org_id == null ? null : String(row.org_id),
+    runId: row.run_id == null ? null : String(row.run_id),
+    threadId: row.thread_id == null ? null : String(row.thread_id),
+    status,
+    startedAt,
+    finishedAt: row.finished_at == null ? null : Number(row.finished_at),
+    error: row.error == null ? null : String(row.error),
+  };
+}
+
+/**
+ * Record that an automation actually began executing. Returns the run id used
+ * to close the record out. Only real executions get a row — a tick that
+ * declined to run the automation must not appear in its history.
+ */
+export async function startAutomationRun(
+  input: StartAutomationRunInput,
+): Promise<string> {
+  await ensureTable();
+  const id = randomUUID();
+  await getDbExec().execute({
+    sql: `INSERT INTO ${TABLE} (id, owner, automation, path, scope, org_id, run_id, thread_id, status, started_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'running', ?)`,
+    args: [
+      id,
+      input.owner,
+      input.automation,
+      input.path,
+      input.scope ?? null,
+      input.orgId ?? null,
+      input.runId ?? null,
+      input.threadId ?? null,
+      Date.now(),
+    ],
+  });
+  await pruneAutomationRuns(input.owner, input.automation);
+  return id;
+}
+
+/**
+ * Drop the oldest rows for one automation once it exceeds the retention cap.
+ *
+ * Pruning on insert keeps the table bounded by the number of automations
+ * rather than by how often they run, and avoids a separate sweeper. The
+ * derived table is aliased because Postgres requires it.
+ */
+async function pruneAutomationRuns(
+  owner: string,
+  automation: string,
+): Promise<void> {
+  await getDbExec().execute({
+    sql: `DELETE FROM ${TABLE}
+          WHERE owner = ? AND automation = ? AND started_at < (
+            SELECT MIN(started_at) FROM (
+              SELECT started_at FROM ${TABLE}
+              WHERE owner = ? AND automation = ?
+              ORDER BY started_at DESC
+              LIMIT ${RUNS_RETAINED_PER_AUTOMATION}
+            ) recent
+          )`,
+    args: [owner, automation, owner, automation],
+  });
+}
+
+export async function finishAutomationRun(
+  id: string,
+  status: Exclude<AutomationRunStatus, "running">,
+  error?: string,
+): Promise<void> {
+  await ensureTable();
+  await getDbExec().execute({
+    sql: `UPDATE ${TABLE} SET status = ?, finished_at = ?, error = ? WHERE id = ?`,
+    args: [status, Date.now(), error?.slice(0, MAX_ERROR_LENGTH) ?? null, id],
+  });
+}
+
+/**
+ * Attach the agent thread once it exists. The thread is created after the run
+ * row so the history survives a crash between the two.
+ */
+export async function attachAutomationRunThread(
+  id: string,
+  threadId: string,
+  runId: string,
+): Promise<void> {
+  await ensureTable();
+  await getDbExec().execute({
+    sql: `UPDATE ${TABLE} SET thread_id = ?, run_id = ? WHERE id = ?`,
+    args: [threadId, runId, id],
+  });
+}
+
+/**
+ * Forget an automation's executions.
+ *
+ * History is keyed by the automation's name, which is reusable: deleting
+ * "digest" and creating a new "digest" would otherwise show the old
+ * definition's runs as the new one's history.
+ */
+export async function deleteAutomationRuns(
+  owner: string,
+  automation: string,
+): Promise<void> {
+  await ensureTable();
+  // Bounded to runs that had already started. Names are reusable, so if a new
+  // automation takes this name and starts running before the cleanup lands,
+  // the cutoff keeps that run's history from being swept up with the old
+  // definition's.
+  const cutoff = Date.now();
+  await getDbExec().execute({
+    sql: `DELETE FROM ${TABLE} WHERE owner = ? AND automation = ? AND started_at <= ?`,
+    args: [owner, automation, cutoff],
+  });
+}
+
+export async function listAutomationRuns(options: {
+  owners: string[];
+  automation: string;
+  limit?: number;
+}): Promise<AutomationRun[]> {
+  await ensureTable();
+  const owners = options.owners.filter(Boolean);
+  if (!owners.length) return [];
+  const limit = Math.min(Math.max(options.limit ?? 20, 1), 100);
+  const placeholders = owners.map(() => "?").join(", ");
+  const result = await getDbExec().execute({
+    sql: `SELECT * FROM ${TABLE} WHERE owner IN (${placeholders}) AND automation = ?
+          ORDER BY started_at DESC LIMIT ${limit}`,
+    args: [...owners, options.automation],
+  });
+  const now = Date.now();
+  return (result.rows ?? []).map((row) =>
+    toRun(row as Record<string, unknown>, now),
+  );
+}

package/corpus/core/src/jobs/scheduler.ts

@@ -1,4 +1,5 @@
 import {
+  resourceGetByPath,
   resourceListAllOwners,
   resourcePut,
   type Resource,
@@ -11,7 +12,12 @@ import {
   type BackgroundAutomationContext,
   type BackgroundAutomationDeps,
 } from "./background-automation-runner.js";
-import { nextOccurrence, isValidCron, describeCron } from "./cron.js";
+import {
+  nextOccurrence,
+  isValidCron,
+  describeCron,
+  effectiveTimezone,
+} from "./cron.js";
 import {
   buildJobResourceContent,
   parseJobResource,
@@ -138,7 +144,7 @@ export async function processRecurringJobs(deps: SchedulerDeps): Promise<void> {
         // Stuck — reset so the next check can re-run it
         meta.lastStatus = "error";
         meta.lastError = "Job timed out or server crashed mid-run";
-        const next = nextOccurrence(meta.schedule, now);
+        const next = nextOccurrence(meta.schedule, now, meta.timezone);
         meta.nextRun = next.toISOString();
         await updateResource(resource, meta, body);
         continue;
@@ -153,7 +159,7 @@ export async function processRecurringJobs(deps: SchedulerDeps): Promise<void> {
         // real next occurrence. Computing from new Date(0) (the epoch) always
         // returns a 1970 date, which is < now, so the job would fire
         // immediately on first sight regardless of its schedule.
-        const next = nextOccurrence(meta.schedule, now);
+        const next = nextOccurrence(meta.schedule, now, meta.timezone);
         meta.nextRun = next.toISOString();
         await updateResource(resource, meta, body);
         continue;
@@ -216,10 +222,16 @@ async function executeJob(
         `User/membership no longer valid — leaving cron entry for admin review.`,
     );
     // Mark as skipped without resetting nextRun so an admin can find it.
-    meta.lastRun = now.toISOString();
+    // `lastRun` is deliberately untouched: the job did not run, and stamping
+    // it here made a permanently blocked job look like it ran every minute.
+    // Re-writing an unchanged resource on every tick also churns the poll
+    // stream, so only persist when the failure state actually changed.
+    const alreadyRecorded =
+      meta.lastStatus === "skipped" && meta.lastError === identity.reason;
+    meta.lastCheck = now.toISOString();
     meta.lastStatus = "skipped";
     meta.lastError = identity.reason;
-    await updateResource(resource, meta, body);
+    if (!alreadyRecorded) await updateResource(resource, meta, body);
     return;
   }
   const jobUserEmail = identity.identity.userEmail;
@@ -263,7 +275,7 @@ async function executeJob(
         automation: jobContext,
         ownerEmail: jobUserEmail,
         orgId: jobOrgId,
-        prompt: `[Recurring Job: ${jobName}]\nSchedule: ${describeCron(meta.schedule)}\n\nExecute the following job instructions:\n\n${body}`,
+        prompt: `[Recurring Job: ${jobName}]\nSchedule: ${describeCron(meta.schedule, effectiveTimezone(meta.timezone))}\n\nExecute the following job instructions:\n\n${body}`,
         threadTitle: `Job: ${jobName} — ${now.toLocaleDateString()}`,
         runIdPrefix: `job-${jobName}`,
         usageLabel: `recurring-job:${jobName}`,
@@ -272,20 +284,21 @@ async function executeJob(
       deps,
     );
 
-    // Compute from completion time so long runs cannot immediately re-fire.
-    meta.lastStatus = "success";
-    meta.nextRun = nextOccurrence(meta.schedule, new Date()).toISOString();
-    await updateResource(resource, meta, body);
-    console.log(
-      `[recurring-jobs] Job "${jobName}" completed. Next run: ${meta.nextRun}`,
-    );
+    await recordExecutionOutcome(resource, {
+      lastRun: meta.lastRun,
+      lastStatus: "success",
+      lastError: undefined,
+    });
+    console.log(`[recurring-jobs] Job "${jobName}" completed.`);
   } catch (err) {
-    meta.lastStatus = "error";
-    meta.lastError =
+    const lastError =
       err instanceof Error ? err.message.slice(0, 200) : "Unknown error";
-    meta.nextRun = nextOccurrence(meta.schedule, new Date()).toISOString();
-    await updateResource(resource, meta, body);
-    console.error(`[recurring-jobs] Job "${jobName}" failed:`, meta.lastError);
+    await recordExecutionOutcome(resource, {
+      lastRun: meta.lastRun,
+      lastStatus: "error",
+      lastError,
+    });
+    console.error(`[recurring-jobs] Job "${jobName}" failed:`, lastError);
   }
 }
 
@@ -297,3 +310,45 @@ async function updateResource(
   const content = buildJobContent(meta, body);
   await resourcePut(resource.owner, resource.path, content);
 }
+
+/** Execution bookkeeping the scheduler owns; the rest belongs to the editor. */
+type ExecutionOutcome = Pick<
+  JobFrontmatter,
+  "lastRun" | "lastCheck" | "lastStatus" | "lastError"
+>;
+
+/**
+ * Persist the result of a run without clobbering a concurrent edit.
+ *
+ * A run holds its `meta` for as long as the job takes, so writing that whole
+ * snapshot back on completion would silently revert a schedule, timezone or
+ * instruction change made while it was running. Only the execution fields are
+ * ours to write, and `nextRun` is recomputed from whatever schedule is stored
+ * now, so an edit mid-run takes effect on the next tick.
+ */
+async function recordExecutionOutcome(
+  resource: Resource,
+  outcome: ExecutionOutcome,
+): Promise<void> {
+  const latest = await resourceGetByPath(resource.owner, resource.path);
+  if (!latest) {
+    // Deleted while it was running. Writing the pre-run snapshot back would
+    // resurrect the automation and schedule it again.
+    console.log(
+      `[recurring-jobs] "${resource.path}" was deleted mid-run; dropping its outcome.`,
+    );
+    return;
+  }
+  const current = parseJobResource(latest.content);
+
+  const meta: JobFrontmatter = { ...current.meta, ...outcome };
+  if (meta.schedule && isValidCron(meta.schedule)) {
+    // Measured from completion so a long run cannot immediately re-fire.
+    meta.nextRun = nextOccurrence(
+      meta.schedule,
+      new Date(),
+      meta.timezone,
+    ).toISOString();
+  }
+  await updateResource(resource, meta, current.body);
+}

package/corpus/core/src/jobs/tools.ts

@@ -1,5 +1,6 @@
 import type { ActionEntry } from "../agent/production-agent.js";
 import { getDbExec } from "../db/client.js";
+import { resolveUserSchedulingTimezone } from "../localization/user-timezone.js";
 import {
   resourcePut,
   resourceGetByPath,
@@ -14,7 +15,13 @@ import {
   getRequestOrgId,
   getIntegrationRequestContext,
 } from "../server/request-context.js";
-import { isValidCron, nextOccurrence, describeCron } from "./cron.js";
+import {
+  isValidCron,
+  nextOccurrence,
+  describeCron,
+  effectiveTimezone,
+  isValidTimezone,
+} from "./cron.js";
 import { classifyJobResource } from "./frontmatter.js";
 import {
   parseJobFrontmatter,
@@ -95,6 +102,7 @@ export async function authorizeJobMutation(
 
 async function runCreate(args: Record<string, any>): Promise<string> {
   const { name, schedule, instructions, scope, runAs, model } = args;
+  const requestedTimezone = args.timezone;
 
   if (!name || !schedule || !instructions) {
     return JSON.stringify({
@@ -118,13 +126,24 @@ async function runCreate(args: Record<string, any>): Promise<string> {
   const owner = scope === "personal" ? getOwner() : getSharedOwner();
   const path = `jobs/${name}.md`;
   const now = new Date();
-  const next = nextOccurrence(schedule, now);
+  // A cron time with no zone silently means the host's zone, which is how an
+  // "8am" job ends up firing at 4am for the person who asked for it.
+  if (requestedTimezone && !isValidTimezone(requestedTimezone)) {
+    return JSON.stringify({
+      error: `Unknown timezone: "${requestedTimezone}". Use an IANA zone such as America/New_York.`,
+    });
+  }
+  const timezone =
+    requestedTimezone ||
+    (await resolveUserSchedulingTimezone(getRequestUserEmail()));
+  const next = nextOccurrence(schedule, now, timezone);
   const integration = getIntegrationRequestContext();
   const channelId = integration?.incoming.platformContext.channelId;
   const threadRef = integration?.incoming.threadRef;
 
   const meta: JobFrontmatter = {
     schedule,
+    timezone,
     enabled: true,
     createdBy: getOwner(),
     orgId: getRequestOrgId() || undefined,
@@ -155,7 +174,8 @@ async function runCreate(args: Record<string, any>): Promise<string> {
     name,
     path,
     schedule,
-    scheduleDescription: describeCron(schedule),
+    timezone,
+    scheduleDescription: describeCron(schedule, timezone),
     nextRun: next.toISOString(),
     scope: scope || "shared",
     ...(mcpTools?.length ? { mcpTools } : {}),
@@ -187,7 +207,10 @@ async function runList(args: Record<string, any>): Promise<string> {
         path: r.path,
         scope: r.owner === sharedOwner ? "shared" : "personal",
         schedule: meta.schedule,
-        scheduleDescription: meta.schedule ? describeCron(meta.schedule) : "",
+        timezone: effectiveTimezone(meta.timezone),
+        scheduleDescription: meta.schedule
+          ? describeCron(meta.schedule, effectiveTimezone(meta.timezone))
+          : "",
         enabled: meta.enabled,
         lastRun: meta.lastRun || null,
         lastStatus: meta.lastStatus || null,
@@ -248,7 +271,23 @@ async function runUpdate(args: Record<string, any>): Promise<string> {
       });
     }
     meta.schedule = schedule;
-    meta.nextRun = nextOccurrence(schedule).toISOString();
+  }
+
+  if (args.timezone !== undefined) {
+    if (!isValidTimezone(args.timezone)) {
+      return JSON.stringify({
+        error: `Unknown timezone: "${args.timezone}".`,
+      });
+    }
+    meta.timezone = args.timezone;
+  }
+
+  if (schedule || args.timezone !== undefined) {
+    meta.nextRun = nextOccurrence(
+      meta.schedule,
+      undefined,
+      meta.timezone,
+    ).toISOString();
   }
 
   if (enabled !== undefined) {
@@ -281,7 +320,11 @@ async function runUpdate(args: Record<string, any>): Promise<string> {
     updated: true,
     name,
     schedule: meta.schedule,
-    scheduleDescription: describeCron(meta.schedule),
+    timezone: effectiveTimezone(meta.timezone),
+    scheduleDescription: describeCron(
+      meta.schedule,
+      effectiveTimezone(meta.timezone),
+    ),
     enabled: meta.enabled,
     nextRun: meta.nextRun,
     mcpTools: meta.mcpTools || [],
@@ -347,6 +390,11 @@ For jobs that use a connected MCP, pass the exact tool names in mcpTools. This b
               description:
                 "Job name (hyphen-case, e.g. 'daily-scorecard-check'). Required for create and update.",
             },
+            timezone: {
+              type: "string",
+              description:
+                "IANA timezone the schedule's clock time is read in, e.g. 'America/New_York'. Optional; defaults to the user's saved scheduling timezone, then the caller's browser zone. Always pass this when the user names a time of day, so '8am' means 8am where they are rather than on the server.",
+            },
             schedule: {
               type: "string",
               description:

package/corpus/core/src/localization/actions/get-localization-preference.ts

@@ -5,7 +5,7 @@ import { getUserSetting } from "../../settings/user-settings.js";
 import {
   LOCALIZATION_SETTING_KEY,
   normalizeLocalizationPreference,
-  type LocalizationPreference,
+  type ResolvedLocalizationPreference,
 } from "../shared.js";
 
 export default defineAction({
@@ -13,7 +13,7 @@ export default defineAction({
     "Get the current user's interface language preference. Returns { locale }, where locale is 'system' or a supported BCP-47 locale.",
   schema: z.object({}),
   http: { method: "GET" },
-  run: async (_args, ctx): Promise<LocalizationPreference> => {
+  run: async (_args, ctx): Promise<ResolvedLocalizationPreference> => {
     if (!ctx?.userEmail) throw new Error("Not authenticated.");
     const stored = await getUserSetting(
       ctx.userEmail,

package/corpus/core/src/localization/actions/set-localization-preference.ts

@@ -1,31 +1,69 @@
 import { z } from "zod";
 
 import { defineAction } from "../../action.js";
-import { putUserSetting } from "../../settings/user-settings.js";
+import {
+  getUserSetting,
+  putUserSetting,
+} from "../../settings/user-settings.js";
 import {
   LOCALIZATION_SETTING_KEY,
   SUPPORTED_LOCALES,
   normalizeLocalePreference,
-  type LocalizationPreference,
+  normalizeLocalizationPreference,
+  normalizeTimezonePreference,
+  type ResolvedLocalizationPreference,
 } from "../shared.js";
 
 export default defineAction({
   description:
-    "Set the current user's interface language preference to 'system' or a supported BCP-47 locale.",
+    "Set the current user's interface language and scheduling timezone. Locale is 'system' or a supported BCP-47 locale; timezone is 'system' or an IANA zone such as America/New_York.",
   schema: z.object({
     locale: z
       .string()
-      .describe("Language preference: 'system' or a supported BCP-47 locale."),
+      .describe("Language preference: 'system' or a supported BCP-47 locale.")
+      .optional(),
+    timezone: z
+      .string()
+      .describe("Scheduling timezone: 'system' or an IANA zone name.")
+      .optional(),
   }),
-  run: async (args, ctx): Promise<LocalizationPreference> => {
+  run: async (args, ctx): Promise<ResolvedLocalizationPreference> => {
     if (!ctx?.userEmail) throw new Error("Not authenticated.");
-    const locale = normalizeLocalePreference(args.locale);
-    if (!locale) {
-      throw new Error(
-        `Unsupported locale. Use system, ${SUPPORTED_LOCALES.join(", ")}.`,
-      );
+
+    // Each field is optional, so merge onto what is stored instead of
+    // writing a partial record that silently resets the other one.
+    const current = normalizeLocalizationPreference(
+      await getUserSetting(ctx.userEmail, LOCALIZATION_SETTING_KEY),
+    );
+
+    let locale = current.locale;
+    if (args.locale !== undefined) {
+      const parsed = normalizeLocalePreference(args.locale);
+      if (!parsed) {
+        throw new Error(
+          `Unsupported locale. Use system, ${SUPPORTED_LOCALES.join(", ")}.`,
+        );
+      }
+      locale = parsed;
     }
-    const value: LocalizationPreference & Record<string, unknown> = { locale };
+
+    let timezone = current.timezone;
+    if (args.timezone !== undefined) {
+      const parsed = normalizeTimezonePreference(args.timezone);
+      // Normalizing an unusable zone to "system" would quietly schedule the
+      // user in the host zone, which is the failure this field exists to fix.
+      if (parsed === "system" && args.timezone.trim() !== "system") {
+        throw new Error(
+          `Unknown timezone "${args.timezone}". Use system or an IANA zone such as America/New_York.`,
+        );
+      }
+      timezone = parsed;
+    }
+
+    const value: ResolvedLocalizationPreference & Record<string, unknown> = {
+      locale,
+      timezone,
+    };
     await putUserSetting(ctx.userEmail, LOCALIZATION_SETTING_KEY, value);
     return value;
   },

package/corpus/core/src/localization/default-messages.ts

@@ -57,6 +57,10 @@ const messages = {
     profileSaved: "Profile updated",
     profileSaveError: "Could not update profile",
     profileMenuItem: "Profile",
+    manageAgentMenuItem: "Manage agent",
+    timezoneLabel: "Timezone",
+    timezoneSystem: "Follow this browser ({{zone}})",
+    timezoneHint: "Used for timestamps and scheduled automations.",
   },
   secrets: {
     scopeLabel: "Scope",
@@ -563,6 +567,7 @@ const messages = {
     systemOrdered: "System · ordered, not evictable",
   },
   jobs: {
+    timezone: "Timezone",
     pageTitle: "Automations",
     pageDescription:
       "Manage agent tasks that run on a schedule or in response to events.",
@@ -582,6 +587,28 @@ const messages = {
     paused: "Paused",
     nextRun: "Next run",
     lastRun: "Last run",
+    lastChecked: "Last checked",
+    lastStatus: "Last status",
+    neverRan: "Never",
+    notSet: "—",
+    status: "Status",
+    trigger: "Trigger",
+    scope: "Scope",
+    createdBy: "Created by",
+    model: "Model",
+    blockedTitle: "This automation is not running",
+    pastRuns: "Past runs",
+    runsLoadError: "Could not load run history.",
+    noRuns:
+      "This automation has not executed yet. Only real executions are recorded here.",
+    edit: "Edit",
+    editScheduleTitle: "Edit schedule — {{name}}",
+    editScheduleDescription:
+      "The clock time below is read in the timezone you pick, so 8:00 means 8:00 there.",
+    cronExpression: "Cron expression",
+    cronFormatHint: "minute hour day-of-month month day-of-week",
+    cronFieldCount: "A cron expression needs exactly 5 fields.",
+    saveSchedule: "Save schedule",
     details: "Details",
     pause: "Pause",
     resume: "Resume",