@agent-native/core 0.141.2 → 0.141.4

package/dist/email-catalog/schema.d.ts

@@ -0,0 +1,231 @@
+/**
+ * Drizzle schema for the transactional email send log.
+ *
+ * One row per `sendEmail` attempt, written by the transport itself so every
+ * send is recorded regardless of which app or code path triggered it. This is
+ * the durable record of "did we send it": the provider's own activity feed ages
+ * out (SendGrid keeps 3 days without the extended-retention add-on), so send
+ * counts and last-sent must not depend on it.
+ *
+ * Engagement (opens, clicks, bounces) is deliberately NOT stored here. Only the
+ * provider knows it, and mirroring it would go stale the moment a recipient
+ * opens an old message. Dispatch reads engagement live from the provider and
+ * joins on `template_id`.
+ */
+export declare const emailLog: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "email_log";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "email_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        orgId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "org_id";
+            tableName: "email_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        templateId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "template_id";
+            tableName: "email_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        app: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "app";
+            tableName: "email_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        recipient: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "recipient";
+            tableName: "email_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        sender: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "sender";
+            tableName: "email_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        subject: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "subject";
+            tableName: "email_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "status";
+            tableName: "email_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: "failed" | "sent";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["sent", "failed"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        error: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "error";
+            tableName: "email_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        provider: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "provider";
+            tableName: "email_log";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "email_log";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'sqlite';
+}>;
+export declare const EMAIL_LOG_CREATE_SQL = "CREATE TABLE IF NOT EXISTS email_log (\n  id TEXT PRIMARY KEY,\n  org_id TEXT,\n  template_id TEXT,\n  app TEXT,\n  recipient TEXT NOT NULL,\n  sender TEXT NOT NULL,\n  subject TEXT NOT NULL,\n  status TEXT NOT NULL,\n  error TEXT,\n  provider TEXT NOT NULL,\n  created_at INTEGER NOT NULL\n)";
+export declare const EMAIL_LOG_TEMPLATE_INDEX_SQL = "CREATE INDEX IF NOT EXISTS email_log_template_created_idx\n  ON email_log (template_id, created_at)";
+export declare const EMAIL_LOG_ORG_APP_INDEX_SQL = "CREATE INDEX IF NOT EXISTS email_log_org_app_created_idx\n  ON email_log (org_id, app, created_at)";

package/dist/email-catalog/schema.js

@@ -0,0 +1,53 @@
+/**
+ * Drizzle schema for the transactional email send log.
+ *
+ * One row per `sendEmail` attempt, written by the transport itself so every
+ * send is recorded regardless of which app or code path triggered it. This is
+ * the durable record of "did we send it": the provider's own activity feed ages
+ * out (SendGrid keeps 3 days without the extended-retention add-on), so send
+ * counts and last-sent must not depend on it.
+ *
+ * Engagement (opens, clicks, bounces) is deliberately NOT stored here. Only the
+ * provider knows it, and mirroring it would go stale the moment a recipient
+ * opens an old message. Dispatch reads engagement live from the provider and
+ * joins on `template_id`.
+ */
+import { table, text, integer } from "../db/schema.js";
+export const emailLog = table("email_log", {
+    id: text("id").primaryKey(),
+    /** Organization that owns the send. Legacy rows without this are unreadable. */
+    orgId: text("org_id"),
+    /** Registered transactional email id, e.g. "calendar.booking-confirmed". */
+    templateId: text("template_id"),
+    /** App slug that sent it. */
+    app: text("app"),
+    /** Recipient address. */
+    recipient: text("recipient").notNull(),
+    /** Resolved From address, after app-sender branding is applied. */
+    sender: text("sender").notNull(),
+    subject: text("subject").notNull(),
+    /** "sent" once the provider accepted it, or "failed". Never optimistic. */
+    status: text("status", { enum: ["sent", "failed"] }).notNull(),
+    /** Provider error text when status is "failed". */
+    error: text("error"),
+    /** "resend" | "sendgrid" | "dev". */
+    provider: text("provider").notNull(),
+    createdAt: integer("created_at").notNull(),
+});
+export const EMAIL_LOG_CREATE_SQL = `CREATE TABLE IF NOT EXISTS email_log (
+  id TEXT PRIMARY KEY,
+  org_id TEXT,
+  template_id TEXT,
+  app TEXT,
+  recipient TEXT NOT NULL,
+  sender TEXT NOT NULL,
+  subject TEXT NOT NULL,
+  status TEXT NOT NULL,
+  error TEXT,
+  provider TEXT NOT NULL,
+  created_at INTEGER NOT NULL
+)`;
+export const EMAIL_LOG_TEMPLATE_INDEX_SQL = `CREATE INDEX IF NOT EXISTS email_log_template_created_idx
+  ON email_log (template_id, created_at)`;
+export const EMAIL_LOG_ORG_APP_INDEX_SQL = `CREATE INDEX IF NOT EXISTS email_log_org_app_created_idx
+  ON email_log (org_id, app, created_at)`;

package/dist/email-catalog/system-emails.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Catalog entries for the framework's own system emails.
+ *
+ * These ship with every app rather than belonging to one, so they register
+ * under the `core` app instead of the running app's slug. Importing this module
+ * performs the registration; `register-system-emails.ts` is the single import
+ * site so the emails appear in every app's catalog without each template
+ * remembering to opt in.
+ */
+export declare const CORE_INVITE_EMAIL_ID = "core.organization-invite";
+export declare const CORE_VERIFY_SIGNUP_EMAIL_ID = "core.verify-signup";
+export declare const CORE_RESET_PASSWORD_EMAIL_ID = "core.reset-password";
+export declare function registerCoreSystemEmails(): void;

package/dist/email-catalog/system-emails.js

@@ -0,0 +1,67 @@
+/**
+ * Catalog entries for the framework's own system emails.
+ *
+ * These ship with every app rather than belonging to one, so they register
+ * under the `core` app instead of the running app's slug. Importing this module
+ * performs the registration; `register-system-emails.ts` is the single import
+ * site so the emails appear in every app's catalog without each template
+ * remembering to opt in.
+ */
+import { renderInviteEmail, renderResetPasswordEmail, renderVerifySignupEmail, } from "../server/email-templates.js";
+import { defineTransactionalEmail } from "./registry.js";
+/** Obviously-fake sample data — these render in a preview pane, never send. */
+const SAMPLE_URL = "https://example.com/accept/sample-token";
+const SAMPLE_EMAIL = "sam.rivera@example.com";
+export const CORE_INVITE_EMAIL_ID = "core.organization-invite";
+export const CORE_VERIFY_SIGNUP_EMAIL_ID = "core.verify-signup";
+export const CORE_RESET_PASSWORD_EMAIL_ID = "core.reset-password";
+let registered = false;
+export function registerCoreSystemEmails() {
+    if (registered)
+        return;
+    registered = true;
+    defineTransactionalEmail({
+        id: CORE_INVITE_EMAIL_ID,
+        app: "core",
+        name: "Organization invitation",
+        trigger: "A member invites someone to their organization from the team settings page.",
+        recipientLabel: "Invited address",
+        recipient: "The address typed into the invite form. One email per invited address.",
+        senderLabel: "Default, app-branded",
+        sender: "The configured EMAIL_FROM. On first-party agent-native.com deployments the display name becomes the app's own, with reply-to agent-native@builder.io.",
+        preview: () => renderInviteEmail({
+            invitee: SAMPLE_EMAIL,
+            orgName: "Northwind Design",
+            acceptUrl: SAMPLE_URL,
+            inviter: "alex.chen@example.com",
+        }),
+    });
+    defineTransactionalEmail({
+        id: CORE_VERIFY_SIGNUP_EMAIL_ID,
+        app: "core",
+        name: "Verify signup",
+        trigger: "A new account is created with email and password, before the account can be used.",
+        recipientLabel: "New account address",
+        recipient: "The address the account was registered with.",
+        senderLabel: "Default, app-branded",
+        sender: "The configured EMAIL_FROM, branded with the app name the signup happened in.",
+        preview: () => renderVerifySignupEmail({
+            email: SAMPLE_EMAIL,
+            verifyUrl: SAMPLE_URL,
+        }),
+    });
+    defineTransactionalEmail({
+        id: CORE_RESET_PASSWORD_EMAIL_ID,
+        app: "core",
+        name: "Reset password",
+        trigger: "A user requests a password reset from the sign-in screen. The link expires after one hour.",
+        recipientLabel: "Account address",
+        recipient: "The account address the reset was requested for, never an address supplied in the request body.",
+        senderLabel: "Default, app-branded",
+        sender: "The configured EMAIL_FROM, branded with the app name the reset was requested from.",
+        preview: () => renderResetPasswordEmail({
+            email: SAMPLE_EMAIL,
+            resetUrl: SAMPLE_URL,
+        }),
+    });
+}

package/dist/jobs/index.d.ts

@@ -1,3 +1,5 @@
 export { nextOccurrence, isValidCron, describeCron } from "./cron.js";
 export { processRecurringJobs, parseJobFrontmatter, buildJobContent, type JobFrontmatter, type SchedulerDeps, } from "./scheduler.js";
+export { getAutomationSchedulerHealth, recordAutomationSchedulerHealth, type AutomationSchedulerHealth, } from "./scheduler-health.js";
+export { RECURRING_JOBS_SWEEP_PATH, RECURRING_JOBS_SWEEP_TOKEN_SUBJECT, } from "./scheduler-dispatch.js";
 export { createJobTools } from "./tools.js";

package/dist/jobs/index.js

@@ -1,3 +1,5 @@
 export { nextOccurrence, isValidCron, describeCron } from "./cron.js";
 export { processRecurringJobs, parseJobFrontmatter, buildJobContent, } from "./scheduler.js";
+export { getAutomationSchedulerHealth, recordAutomationSchedulerHealth, } from "./scheduler-health.js";
+export { RECURRING_JOBS_SWEEP_PATH, RECURRING_JOBS_SWEEP_TOKEN_SUBJECT, } from "./scheduler-dispatch.js";
 export { createJobTools } from "./tools.js";

package/dist/jobs/run-history.js

@@ -1,6 +1,23 @@
 import { randomUUID } from "node:crypto";
+import { z } from "zod";
 import { getDbExec, intType, isPostgres } from "../db/client.js";
 import { ensureColumnExists, ensureIndexExists, ensureTableExists, } from "../db/ddl-guard.js";
+import { emit as emitBusEvent, registerEvent } from "../event-bus/index.js";
+registerEvent({
+    name: "automation.run.finished",
+    description: "Fires after a scheduled or manual automation run records a terminal status.",
+    payloadSchema: z.object({
+        automationRunId: z.string(),
+        owner: z.string(),
+        automation: z.string(),
+        path: z.string(),
+        orgId: z.string().nullable(),
+        runId: z.string().nullable(),
+        threadId: z.string().nullable(),
+        status: z.enum(["success", "error", "interrupted"]),
+        error: z.string().nullable(),
+    }),
+});
 const TABLE = "automation_runs";
 const MAX_ERROR_LENGTH = 500;
 /**
@@ -8,6 +25,7 @@ const MAX_ERROR_LENGTH = 500;
  * (BACKGROUND_RUN_HARD_TIMEOUT_MS). Past this, no run is still alive.
  */
 const RUN_LIVENESS_CEILING_MS = 15 * 60_000;
+const INTERRUPTED_RUN_MESSAGE = "Worker stopped before a terminal result was recorded. The serverless worker may have timed out or been recycled. No delivery was confirmed.";
 // The background worker has a shorter hard timeout than this lease. A worker
 // that dies after claiming can therefore be redelivered without overlapping a
 // still-live execution under normal runtime limits.
@@ -91,7 +109,11 @@ function toRun(row, now) {
         status,
         startedAt,
         finishedAt: row.finished_at == null ? null : Number(row.finished_at),
-        error: row.error == null ? null : String(row.error),
+        error: row.error == null && status === "interrupted"
+            ? INTERRUPTED_RUN_MESSAGE
+            : row.error == null
+                ? null
+                : String(row.error),
     };
 }
 /**
@@ -182,10 +204,35 @@ async function pruneAutomationRuns(owner, automation) {
 }
 export async function finishAutomationRun(id, status, error) {
     await ensureTable();
+    const existing = await getDbExec().execute({
+        sql: `SELECT owner, automation, path, org_id, run_id, thread_id FROM ${TABLE} WHERE id = ? LIMIT 1`,
+        args: [id],
+    });
+    const row = existing.rows?.[0];
     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],
     });
+    if (!row)
+        return;
+    try {
+        emitBusEvent("automation.run.finished", {
+            automationRunId: id,
+            owner: String(row.owner),
+            automation: String(row.automation),
+            path: String(row.path),
+            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,
+            error: error?.slice(0, MAX_ERROR_LENGTH) ?? null,
+        }, { owner: String(row.owner) });
+    }
+    catch (eventError) {
+        // History is the source of truth. A subscriber must never turn a recorded
+        // terminal result back into a failed automation run.
+        console.warn("[automations] terminal-run event delivery failed:", eventError);
+    }
 }
 /**
  * Attach the agent thread once it exists. The thread is created after the run

package/dist/jobs/scheduler-dispatch.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Internal route used by platform schedulers to run one recurring-job sweep.
+ * The route is intentionally narrow: it accepts no job or owner input and
+ * authenticates the platform handoff with the deployment's internal token.
+ */
+export declare const RECURRING_JOBS_SWEEP_PATH = "/_agent-native/jobs/_process-sweep";
+export declare const RECURRING_JOBS_SWEEP_TOKEN_SUBJECT = "agent-native-recurring-jobs-sweep";

package/dist/jobs/scheduler-dispatch.js

@@ -0,0 +1,7 @@
+/**
+ * Internal route used by platform schedulers to run one recurring-job sweep.
+ * The route is intentionally narrow: it accepts no job or owner input and
+ * authenticates the platform handoff with the deployment's internal token.
+ */
+export const RECURRING_JOBS_SWEEP_PATH = "/_agent-native/jobs/_process-sweep";
+export const RECURRING_JOBS_SWEEP_TOKEN_SUBJECT = "agent-native-recurring-jobs-sweep";

package/dist/jobs/scheduler-health.d.ts

@@ -0,0 +1,22 @@
+export interface AutomationSchedulerHealth {
+    appId: string;
+    orgId: string | null;
+    lastCheckedAt: number | null;
+    lastDispatchedAt: number | null;
+    lastError: string | null;
+    runtime: string | null;
+    updatedAt: number | null;
+}
+/** Record the last scheduler tick without making health bookkeeping fatal. */
+export declare function recordAutomationSchedulerHealth(input: {
+    appId?: string;
+    orgId?: string | null;
+    checkedAt?: number;
+    dispatchedAt?: number;
+    error?: string | null;
+    runtime?: string | null;
+}): Promise<void>;
+export declare function getAutomationSchedulerHealth(input?: {
+    appId?: string;
+    orgId?: string | null;
+}): Promise<AutomationSchedulerHealth | null>;

package/dist/jobs/scheduler-health.js

@@ -0,0 +1,172 @@
+import { getDbExec, intType, isPostgres } from "../db/client.js";
+import { ensureColumnExists, ensureIndexExists, ensureTableExists, } from "../db/ddl-guard.js";
+const TABLE = "automation_scheduler_health";
+const DEFAULT_APP_ID = "default";
+const MAX_ERROR_LENGTH = 500;
+function normalizeAppId(appId) {
+    const normalized = appId?.trim();
+    return normalized || DEFAULT_APP_ID;
+}
+function rowIdForScope(appId, orgId) {
+    return `${appId}:${orgId ?? "global"}`;
+}
+let initPromise;
+async function ensureHealthTable() {
+    if (!initPromise) {
+        initPromise = (async () => {
+            const createSql = `
+        CREATE TABLE IF NOT EXISTS ${TABLE} (
+          id TEXT PRIMARY KEY,
+          app_id TEXT NOT NULL DEFAULT 'default',
+          org_id TEXT,
+          last_checked_at ${intType()},
+          last_dispatched_at ${intType()},
+          last_error TEXT,
+          runtime TEXT,
+          updated_at ${intType()} NOT NULL
+        )
+      `;
+            const indexSql = `CREATE INDEX IF NOT EXISTS idx_${TABLE}_updated ON ${TABLE} (updated_at)`;
+            if (isPostgres()) {
+                await ensureTableExists(TABLE, createSql);
+                await ensureColumnExists(TABLE, "app_id", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS app_id TEXT NOT NULL DEFAULT 'default'`);
+                await ensureColumnExists(TABLE, "org_id", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS org_id TEXT`);
+                await ensureColumnExists(TABLE, "last_checked_at", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS last_checked_at ${intType()}`);
+                await ensureColumnExists(TABLE, "last_dispatched_at", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS last_dispatched_at ${intType()}`);
+                await ensureColumnExists(TABLE, "last_error", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS last_error TEXT`);
+                await ensureColumnExists(TABLE, "runtime", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS runtime TEXT`);
+                await ensureColumnExists(TABLE, "updated_at", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS updated_at ${intType()}`);
+                await ensureIndexExists(`idx_${TABLE}_updated`, indexSql);
+                return;
+            }
+            const client = getDbExec();
+            await client.execute(createSql);
+            const { rows } = await client.execute(`PRAGMA table_info("${TABLE}")`);
+            const columns = new Set(rows.map((row) => String(row.name)));
+            for (const [name, definition] of [
+                ["app_id", "TEXT NOT NULL DEFAULT 'default'"],
+                ["org_id", "TEXT"],
+                ["last_checked_at", `${intType()}`],
+                ["last_dispatched_at", `${intType()}`],
+                ["last_error", "TEXT"],
+                ["runtime", "TEXT"],
+                ["updated_at", `${intType()} NOT NULL DEFAULT 0`],
+            ]) {
+                if (columns.has(name))
+                    continue;
+                try {
+                    await client.execute(`ALTER TABLE ${TABLE} ADD COLUMN ${name} ${definition}`);
+                }
+                catch (error) {
+                    const message = String(error?.message ?? error);
+                    if (!/duplicate column name/i.test(message) &&
+                        !/column .* already exists/i.test(message)) {
+                        throw error;
+                    }
+                }
+            }
+            await client.execute(indexSql);
+        })().catch((error) => {
+            initPromise = undefined;
+            throw error;
+        });
+    }
+    return initPromise;
+}
+function fromRow(row) {
+    return {
+        appId: String(row.app_id ?? DEFAULT_APP_ID),
+        orgId: row.org_id == null ? null : String(row.org_id),
+        lastCheckedAt: row.last_checked_at == null ? null : Number(row.last_checked_at),
+        lastDispatchedAt: row.last_dispatched_at == null ? null : Number(row.last_dispatched_at),
+        lastError: row.last_error == null ? null : String(row.last_error),
+        runtime: row.runtime == null ? null : String(row.runtime),
+        updatedAt: row.updated_at == null ? null : Number(row.updated_at),
+    };
+}
+/** Record the last scheduler tick without making health bookkeeping fatal. */
+export async function recordAutomationSchedulerHealth(input) {
+    await ensureHealthTable();
+    const appId = normalizeAppId(input.appId);
+    const orgId = input.orgId ?? null;
+    const rowId = rowIdForScope(appId, orgId);
+    const now = Date.now();
+    const checkedAt = input.checkedAt ?? now;
+    const existing = await getDbExec().execute({
+        sql: `SELECT * FROM ${TABLE} WHERE id = ? LIMIT 1`,
+        args: [rowId],
+    });
+    const row = existing.rows?.[0];
+    if (row) {
+        await getDbExec().execute({
+            sql: `UPDATE ${TABLE}
+            SET last_checked_at = ?,
+                last_dispatched_at = ?,
+                last_error = ?,
+                runtime = ?,
+                updated_at = ?
+            WHERE id = ?`,
+            args: [
+                checkedAt,
+                input.dispatchedAt ?? row.last_dispatched_at ?? null,
+                input.error?.slice(0, MAX_ERROR_LENGTH) ?? null,
+                input.runtime ?? row.runtime ?? null,
+                now,
+                rowId,
+            ],
+        });
+        return;
+    }
+    try {
+        await getDbExec().execute({
+            sql: `INSERT INTO ${TABLE}
+        (id, app_id, org_id, last_checked_at, last_dispatched_at, last_error, runtime, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+            args: [
+                rowId,
+                appId,
+                orgId,
+                checkedAt,
+                input.dispatchedAt ?? null,
+                input.error?.slice(0, MAX_ERROR_LENGTH) ?? null,
+                input.runtime ?? null,
+                now,
+            ],
+        });
+    }
+    catch (error) {
+        // Another serverless isolate may have inserted this scope between the read
+        // and insert. Turn that race into the same update path.
+        const message = String(error?.message ?? error);
+        if (!/unique|duplicate/i.test(message))
+            throw error;
+        await getDbExec().execute({
+            sql: `UPDATE ${TABLE}
+            SET last_checked_at = ?,
+                last_dispatched_at = COALESCE(?, last_dispatched_at),
+                last_error = ?,
+                runtime = ?,
+                updated_at = ?
+            WHERE id = ?`,
+            args: [
+                checkedAt,
+                input.dispatchedAt ?? null,
+                input.error?.slice(0, MAX_ERROR_LENGTH) ?? null,
+                input.runtime ?? null,
+                now,
+                rowId,
+            ],
+        });
+    }
+}
+export async function getAutomationSchedulerHealth(input = {}) {
+    await ensureHealthTable();
+    const appId = normalizeAppId(input.appId);
+    const rowId = rowIdForScope(appId, input.orgId ?? null);
+    const result = await getDbExec().execute({
+        sql: `SELECT * FROM ${TABLE} WHERE id = ? LIMIT 1`,
+        args: [rowId],
+    });
+    const row = result.rows?.[0];
+    return row ? fromRow(row) : null;
+}