@agent-native/core 0.145.7 → 0.146.0

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 7888
+- template files: 7896

package/corpus/templates/analytics/.agents/skills/frontend-design/SKILL.md

@@ -199,7 +199,11 @@ as an operator would use it repeatedly:
 - Use full `Card` composition when the content has a title, description, content, or actions. Do not dump complex cards into a single `CardContent`.
 - Use `ToggleGroup` for small option sets, `Switch` for binary settings, `Checkbox` for multi-select, `RadioGroup` for one-of-many, and `Slider`/inputs for numeric values.
 - For forms, prefer the app's existing shadcn form pattern. If newer `Field`, `FieldGroup`, or `InputGroup` primitives are installed or appropriate to add, use them instead of raw layout divs.
-- Loading states use `Skeleton`, `Progress`, `Spinner`, or the app's existing loading primitives. Empty states should have one clear next action.
+- Page and section data loading uses layout-matching `Skeleton` geometry. Do
+  not show generic "Loading..." text for content loads; reserve `Spinner` for
+  brief mutations, uploads, and progress actions. Use the app's existing
+  loading primitive when it is a genuine design-system adapter. Empty states
+  should have one clear next action.
 
 ## Anti-Patterns
 

package/corpus/templates/analytics/.agents/skills/turn-into-app/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   Turn visible project context, a proven thread, skill, or workflow into a
   runnable Agent-Native app with simple buttons, visible agent steps, preview,
   and deployment handoff. Use when a user invokes `/turn-into-app` or asks to
-  make a workflow into an app.
+  make a workflow into an app, including from Claude or ChatGPT on the web.
 user-invocable: true
 scope: both
 metadata:
@@ -13,9 +13,32 @@ metadata:
 
 # Turn Into App
 
+## Host execution boundary
+
+The build location depends on the host. Treat this as a hard routing rule:
+
+- In Claude Web, ChatGPT Web, or a Claude/ChatGPT Project on the web, you are
+  the source analyst and handoff orchestrator. You must not build the app in
+  the host sandbox. Do not run `npm`, `pnpm`, `npx`, `agent-native create`, or
+  `add-app`; do not edit files, create artifacts, or start a local dev server.
+  After writing the bounded source brief, call the connected Dispatch action
+  `start-workspace-app-creation`. Pass the brief and repeatable workflow in
+  `prompt`, plus the inferred `appId`, `description`, `template`, and selected
+  `resourceIds` when available. This is the Builder handoff.
+- Do not substitute the generic `create_workspace_app` MCP tool in an online
+  host. That tool is a local workspace scaffolder, not the Builder handoff.
+- If `start-workspace-app-creation` is not available or Dispatch is not
+  authenticated, stop with the connector setup needed. Do not fall back to a
+  local build or claim that the app exists.
+- In Claude Code, Codex Code, or another local code-agent runtime with a target
+  workspace, follow the local implementation steps below. The local agent may
+  scaffold, edit, run, and verify the app there.
+
 ## Default behavior
 
-This is an end-to-end build skill, not a request for an app proposal.
+For a local code-agent runtime this is an end-to-end build skill, not a request
+for an app proposal. For an online host, the end-to-end result is a verified
+Builder handoff and the resulting workspace app, not code written in the host.
 
 - With no argument, choose the source in this order: visible project context,
   then the current thread. A fresh Claude or ChatGPT Project is a valid source
@@ -47,9 +70,12 @@ private web access, invent an importer, add fake OAuth, or scrape a logged-in
 page. If the needed context is not visible, ask for an export, transcript, or
 attachment and treat that artifact as imported source material.
 
-Deliver a fresh app in a new directory, implement the repeatable workflow with
-buttons and agent handoffs, start its dev server, verify the main path, and
-continue through build/deployment handoff. Do not stop at a plan.
+For local code-agent runtimes, deliver a fresh app in a new directory,
+implement the repeatable workflow with buttons and agent handoffs, start its dev
+server, verify the main path, and continue through build/deployment handoff. Do
+not stop at a plan. For online hosts, call Dispatch first after the source brief,
+then report the returned Builder branch/path and verify the workspace app through
+Dispatch when it becomes available.
 
 ## Fresh project context mode
 
@@ -190,12 +216,12 @@ Do not use `create` for an existing workspace; it scaffolds a new standalone
 workspace rather than adding an app to the current one.
 
 When the source came from a fresh external Project and the target is a Builder
-workspace, prefer the available Dispatch MCP workspace handoff after writing
-the source brief. Call `start-workspace-app-creation` with a concise prompt,
-the inferred app id, and the brief's repeatable workflow. Pass selected
-workspace resource IDs when they are available, rather than pasting entire
-knowledge files. Continue from the returned workspace path or Builder handoff
-and report the actual verification result.
+workspace, the online host path is mandatory: after writing the source brief,
+call `start-workspace-app-creation` with a concise prompt, the inferred app id,
+and the brief's repeatable workflow. Pass selected workspace resource IDs when
+they are available, rather than pasting entire knowledge files. Continue from
+the returned workspace path or Builder branch handoff and report the actual
+verification result. Do not run the local scaffold commands in this host mode.
 
 Use a first-party template only when it materially fits the workflow. Keep the
 new app independent from the source thread's working tree unless the user

package/corpus/templates/analytics/.agents/skills/turn-into-app/references/fresh-project.md

@@ -51,13 +51,24 @@ also place the skill instructions or this reference in the Project
 instructions/knowledge files. Then add and authenticate the Dispatch MCP
 connector from the packaged `adapters/chatgpt-mcp/connector.json`.
 
+For Claude Web, ChatGPT Web, and their web Projects, the host is an
+orchestrator, not the build environment. After forming the source brief, call
+the Dispatch `start-workspace-app-creation` action so Builder creates the app
+in the connected workspace. Do not use the host's code interpreter, shell,
+artifact editor, `create_workspace_app`, or local `pnpm`/`npm` commands. If the
+handoff action is unavailable, stop and ask the user to authenticate Dispatch;
+do not fall back to a local sandbox build. Claude Code and Codex Code are the
+local-agent exception and may follow the implementation steps in the main
+skill.
+
 In a new Project chat, say:
 
 ```text
 Turn this project into an app. Use the visible Project instructions,
 knowledge files, and any selected successful runs as the source. Create the
-app in the connected Agent-Native workspace, keep the source brief bounded,
-and report the real path and verification result.
+app in the connected Agent-Native workspace through Dispatch and Builder, keep
+the source brief bounded, and report the real Builder branch/path and
+verification result. Do not build it in this chat's sandbox.
 ```
 
 If the host does not show the Project instructions or files to the model, stop

package/corpus/templates/analytics/actions/get-sql-dashboard.ts

@@ -10,8 +10,10 @@ import {
   buildDashboardAgentContext,
   buildDashboardSeedAgentContext,
 } from "../server/lib/agent-readable-resource-context";
+import { repairCanonicalFirstPartyDashboardQueries } from "../server/lib/canonical-first-party-dashboard-repair";
 import { loadDashboardSeed } from "../server/lib/dashboard-seeds";
 import { getDashboard } from "../server/lib/dashboards-store";
+import { FIRST_PARTY_DASHBOARD_ID } from "../server/lib/first-party-metric-catalog";
 
 export default defineAction({
   description:
@@ -64,14 +66,28 @@ export default defineAction({
     if (!dash || dash.kind !== "sql") {
       const seed = loadDashboardSeed(args.id);
       if (seed)
-        return buildDashboardSeedAgentContext(args.id, seed, {
-          includeConfig: args.includeConfig === true,
-        });
+        return buildDashboardSeedAgentContext(
+          args.id,
+          args.id === FIRST_PARTY_DASHBOARD_ID
+            ? repairCanonicalFirstPartyDashboardQueries(seed).config
+            : seed,
+          {
+            includeConfig: args.includeConfig === true,
+          },
+        );
       throw Object.assign(new Error("Dashboard not found"), {
         statusCode: 404,
       });
     }
-    return buildDashboardAgentContext(dash, {
+    const dashboard =
+      args.id === FIRST_PARTY_DASHBOARD_ID
+        ? {
+            ...dash,
+            config: repairCanonicalFirstPartyDashboardQueries(dash.config)
+              .config,
+          }
+        : dash;
+    return buildDashboardAgentContext(dashboard, {
       includeConfig: args.includeConfig === true,
     });
   },

package/corpus/templates/analytics/actions/migrate-first-party-analytics-to-bigquery.ts

@@ -5,10 +5,13 @@ import {
 } from "@agent-native/core/server";
 import { z } from "zod";
 
+import {
+  getFirstPartyAnalyticsBigQueryBackfillJob,
+  queueFirstPartyAnalyticsBigQueryBackfill,
+} from "../server/jobs/analytics-bigquery-backfill.js";
 import { requireAnalyticsAdminContext } from "../server/lib/db-admin-connections.js";
 import {
   assertFirstPartyAnalyticsBigQueryReady,
-  backfillFirstPartyAnalyticsBatch,
   getFirstPartyAnalyticsBackend,
   saveFirstPartyAnalyticsBackend,
 } from "../server/lib/first-party-analytics-backend.js";
@@ -35,18 +38,23 @@ const migrationSchema = z.object({
     .describe(
       "Optional BigQuery table reference as dataset.table or project.dataset.table. The default is <BIGQUERY_PROJECT_ID>.analytics.first_party_analytics_events_raw.",
     ),
-  cursor: z.string().trim().optional(),
-  limit: z.number().int().min(1).max(5_000).optional(),
+  limit: z
+    .number()
+    .int()
+    .min(1)
+    .max(750)
+    .optional()
+    .describe("Optional per-page limit used when mode is prepare."),
   confirm: z.boolean().optional(),
 });
 
 export default defineAction({
   description:
-    "UI-only production migration for the current Analytics organization. Run prepare to validate the configured BigQuery table and enter dual-write mode, call backfill repeatedly with the returned cursor until complete, then call cutover with confirm=true. New /track events stay in Postgres during dual-write, so a BigQuery outage does not silently lose live data. Cutover is the only step that stops analytics event and rollup writes to Postgres; public-key metadata, derived exception issues, and session-replay data remain in the SQL store.",
+    "Production migration for the current Analytics organization. Run prepare to validate the configured BigQuery table, enter dual-write mode, and enqueue a durable single-flight worker. The worker uses bounded pages, a persisted cursor, a lease, and a database-pressure gate; it pauses instead of competing with live traffic. Call status or backfill to inspect progress, then call cutover with confirm=true only after the worker reports completed. New /track events stay in Postgres during dual-write, so a BigQuery outage does not silently lose live data. Cutover is the only step that stops first-party event and rollup writes to Postgres; public-key metadata, derived exception issues, and session-replay data remain in the SQL store.",
   schema: migrationSchema,
   agentTool: false,
   needsApproval: ({ mode }) => mode === "cutover",
-  run: async ({ mode, table, cursor, limit, confirm }) => {
+  run: async ({ mode, table, limit, confirm }) => {
     const scope = await resolveScope();
     const current = await getFirstPartyAnalyticsBackend(scope);
     const configuredTable = table ?? current.table;
@@ -56,27 +64,58 @@ export default defineAction({
         current.sink === "postgres"
           ? null
           : await assertFirstPartyAnalyticsBigQueryReady(current.table);
+      const job =
+        current.sink === "postgres"
+          ? null
+          : await getFirstPartyAnalyticsBigQueryBackfillJob(scope);
       return {
         ...current,
+        backfillCursor:
+          current.sink === "dual"
+            ? (job?.cursor ?? null)
+            : current.backfillCursor,
+        backfillCompleted:
+          current.sink === "dual"
+            ? job?.status === "completed"
+            : current.backfillCompleted,
         ready: Boolean(ready),
         rowCount: ready?.rowCount ?? null,
         table: ready?.table.fullyQualified ?? current.table,
+        job,
       };
     }
 
     if (mode === "prepare") {
+      if (current.sink === "bigquery") {
+        throw new Error(
+          "This organization has already cut over to BigQuery; preparing it again is not supported.",
+        );
+      }
       const ready =
         await assertFirstPartyAnalyticsBigQueryReady(configuredTable);
+      const existingJob =
+        await getFirstPartyAnalyticsBigQueryBackfillJob(scope);
+      if (existingJob && existingJob.table !== ready.table.fullyQualified) {
+        throw new Error(
+          `BigQuery backfill already targets ${existingJob.table}; prepare the existing migration before changing tables.`,
+        );
+      }
       await saveFirstPartyAnalyticsBackend(scope, {
         sink: "dual",
         table: ready.table.fullyQualified,
-        backfillCursor: null,
-        backfillCompleted: false,
+        backfillCursor: existingJob?.cursor ?? null,
+        backfillCompleted: existingJob?.status === "completed",
       });
+      const job = await queueFirstPartyAnalyticsBigQueryBackfill(
+        scope,
+        ready.table.fullyQualified,
+        limit,
+      );
       return {
         sink: "dual" as const,
         table: ready.table.fullyQualified,
         existingBigQueryRows: ready.rowCount,
+        job,
         next: "backfill",
       };
     }
@@ -87,23 +126,18 @@ export default defineAction({
           "Prepare the organization for dual-write before starting the BigQuery backfill.",
         );
       }
-      const result = await backfillFirstPartyAnalyticsBatch(
-        scope,
-        cursor ?? current.backfillCursor ?? null,
-        limit ?? 500,
-        current.table,
-      );
-      await saveFirstPartyAnalyticsBackend(scope, {
-        sink: "dual",
-        table: current.table,
-        backfillCursor: result.nextCursor,
-        backfillCompleted: result.complete,
-      });
+      const job = await getFirstPartyAnalyticsBigQueryBackfillJob(scope);
+      if (!job) {
+        throw new Error(
+          "Prepare the organization before enqueueing the BigQuery backfill.",
+        );
+      }
       return {
-        ...result,
         sink: "dual" as const,
         table: current.table,
-        next: result.complete ? "cutover" : "backfill",
+        job,
+        next: job.status === "completed" ? "cutover" : "backfill",
+        queued: job.status !== "completed",
       };
     }
 
@@ -112,16 +146,17 @@ export default defineAction({
         "Cutover requires confirm=true because it stops first-party event and rollup writes to Postgres for this organization.",
       );
     }
-    if (current.sink !== "dual" || current.backfillCompleted !== true) {
+    const job = await getFirstPartyAnalyticsBigQueryBackfillJob(scope);
+    if (current.sink !== "dual" || job?.status !== "completed") {
       throw new Error(
-        "Complete the dual-write backfill before cutting over to BigQuery.",
+        "Wait for the durable dual-write backfill job to report completed before cutting over to BigQuery.",
       );
     }
     const ready = await assertFirstPartyAnalyticsBigQueryReady(current.table);
     await saveFirstPartyAnalyticsBackend(scope, {
       sink: "bigquery",
       table: ready.table.fullyQualified,
-      backfillCursor: current.backfillCursor,
+      backfillCursor: job.cursor,
       backfillCompleted: true,
     });
     return {

package/corpus/templates/analytics/app/pages/settings/AlertRulesSettingsCard.tsx

@@ -58,6 +58,7 @@ import {
   SelectTrigger,
   SelectValue,
 } from "@/components/ui/select";
+import { Skeleton } from "@/components/ui/skeleton";
 import { Switch } from "@/components/ui/switch";
 import { Textarea } from "@/components/ui/textarea";
 import { cn } from "@/lib/utils";
@@ -503,9 +504,9 @@ export function AlertRulesSettingsCard() {
           {isLoading ? (
             <div className="space-y-2">
               {[0, 1, 2].map((item) => (
-                <div
+                <Skeleton
                   key={item}
-                  className="h-14 rounded-md border border-border bg-muted/30"
+                  className="h-14 w-full rounded-md border border-border bg-muted/30"
                 />
               ))}
             </div>

package/corpus/templates/analytics/changelog/2026-08-07-analytics-migrations-now-use-bounded-pressure-aware-backgrou.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-07
+---
+
+Analytics migrations now use bounded, pressure-aware background jobs

package/corpus/templates/analytics/changelog/2026-08-07-settings-skeleton-placeholders.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-08-07
+---
+
+Settings show stable skeleton placeholders while alert rules load.

package/corpus/templates/analytics/changelog/2026-08-07-template-activity-charts-now-show-only-core-agent-native-app.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-07
+---
+
+Template activity charts now show only core Agent Native apps

package/corpus/templates/analytics/netlify.toml

@@ -4,7 +4,7 @@ ignore = "node ./scripts/netlify-ignore-build.mjs analytics"
 # core explicitly here so a cached Netlify install cannot bundle an older agent
 # loop into Analytics' server functions (including A2A/MCP final-response
 # guards).
-command = "export DATABASE_URL=${NETLIFY_DATABASE_URL:-$DATABASE_URL} && pnpm install && pnpm --filter @agent-native/core build && NITRO_PRESET=netlify pnpm --filter analytics build"
+command = "export DATABASE_URL=${NETLIFY_DATABASE_URL:-$DATABASE_URL} && pnpm install && pnpm --filter @agent-native/core build && NITRO_PRESET=netlify pnpm --filter analytics build && if [ \"${CONTEXT:-}\" = \"production\" ]; then pnpm --filter analytics migrate:production; fi"
 publish = "templates/analytics/dist"
 functions = "templates/analytics/.netlify/functions-internal"
 

package/corpus/templates/analytics/package.json

@@ -10,6 +10,7 @@
     "test": "vitest --run",
     "format.fix": "oxfmt --write .",
     "typecheck": "agent-native typecheck",
+    "migrate:production": "tsx scripts/migrate-production.ts",
     "action": "agent-native action",
     "script": "agent-native script"
   },

package/corpus/templates/analytics/scripts/emit-netlify-dashboard-report-cron.ts

@@ -26,6 +26,10 @@ const ROLLUP_SCHEDULED_NAME = "analytics-rollup-backfill-cron";
 const ROLLUP_WORKER_NAME = "analytics-rollup-backfill-background";
 const ROLLUP_ROUTE_PATH = "/api/analytics-rollups/backfill";
 const ROLLUP_SCHEDULE = "*/15 * * * *";
+const BIGQUERY_SCHEDULED_NAME = "analytics-bigquery-backfill-cron";
+const BIGQUERY_WORKER_NAME = "analytics-bigquery-backfill-background";
+const BIGQUERY_ROUTE_PATH = "/api/analytics-bigquery/backfill";
+const BIGQUERY_SCHEDULE = "* * * * *";
 const RETENTION_SCHEDULED_NAME = "session-replay-retention-cron";
 const RETENTION_WORKER_NAME = "session-replay-retention-sweep-background";
 const RETENTION_ROUTE_PATH = "/api/session-replay/retention";
@@ -499,6 +503,106 @@ export const config = {
   writeFileSync(path.join(dest, `${ROLLUP_WORKER_NAME}.mjs`), source);
 }
 
+function emitBigQueryScheduledTrigger(token: string) {
+  const dest = path.join(FUNCTIONS_DIR, BIGQUERY_SCHEDULED_NAME);
+  rmSync(dest, { recursive: true, force: true });
+  ensureDir(dest);
+
+  const source = `const WORKER_PATH = "/.netlify/functions/${BIGQUERY_WORKER_NAME}";
+const CRON_TOKEN = ${JSON.stringify(token)};
+
+function siteOrigin(request) {
+  const configured = process.env.URL || process.env.DEPLOY_URL;
+  if (configured) return configured;
+  const url = new URL(request.url);
+  return url.origin;
+}
+
+export default async function handler(request) {
+  const url = new URL(WORKER_PATH, siteOrigin(request));
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-agent-native-analytics-bigquery-cron": CRON_TOKEN,
+    },
+    body: JSON.stringify({ scheduled: true }),
+  });
+
+  if (!response.ok && response.status !== 202) {
+    console.error(
+      "[analytics-bigquery-backfill-cron] Background backfill trigger failed:",
+      response.status,
+    );
+  }
+}
+
+export const config = {
+  name: "analytics BigQuery backfill cron trigger",
+  generator: "agent-native analytics build",
+  schedule: ${JSON.stringify(BIGQUERY_SCHEDULE)},
+};
+`;
+
+  writeFileSync(path.join(dest, `${BIGQUERY_SCHEDULED_NAME}.mjs`), source);
+}
+
+function emitBigQueryBackgroundWorker(token: string) {
+  const dest = path.join(FUNCTIONS_DIR, BIGQUERY_WORKER_NAME);
+  rmSync(dest, { recursive: true, force: true });
+  cloneServerBundleForFunction(SERVER_DIR, dest);
+  rmSync(path.join(dest, "server.mjs"), { force: true });
+
+  const source = `globalThis.__AGENT_NATIVE_BACKGROUND_RUNTIME__ = true;
+globalThis.__AGENT_NATIVE_LOW_CONNECTION_BACKGROUND_RUNTIME__ = true;
+globalThis.__AGENT_NATIVE_ANALYTICS_BIGQUERY_BACKFILL_SCHEDULED_RUNTIME__ = true;
+
+const CRON_TOKEN = ${JSON.stringify(token)};
+const ROUTE_PATH = ${JSON.stringify(BIGQUERY_ROUTE_PATH)};
+let cachedHandler;
+
+function timingSafeEquals(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i += 1) {
+    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return diff === 0;
+}
+
+export default async function handler(request, context) {
+  const token = request.headers.get("x-agent-native-analytics-bigquery-cron") || "";
+  if (!timingSafeEquals(token, CRON_TOKEN)) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+
+  cachedHandler ??= (await import("./main.mjs")).default;
+  const url = new URL(request.url);
+  url.pathname = ROUTE_PATH;
+  url.search = "";
+
+  const rewritten = new Request(url.toString(), {
+    method: "POST",
+    headers: new Headers({ "content-type": "application/json" }),
+    body: JSON.stringify({ scheduled: true }),
+  });
+
+  return await cachedHandler(rewritten, context);
+}
+
+export const config = {
+  name: "analytics BigQuery backfill background sweep",
+  generator: "agent-native analytics build",
+  background: true,
+  nodeBundler: "none",
+  includedFiles: ["**"],
+  preferStatic: false,
+};
+`;
+
+  writeFileSync(path.join(dest, `${BIGQUERY_WORKER_NAME}.mjs`), source);
+}
+
 function emitRetentionScheduledTrigger(token: string) {
   const dest = path.join(FUNCTIONS_DIR, RETENTION_SCHEDULED_NAME);
   rmSync(dest, { recursive: true, force: true });
@@ -621,6 +725,7 @@ function main(): void {
   const alertToken = randomBytes(32).toString("hex");
   const uptimeToken = randomBytes(32).toString("hex");
   const rollupToken = randomBytes(32).toString("hex");
+  const bigQueryToken = randomBytes(32).toString("hex");
   const retentionToken = randomBytes(32).toString("hex");
   emitScheduledTrigger(token);
   emitBackgroundWorker(token);
@@ -630,6 +735,8 @@ function main(): void {
   emitUptimeBackgroundWorker(uptimeToken);
   emitRollupScheduledTrigger(rollupToken);
   emitRollupBackgroundWorker(rollupToken);
+  emitBigQueryScheduledTrigger(bigQueryToken);
+  emitBigQueryBackgroundWorker(bigQueryToken);
   emitRetentionScheduledTrigger(retentionToken);
   emitRetentionBackgroundWorker(retentionToken);
   console.log(
@@ -644,6 +751,9 @@ function main(): void {
   console.log(
     `[analytics-rollup-backfill-cron] Emitted Netlify scheduled trigger "${ROLLUP_SCHEDULED_NAME}" (${ROLLUP_SCHEDULE}) and background worker "${ROLLUP_WORKER_NAME}".`,
   );
+  console.log(
+    `[analytics-bigquery-backfill-cron] Emitted Netlify scheduled trigger "${BIGQUERY_SCHEDULED_NAME}" (${BIGQUERY_SCHEDULE}) and background worker "${BIGQUERY_WORKER_NAME}".`,
+  );
   console.log(
     `[session-replay-retention-cron] Emitted Netlify scheduled trigger "${RETENTION_SCHEDULED_NAME}" (${RETENTION_SCHEDULE}) and background worker "${RETENTION_WORKER_NAME}".`,
   );

package/corpus/templates/analytics/scripts/migrate-production.ts

@@ -0,0 +1,24 @@
+import { closeDbExec, withMigrationRuntime } from "@agent-native/core/db";
+import { runFrameworkReleaseMigrations } from "@agent-native/core/server";
+
+import { runAnalyticsMigrations } from "../server/plugins/db.js";
+
+/**
+ * Release-time schema entrypoint for Analytics.
+ *
+ * This script is the production owner of schema changes. It runs against the
+ * direct migration endpoint selected by core, while request functions skip
+ * all migration and ensure-table work automatically.
+ */
+async function main(): Promise<void> {
+  await withMigrationRuntime(async () => {
+    await runFrameworkReleaseMigrations(null);
+    await runAnalyticsMigrations(null);
+  });
+}
+
+try {
+  await main();
+} finally {
+  await closeDbExec();
+}