@agent-native/core 0.145.6 → 0.145.8

package/dist/db/client.js

@@ -765,6 +765,47 @@ export function isServerlessRuntime() {
         !!process.env.LAMBDA_TASK_ROOT ||
         !!process.env.CF_PAGES);
 }
+/**
+ * True for production serverless execution contexts. Netlify also exposes
+ * `NETLIFY=true` in its build environment, so build-time code that owns
+ * migrations must use `withMigrationRuntime()` explicitly.
+ */
+export function isProductionServerlessFunctionRuntime(env = process.env) {
+    if (env.NODE_ENV !== "production" || env.NETLIFY_LOCAL === "true") {
+        return false;
+    }
+    return Boolean(env.NETLIFY === "true" ||
+        env.NETLIFY_FUNCTION_NAME ||
+        env.AWS_LAMBDA_FUNCTION_NAME ||
+        env.AWS_LAMBDA_FUNCTION_VERSION ||
+        env.LAMBDA_TASK_ROOT ||
+        env.AWS_EXECUTION_ENV?.startsWith("AWS_Lambda") === true ||
+        env.VERCEL_FUNCTION_ID ||
+        env.VERCEL_REGION ||
+        env.VERCEL === "1");
+}
+const SCHEMA_MUTATION_STATEMENT = /^\s*(?:CREATE|ALTER|DROP|TRUNCATE|COMMENT|REINDEX|GRANT|REVOKE)\b/i;
+function rawSql(statement) {
+    return typeof statement === "string" ? statement : statement.sql;
+}
+/** True for statements that change database schema or database privileges. */
+export function isSchemaMutationStatement(statement) {
+    return SCHEMA_MUTATION_STATEMENT.test(rawSql(statement));
+}
+/**
+ * Request functions must never be able to prepare or mutate schema. Throwing
+ * here makes an unconverted ensureTable path fail loudly instead of silently
+ * reporting success against a missing table. The release migration wrapper
+ * is the only supported production opt-in.
+ */
+export function assertSchemaMutationAllowed(statement) {
+    const migrationRuntime = globalThis.__AGENT_NATIVE_MIGRATION_RUNTIME__ === true;
+    if (isProductionServerlessFunctionRuntime() &&
+        !migrationRuntime &&
+        isSchemaMutationStatement(statement)) {
+        throw new Error("Schema mutation attempted in a production serverless request. Run migrations in the release job instead.");
+    }
+}
 /**
  * postgres.js pool options tuned per runtime. idle_timeout is shortened on
  * serverless so a thawed-but-idle instance releases its connections quickly.
@@ -774,10 +815,27 @@ export function isServerlessRuntime() {
  * process, not one per consumer. See {@link neonPoolMax} for why the cap must
  * leave room for concurrency.
  */
+/**
+ * Identifies the connection in `pg_stat_activity.application_name`.
+ *
+ * Without it every backend reports `pgbouncer` and a runaway query is
+ * anonymous. A 58 MB `SELECT id, config FROM dashboards` ran 20-wide against
+ * production and could not be traced to a caller: it appears nowhere in the
+ * repo or any built bundle, and `pg_stat_statements` is not installed. This is
+ * the cheapest thing that would have named it.
+ */
+function poolApplicationName() {
+    const site = process.env.SITE_NAME ??
+        process.env.NETLIFY_SITE_NAME ??
+        process.env.AGENT_NATIVE_APP_NAME ??
+        "app";
+    return `agent-native:${site}`.slice(0, 63);
+}
 export function pgPoolOptions(url) {
     const serverless = isServerlessRuntime();
     return {
         onnotice: () => { },
+        connection: { application_name: poolApplicationName() },
         max: serverless ? serverlessPoolMax() : 20,
         idle_timeout: serverless ? 20 : 240,
         max_lifetime: 60 * 30,
@@ -785,6 +843,7 @@ export function pgPoolOptions(url) {
         ...(serverless
             ? {
                 connection: {
+                    application_name: poolApplicationName(),
                     idle_in_transaction_session_timeout: 30_000,
                 },
             }
@@ -1504,7 +1563,36 @@ async function createDbExecInternal(config = {}, trackSingletonResources = false
     };
 }
 export async function createDbExec(config = {}) {
-    return createDbExecInternal(config, false);
+    const exec = await createDbExecInternal(config, false);
+    return guardSchemaMutations(exec);
+}
+function guardSchemaMutations(exec) {
+    const guarded = {
+        async execute(statement) {
+            assertSchemaMutationAllowed(statement);
+            return exec.execute(statement);
+        },
+    };
+    if (exec.atomicBatch) {
+        guarded.atomicBatch = async (statements) => {
+            for (const statement of statements) {
+                assertSchemaMutationAllowed(statement);
+            }
+            return exec.atomicBatch(statements);
+        };
+    }
+    if (exec.transaction) {
+        guarded.transaction = (fn) => exec.transaction((tx) => fn({
+            ...tx,
+            execute: async (statement) => {
+                assertSchemaMutationAllowed(statement);
+                return tx.execute(statement);
+            },
+        }));
+    }
+    if (exec.close)
+        guarded.close = () => exec.close();
+    return guarded;
 }
 async function initClient() {
     if (_exec)
@@ -1561,6 +1649,7 @@ export function getDbExec() {
         return sql;
     }
     async function execAnnotated(s) {
+        assertSchemaMutationAllowed(s);
         try {
             return await _exec.execute(sanitize(s));
         }
@@ -1571,6 +1660,7 @@ export function getDbExec() {
     // Return a proxy that lazy-inits on first call
     const proxy = {
         async execute(sql) {
+            assertSchemaMutationAllowed(sql);
             if (!_initPromise)
                 _initPromise = initClient();
             try {
@@ -1588,11 +1678,19 @@ export function getDbExec() {
             const wrapper = {
                 execute: (s) => execAnnotated(s),
                 atomicBatch: _exec.atomicBatch
-                    ? (statements) => _exec.atomicBatch(statements.map((s) => sanitize(s)))
+                    ? async (statements) => {
+                        for (const statement of statements) {
+                            assertSchemaMutationAllowed(statement);
+                        }
+                        return _exec.atomicBatch(statements.map((s) => sanitize(s)));
+                    }
                     : undefined,
                 transaction: _exec.transaction
                     ? (fn) => _exec.transaction((tx) => fn({
-                        execute: (s) => tx.execute(sanitize(s)),
+                        execute: (s) => {
+                            assertSchemaMutationAllowed(s);
+                            return tx.execute(sanitize(s));
+                        },
                         transaction: tx.transaction,
                     }))
                     : undefined,
@@ -1614,11 +1712,19 @@ export function getDbExec() {
             const wrapper = {
                 execute: (s) => execAnnotated(s),
                 atomicBatch: _exec.atomicBatch
-                    ? (statements) => _exec.atomicBatch(statements.map((s) => sanitize(s)))
+                    ? async (statements) => {
+                        for (const statement of statements) {
+                            assertSchemaMutationAllowed(statement);
+                        }
+                        return _exec.atomicBatch(statements.map((s) => sanitize(s)));
+                    }
                     : undefined,
                 transaction: _exec.transaction
                     ? (innerFn) => _exec.transaction((tx) => innerFn({
-                        execute: (s) => tx.execute(sanitize(s)),
+                        execute: (s) => {
+                            assertSchemaMutationAllowed(s);
+                            return tx.execute(sanitize(s));
+                        },
                         transaction: tx.transaction,
                     }))
                     : undefined,
@@ -1626,7 +1732,10 @@ export function getDbExec() {
             Object.assign(proxy, wrapper);
             if (_exec.transaction) {
                 return _exec.transaction((tx) => fn({
-                    execute: (s) => tx.execute(sanitize(s)),
+                    execute: (s) => {
+                        assertSchemaMutationAllowed(s);
+                        return tx.execute(sanitize(s));
+                    },
                     transaction: tx.transaction,
                 }));
             }
@@ -1636,6 +1745,9 @@ export function getDbExec() {
             return explicitTransaction(wrapper.execute)(fn);
         },
         async atomicBatch(statements) {
+            for (const statement of statements) {
+                assertSchemaMutationAllowed(statement);
+            }
             if (!_initPromise)
                 _initPromise = initClient();
             try {
@@ -1649,7 +1761,12 @@ export function getDbExec() {
             if (!_exec.atomicBatch) {
                 throw new Error("This database does not support atomic batches.");
             }
-            const batch = (items) => _exec.atomicBatch(items.map((item) => sanitize(item)));
+            const batch = async (items) => {
+                for (const item of items) {
+                    assertSchemaMutationAllowed(item);
+                }
+                return _exec.atomicBatch(items.map((item) => sanitize(item)));
+            };
             Object.assign(proxy, { atomicBatch: batch });
             return batch(statements);
         },

package/dist/db/ddl-guard.js

@@ -28,7 +28,7 @@
  * (local dev) there is no such lock problem, so callers keep their existing
  * behaviour there.
  */
-import { isPostgres, getDbExec } from "./client.js";
+import { getDbExec, isPostgres, isProductionServerlessFunctionRuntime, } from "./client.js";
 const PLAIN_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
 /**
  * Skip on-demand schema DDL entirely. For deployments that run real migrations,
@@ -45,6 +45,8 @@ const PLAIN_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
  * down the DDL path this flag exists to avoid.
  */
 function schemaEnsureDisabled() {
+    if (isProductionServerlessFunctionRuntime())
+        return true;
     const raw = process.env.AGENT_NATIVE_SKIP_ENSURE_TABLES?.trim();
     return !!raw && ["1", "true", "yes", "on"].includes(raw.toLowerCase());
 }

package/dist/db/ensure-additive-columns.d.ts

@@ -67,6 +67,8 @@ export interface EnsureAdditiveColumnsOptions {
     logger?: EnsureAdditiveColumnsLogger;
 }
 export interface EnsureAdditiveColumnsResult {
+    /** Whether this invocation actually inspected the live schema. */
+    mode: "checked" | "skipped-serverless";
     /** `"table.column"` entries that were successfully added. */
     applied: string[];
     /** Declared columns that were intentionally left unpatched, with why. */

package/dist/db/ensure-additive-columns.js

@@ -54,7 +54,7 @@
  *   unreadable) must never crash boot — the caller decides whether/how to
  *   surface `errors` in the returned summary.
  */
-import { isPostgres } from "./client.js";
+import { isPostgres, isProductionServerlessFunctionRuntime, } from "./client.js";
 const PLAIN_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const defaultLogger = {
     info: (message) => console.log(message),
@@ -62,7 +62,7 @@ const defaultLogger = {
     error: (message) => console.error(message),
 };
 function emptyResult() {
-    return { applied: [], skipped: [], errors: [] };
+    return { mode: "checked", applied: [], skipped: [], errors: [] };
 }
 /**
  * Resolve `getTableConfig` for the dialect currently in effect. Both
@@ -246,6 +246,9 @@ function describeSchemaDriftError(err) {
  */
 export async function ensureAdditiveColumns(options) {
     const { db, tables, logger = defaultLogger } = options;
+    if (isProductionServerlessFunctionRuntime()) {
+        return { ...emptyResult(), mode: "skipped-serverless" };
+    }
     const result = emptyResult();
     let getTableConfig;
     try {

package/dist/db/index.d.ts

@@ -21,7 +21,7 @@ export declare function createDb(config: DbConfig): Promise<(import("drizzle-orm
 })>;
 export type DrizzleDb = Awaited<ReturnType<typeof createDb>>;
 export { createGetDb } from "./create-get-db.js";
-export { deferMigration, MIGRATION_DEFERRED, runMigrations, type MigrationEntry, type MigrationRunResult, type MigrationSql, } from "./migrations.js";
-export { getDbExec, createDbExec, getDatabaseUrl, getDialect, isLocalDatabase, isPostgres, intType, closeDbExec, type DbExec, type DbExecConfig, type DbExecQuery, type DbExecStatement, type Dialect, } from "./client.js";
+export { deferMigration, MIGRATION_DEFERRED, runMigrations, withMigrationRuntime, type MigrationEntry, type MigrationRunResult, type MigrationSql, } from "./migrations.js";
+export { getDbExec, createDbExec, getDatabaseUrl, getDialect, isLocalDatabase, isPostgres, assertSchemaMutationAllowed, isSchemaMutationStatement, isProductionServerlessFunctionRuntime, intType, closeDbExec, type DbExec, type DbExecConfig, type DbExecQuery, type DbExecStatement, type Dialect, } from "./client.js";
 export { table, text, integer, now } from "./schema.js";
 export { ensureAdditiveColumns, type EnsureAdditiveColumnsOptions, type EnsureAdditiveColumnsResult, type EnsureAdditiveColumnsLogger, } from "./ensure-additive-columns.js";

package/dist/db/index.js

@@ -20,7 +20,7 @@ export async function createDb(config) {
     throw new Error(`Unsupported driver: ${config.driver}`);
 }
 export { createGetDb } from "./create-get-db.js";
-export { deferMigration, MIGRATION_DEFERRED, runMigrations, } from "./migrations.js";
-export { getDbExec, createDbExec, getDatabaseUrl, getDialect, isLocalDatabase, isPostgres, intType, closeDbExec, } from "./client.js";
+export { deferMigration, MIGRATION_DEFERRED, runMigrations, withMigrationRuntime, } from "./migrations.js";
+export { getDbExec, createDbExec, getDatabaseUrl, getDialect, isLocalDatabase, isPostgres, assertSchemaMutationAllowed, isSchemaMutationStatement, isProductionServerlessFunctionRuntime, intType, closeDbExec, } from "./client.js";
 export { table, text, integer, now } from "./schema.js";
 export { ensureAdditiveColumns, } from "./ensure-additive-columns.js";

package/dist/db/migrations.d.ts

@@ -19,6 +19,13 @@ export declare function isDuplicateColumnError(err: unknown): boolean;
  */
 export declare function isPermissionError(err: unknown): boolean;
 export interface RunMigrationsOptions {
+    /**
+     * Run migrations even inside a serverless request runtime. Off by default:
+     * see the guard in {@link runMigrations} for why request-path DDL is what
+     * took analytics down. Only set this when the caller has no scheduled or
+     * background runtime that could migrate instead.
+     */
+    runInServerlessRequest?: boolean;
     /**
      * Name of the migrations bookkeeping table. REQUIRED — there is intentionally
      * no default. Two templates that share a database (e.g. via the same Neon URL)
@@ -85,61 +92,11 @@ export interface MigrationEntry {
     run?: () => Promise<MigrationRunResult>;
 }
 /**
- * Runs a list of migrations against the configured database, gated by a
- * per-table bookkeeping row (`options.table`) so repeated boots only apply
- * new migrations.
- *
- * ## Name-based tracking (why it exists)
- *
- * The legacy gate is purely numeric: `SELECT MAX(version)` from the
- * bookkeeping table, then apply every entry whose `version` is greater. That
- * scheme silently breaks down when **two independent branches each extend the
- * same migration list with different DDL under the same version numbers** —
- * exactly what happened to the analytics template's v75-v83 range. Branch A
- * shipped alert-rule tables as v75-v78; branch B shipped unrelated DDL as its
- * own v75-v83. Whichever branch deployed first recorded "v75..v83 applied"
- * in the bookkeeping table. When the other branch merged and deployed, its
- * migrations at those same version numbers were never applied — `MAX(version)`
- * was already ≥ their version, so the gate treated them as done even though
- * their actual DDL had never run. The result: `analytics_migrations` showed
- * rows for 1..83 with no gaps, yet `analytics_alert_rules`,
- * `analytics_alert_incidents`, and `session_recordings.network_error_count`
- * did not exist in production. Version numbers are not a stable identity —
- * they're just sequence position, and sequence position collides across
- * branches.
- *
- * Name-based tracking fixes this by keying application on a stable, unique
- * **string slug** instead of a position in a shared integer sequence:
- *
- * - Entries with a `name` are recorded in a companion table,
- *   `${table}_named` (`name TEXT PRIMARY KEY`), and APPLY IFF their name is
- *   absent from that table — completely independent of version numbers or
- *   the legacy `MAX(version)` gate. Two branches can both ship a migration
- *   named `"analytics-alert-rules-table"` at version 75, or one at version 75
- *   and the other at version 90 after a rebase — either way it applies
- *   exactly once per database, keyed on the name.
- * - Entries WITHOUT a `name` keep the exact legacy behavior
- *   (`version > MAX(recorded version)`), so nothing changes for existing
- *   unnamed migrations.
- * - Named migrations still execute in list order, interleaved with unnamed
- *   ones exactly as written.
- * - When a named migration's DDL runs, we record BOTH the named row (always)
- *   and — if its `version` is greater than the current legacy max — the
- *   legacy version row too, in the SAME atomic batch/transaction as the DDL.
- *   This keeps the legacy `MAX(version)` gate monotonically advancing for
- *   any unnamed migrations that come after it in the list, while ensuring a
- *   named migration is never "double recorded" in a way that would let it
- *   re-apply.
- * - A duplicate `name` across the migration list throws at startup — that's
- *   a programmer error (copy-paste or merge mistake), not a runtime data
- *   problem, and failing loud beats silently tracking the wrong row.
+ * Run an explicit release-time migration job with migration duty enabled.
  *
- * New migrations should always set a `name`. Legacy unnamed migrations don't
- * need to be renamed retroactively — the two gating strategies coexist in the
- * same list — but if a table is EVER at risk of being shared across parallel
- * branches (any template's own migrations qualify, since branches routinely
- * extend the same list concurrently), giving new entries a name is what makes
- * them immune to the collision class described above.
+ * The flag is process-local and restored even when the job fails, so a build
+ * step can opt in without creating a permanent escape hatch for request code.
  */
+export declare function withMigrationRuntime<T>(run: () => Promise<T>): Promise<T>;
 export declare function runMigrations(migrations: Array<MigrationEntry>, options: RunMigrationsOptions): NitroPluginDef;
 export {};

package/dist/db/migrations.js

@@ -226,6 +226,56 @@ function resolveMigrationSql(sql, pg) {
  * extend the same list concurrently), giving new entries a name is what makes
  * them immune to the collision class described above.
  */
+/**
+ * True in a production serverless runtime that serves user REQUESTS.
+ *
+ * Deliberately mirrors the analytics template's own predicate rather than
+ * importing it: `packages/core/src/db` must not depend on a template, and the
+ * agent/background modules that carry the sibling predicates would introduce a
+ * cycle here.
+ */
+function isServerlessRequestRuntime() {
+    if (process.env.NODE_ENV !== "production")
+        return false;
+    return (process.env.NETLIFY === "true" ||
+        Boolean(process.env.NETLIFY_FUNCTION_NAME) ||
+        Boolean(process.env.AWS_LAMBDA_FUNCTION_NAME) ||
+        Boolean(process.env.LAMBDA_TASK_ROOT) ||
+        process.env.AWS_EXECUTION_ENV?.startsWith("AWS_Lambda") === true ||
+        process.env.VERCEL === "1");
+}
+/**
+ * A runtime that is ALLOWED to migrate: scheduled jobs and durable background
+ * workers, which are off the request path and may take as long as they need.
+ *
+ * Set by whichever runtime claims migration duty. Analytics sets its own
+ * equivalent flag before running the scheduled rollup.
+ */
+function isMigrationAuthorizedRuntime() {
+    return (globalThis.__AGENT_NATIVE_MIGRATION_RUNTIME__ === true);
+}
+/**
+ * Run an explicit release-time migration job with migration duty enabled.
+ *
+ * The flag is process-local and restored even when the job fails, so a build
+ * step can opt in without creating a permanent escape hatch for request code.
+ */
+export async function withMigrationRuntime(run) {
+    const runtime = globalThis;
+    const previous = runtime.__AGENT_NATIVE_MIGRATION_RUNTIME__;
+    runtime.__AGENT_NATIVE_MIGRATION_RUNTIME__ = true;
+    try {
+        return await run();
+    }
+    finally {
+        if (previous === undefined) {
+            delete runtime.__AGENT_NATIVE_MIGRATION_RUNTIME__;
+        }
+        else {
+            runtime.__AGENT_NATIVE_MIGRATION_RUNTIME__ = previous;
+        }
+    }
+}
 export function runMigrations(migrations, options) {
     const table = options?.table;
     if (!table ||
@@ -256,6 +306,26 @@ export function runMigrations(migrations, options) {
         return async () => { };
     const namedTable = `${table}_named`;
     return async () => {
+        // Migrations are schema DDL plus an introspection pass. On serverless
+        // "first touch" is EVERY cold start, so this lands on the critical path of
+        // a user request — measured at ~5.5-8.6s for the version check alone on a
+        // 180-table database, with 4-6 copies running concurrently under load.
+        //
+        // Guarded HERE rather than at each call site on purpose. The analytics
+        // template guarded its own runner in #2708; three core plugins
+        // (org, context-xray, observational-memory) kept calling this unguarded,
+        // so the probe storm survived the fix that was supposed to end it. A
+        // fourth special case would have shipped the same bug a fourth time.
+        //
+        // Schema still has to exist: a scheduled/background runtime sets
+        // `__AGENT_NATIVE_MIGRATION_RUNTIME__`, and `runInServerlessRequest` is
+        // the explicit opt-in for a caller that genuinely cannot defer.
+        if (options?.runInServerlessRequest !== true &&
+            isServerlessRequestRuntime() &&
+            !isMigrationAuthorizedRuntime()) {
+            console.info(`[migrations] Skipping "${table}" migrations in a serverless request runtime`);
+            return;
+        }
         try {
             // Check for Cloudflare D1 binding (only if DATABASE_URL not set)
             const d1 = getDialect() === "d1"

package/dist/jobs/index.d.ts

@@ -3,3 +3,4 @@ export { processRecurringJobs, parseJobFrontmatter, buildJobContent, type JobFro
 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";
+export { AUTOMATION_RUN_MIGRATIONS, runAutomationRunMigrations, } from "./run-history.js";

package/dist/jobs/index.js

@@ -3,3 +3,4 @@ export { processRecurringJobs, parseJobFrontmatter, buildJobContent, } from "./s
 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";
+export { AUTOMATION_RUN_MIGRATIONS, runAutomationRunMigrations, } from "./run-history.js";

package/dist/jobs/run-history.d.ts

@@ -1,3 +1,4 @@
+import { type MigrationEntry } from "../db/migrations.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
@@ -30,6 +31,9 @@ export interface StartAutomationRunInput {
     /** A pre-created row still waiting for its background worker handoff. */
     dispatchPending?: boolean;
 }
+/** Authoritative release-time schema for durable automation history. */
+export declare const AUTOMATION_RUN_MIGRATIONS: MigrationEntry[];
+export declare function runAutomationRunMigrations(nitroApp: unknown): Promise<void>;
 /**
  * Record an automation execution. Manual runs create the row before dispatch,
  * so `dispatchPending` distinguishes that durable handoff from a run that has

package/dist/jobs/run-history.js

@@ -2,6 +2,7 @@ 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 { runMigrations } from "../db/migrations.js";
 import { emit as emitBusEvent, registerEvent } from "../event-bus/index.js";
 registerEvent({
     name: "automation.run.finished",
@@ -32,6 +33,49 @@ const INTERRUPTED_RUN_MESSAGE = "Worker stopped before a terminal result was rec
 const CLAIM_LEASE_MS = RUN_LIVENESS_CEILING_MS;
 /** Rows kept per automation, so a per-minute schedule cannot grow forever. */
 const RUNS_RETAINED_PER_AUTOMATION = 50;
+/** Authoritative release-time schema for durable automation history. */
+export const AUTOMATION_RUN_MIGRATIONS = [
+    {
+        version: 1,
+        name: "automation-runs-table",
+        sql: `
+      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 INTEGER NOT NULL,
+        finished_at INTEGER,
+        error TEXT,
+        claimed_at INTEGER,
+        dispatch_pending INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE INDEX IF NOT EXISTS idx_${TABLE}_owner_automation
+        ON ${TABLE} (owner, automation, started_at)
+    `,
+    },
+    {
+        version: 2,
+        name: "automation-runs-claimed-at",
+        sql: `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS claimed_at INTEGER`,
+    },
+    {
+        version: 3,
+        name: "automation-runs-dispatch-pending",
+        sql: `ALTER TABLE ${TABLE}
+      ADD COLUMN IF NOT EXISTS dispatch_pending INTEGER NOT NULL DEFAULT 0`,
+    },
+];
+export async function runAutomationRunMigrations(nitroApp) {
+    await runMigrations(AUTOMATION_RUN_MIGRATIONS, {
+        table: "_automation_run_migrations",
+    })(nitroApp);
+}
 let _initPromise;
 async function ensureTable() {
     if (!_initPromise) {

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/progress/routes.d.ts

@@ -15,6 +15,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;