@agent-native/core 0.85.7 → 0.86.1

package/corpus/templates/analytics/server/plugins/db.ts

@@ -1,10 +1,37 @@
-import { runMigrations } from "@agent-native/core/db";
+import {
+  ensureAdditiveColumns,
+  getDbExec,
+  runMigrations,
+} from "@agent-native/core/db";
 
 // Side-effect import: ensures registerShareableResource runs on server
 // startup so the dashboard / analysis share actions know where to dispatch.
 import "../db/index.js";
+import * as schema from "../db/schema.js";
 
-export default runMigrations(
+/**
+ * Every Drizzle table exported from schema.ts. Filters out type-only and
+ * helper exports (e.g. re-exported `eq`/`sql`) the same way db.spec.ts's
+ * `isDrizzleTable` regression guard does: a real table carries a
+ * Symbol-keyed drizzle metadata bag, plain exports don't.
+ */
+function isDrizzleTable(value: unknown): value is object {
+  return (
+    !!value &&
+    typeof value === "object" &&
+    Object.getOwnPropertySymbols(value).some((s) =>
+      s.toString().includes("drizzle"),
+    )
+  );
+}
+
+const schemaTables = Object.values(schema).filter(isDrizzleTable);
+
+// Convention: every new migration below MUST set a unique `name:` slug (see
+// packages/core/src/db/migrations.ts for the full rationale). Version numbers
+// alone are not a safe identity across parallel branches that each extend
+// this list independently — see the v75-v83 incident documented on v75 below.
+const runAnalyticsMigrations = runMigrations(
   [
     {
       version: 1,
@@ -513,8 +540,19 @@ export default runMigrations(
         sqlite: `UPDATE session_replay_chunks SET started_at = CASE WHEN started_at IS NOT NULL AND substr(started_at, 1, 10) > date('now') THEN min(COALESCE(NULLIF(created_at, ''), datetime('now')), datetime('now')) ELSE started_at END, ended_at = CASE WHEN ended_at IS NOT NULL AND substr(ended_at, 1, 10) > date('now') THEN min(COALESCE(NULLIF(created_at, ''), datetime('now')), datetime('now')) ELSE ended_at END WHERE (started_at IS NOT NULL AND substr(started_at, 1, 10) > date('now')) OR (ended_at IS NOT NULL AND substr(ended_at, 1, 10) > date('now'))`,
       },
     },
+    // v75-v83: a parallel branch shipped unrelated DDL under these SAME version
+    // numbers, so whichever branch deployed first "used up" v75-v83 in
+    // `analytics_migrations` and the other branch's DDL below was silently
+    // never applied on any database that had already advanced past v83 — the
+    // exact version-collision failure class `runMigrations` name-based
+    // tracking exists to fix (see packages/core/src/db/migrations.ts). v75-v80
+    // below now carry a `name:` so they apply by name on every database
+    // regardless of what its recorded MAX(version) already is. All SQL here
+    // is untouched (still the original IF NOT EXISTS / ADD COLUMN IF NOT
+    // EXISTS DDL) — only the `name:` field was added.
     {
       version: 75,
+      name: "analytics-alert-rules-table",
       sql: {
         postgres: `CREATE TABLE IF NOT EXISTS analytics_alert_rules (
       id TEXT PRIMARY KEY,
@@ -568,6 +606,7 @@ export default runMigrations(
     },
     {
       version: 76,
+      name: "analytics-alert-incidents-table",
       sql: {
         postgres: `CREATE TABLE IF NOT EXISTS analytics_alert_incidents (
       id TEXT PRIMARY KEY,
@@ -607,12 +646,99 @@ export default runMigrations(
     },
     {
       version: 77,
+      name: "analytics-alert-rules-scope-enabled-idx",
       sql: `CREATE INDEX IF NOT EXISTS analytics_alert_rules_scope_enabled_idx ON analytics_alert_rules (org_id, owner_email, enabled, updated_at)`,
     },
     {
       version: 78,
+      name: "analytics-alert-incidents-rule-triggered-idx",
       sql: `CREATE INDEX IF NOT EXISTS analytics_alert_incidents_rule_triggered_idx ON analytics_alert_incidents (rule_id, triggered_at)`,
     },
+    // v79: session_recordings gained `network_error_count` in schema.ts (failed
+    // network requests observed in captured replay diagnostics events) without
+    // a matching migration, so pre-existing production tables never got the
+    // column — every read/write touching it 42703'd. Backfill it the same way
+    // page_count/error_count/rage_click_count/privacy_mode were added (v61-64).
+    // Also caught by the v75-v83 version-collision incident described above —
+    // named so it applies regardless of a database's recorded MAX(version).
+    {
+      version: 79,
+      name: "session-recordings-network-error-count",
+      sql: `ALTER TABLE session_recordings ADD COLUMN IF NOT EXISTS network_error_count INTEGER NOT NULL DEFAULT 0`,
+    },
+    {
+      version: 80,
+      name: "analytics-alert-rules-enabled-eval-idx",
+      sql: `CREATE INDEX IF NOT EXISTS analytics_alert_rules_enabled_eval_idx ON analytics_alert_rules (enabled, last_status, last_evaluated_at, created_at)`,
+    },
+    {
+      version: 81,
+      name: "analytics-db-admin-connections-table",
+      sql: {
+        postgres: `CREATE TABLE IF NOT EXISTS analytics_db_admin_connections (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      app_id TEXT,
+      app_url TEXT,
+      database_url_secret_key TEXT NOT NULL,
+      database_auth_token_secret_key TEXT,
+      created_by TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (now()::text),
+      updated_at TEXT NOT NULL DEFAULT (now()::text),
+      org_id TEXT NOT NULL
+    )`,
+        sqlite: `CREATE TABLE IF NOT EXISTS analytics_db_admin_connections (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      app_id TEXT,
+      app_url TEXT,
+      database_url_secret_key TEXT NOT NULL,
+      database_auth_token_secret_key TEXT,
+      created_by TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      org_id TEXT NOT NULL
+    )`,
+      },
+    },
+    {
+      version: 82,
+      name: "analytics-db-admin-connections-org-updated-idx",
+      sql: `CREATE INDEX IF NOT EXISTS analytics_db_admin_connections_org_updated_idx ON analytics_db_admin_connections (org_id, updated_at)`,
+    },
   ],
   { table: "analytics_migrations" },
 );
+
+/**
+ * The migration list above is the authoritative source for tables, indexes,
+ * and data transforms. `ensureAdditiveColumns` runs after it as a
+ * belt-and-braces safety net for the specific failure mode that caused the
+ * v79 migration above: a column added to schema.ts without a matching
+ * hand-written ALTER migration, which silently 500s every query touching a
+ * pre-existing production table. It only ever adds missing columns — never
+ * drops, renames, or retypes anything — and any failure here is logged and
+ * swallowed so it can never fail boot.
+ */
+export default async (nitroApp: any): Promise<void> => {
+  await runAnalyticsMigrations(nitroApp);
+  try {
+    const summary = await ensureAdditiveColumns({
+      db: getDbExec(),
+      tables: schemaTables,
+    });
+    if (summary.errors.length > 0) {
+      console.warn(
+        "[db] ensureAdditiveColumns completed with errors:",
+        summary.errors,
+      );
+    }
+  } catch (err) {
+    // Never fail boot over the safety net itself — the authoritative
+    // migrations above already ran.
+    console.warn(
+      "[db] ensureAdditiveColumns failed (non-fatal):",
+      err instanceof Error ? err.message : err,
+    );
+  }
+};

package/corpus/templates/analytics/server/routes/[base]/_agent-native/analytics-db-admin/[...path].ts

@@ -0,0 +1 @@
+export { default } from "../../../_agent-native/analytics-db-admin/[...path].js";

package/corpus/templates/analytics/server/routes/_agent-native/analytics-db-admin/[...path].ts

@@ -0,0 +1,160 @@
+import {
+  applyMutations,
+  DbAdminConfirmRequiredError,
+  getRows,
+  getTableSchema,
+  listTables,
+  runSql,
+  type DbAdminMutation,
+  type DbAdminRowsRequest,
+} from "@agent-native/core/db-admin";
+import { readBody } from "@agent-native/core/server";
+import {
+  defineEventHandler,
+  getMethod,
+  getRequestURL,
+  setResponseHeader,
+  setResponseStatus,
+  type H3Event,
+} from "h3";
+
+import {
+  DbAdminConnectionError,
+  redactDbAdminError,
+  runWithDbAdminEventContext,
+  withDbAdminConnectionRuntime,
+} from "../../../lib/db-admin-connections";
+
+function decodeSegment(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function pathSegments(event: H3Event): string[] {
+  const url = getRequestURL(event);
+  const marker = "/_agent-native/analytics-db-admin";
+  const markerIndex = url.pathname.indexOf(marker);
+  const suffix =
+    markerIndex === -1 ? "" : url.pathname.slice(markerIndex + marker.length);
+  return suffix
+    .replace(/^\/+/, "")
+    .split("/")
+    .filter(Boolean)
+    .map(decodeSegment)
+    .filter((segment): segment is string => Boolean(segment));
+}
+
+function methodNotAllowed(event: H3Event) {
+  setResponseStatus(event, 405);
+  return { ok: false, error: "Method not allowed" };
+}
+
+function badRequest(event: H3Event, error: string) {
+  setResponseStatus(event, 400);
+  return { ok: false, error };
+}
+
+function notFound(event: H3Event, error: string) {
+  setResponseStatus(event, 404);
+  return { ok: false, error };
+}
+
+export default defineEventHandler(async (event) => {
+  setResponseHeader(event, "Cache-Control", "no-store");
+
+  const method = getMethod(event);
+  const [connectionId, ...segments] = pathSegments(event);
+  if (!connectionId) {
+    return badRequest(event, "Connection id is required");
+  }
+
+  try {
+    return await runWithDbAdminEventContext(event, async (admin) =>
+      withDbAdminConnectionRuntime(admin, connectionId, async (runtime) => {
+        if (segments[0] === "overview" && segments.length === 1) {
+          if (method !== "GET") return methodNotAllowed(event);
+          const result = await listTables(runtime);
+          return { ok: true, ...result };
+        }
+
+        if (segments[0] === "table") {
+          const name = segments[1];
+          if (!name) return badRequest(event, "Table name is required");
+          const sub = segments[2];
+
+          if (sub === "schema" && segments.length === 3) {
+            if (method !== "GET") return methodNotAllowed(event);
+            const table = await getTableSchema(name, runtime);
+            return { ok: true, table };
+          }
+
+          if (sub === "rows" && segments.length === 3) {
+            if (method !== "POST") return methodNotAllowed(event);
+            const body = await readBody<Partial<DbAdminRowsRequest>>(event);
+            const result = await getRows(
+              name,
+              {
+                page: Number(body.page) || 1,
+                pageSize: Number(body.pageSize) || 50,
+                sort: body.sort,
+                filters: body.filters,
+              },
+              runtime,
+            );
+            return { ok: true, ...result };
+          }
+
+          if (sub === "mutate" && segments.length === 3) {
+            if (method !== "POST") return methodNotAllowed(event);
+            const body = await readBody<DbAdminMutation>(event);
+            const result = await applyMutations(name, body ?? {}, runtime);
+            return { ok: true, ...result };
+          }
+
+          return notFound(event, "Unknown analytics db-admin table route");
+        }
+
+        if (segments[0] === "query" && segments.length === 1) {
+          if (method !== "POST") return methodNotAllowed(event);
+          const body = await readBody<{
+            sql?: string;
+            params?: unknown[];
+            confirmDestructive?: boolean;
+          }>(event);
+          try {
+            const result = await runSql(
+              String(body.sql ?? ""),
+              Array.isArray(body.params) ? body.params : undefined,
+              { confirmDestructive: body.confirmDestructive === true },
+              runtime,
+            );
+            return { ok: true, ...result };
+          } catch (err) {
+            if (err instanceof DbAdminConfirmRequiredError) {
+              setResponseStatus(event, 400);
+              return {
+                ok: false,
+                error: err.message,
+                needsConfirm: true,
+              };
+            }
+            throw err;
+          }
+        }
+
+        return notFound(event, "Unknown analytics db-admin route");
+      }),
+    );
+  } catch (err) {
+    if (err instanceof DbAdminConnectionError) {
+      setResponseStatus(event, err.statusCode);
+      return { ok: false, error: err.message };
+    }
+    setResponseStatus(event, 500);
+    return { ok: false, error: redactDbAdminError(err) };
+  }
+});

package/corpus/templates/analytics/server/routes/api/session-replay/agent-diagnostics.json.get.ts

@@ -15,6 +15,8 @@ import { getSessionReplayTokenizedEvents } from "../../../lib/session-replay.js"
 
 const DEFAULT_DIAGNOSTICS_LIMIT = 200;
 const MAX_DIAGNOSTICS_LIMIT = 500;
+const DEFAULT_REPLAY_EVENT_READ_LIMIT = 10_000;
+const MAX_REPLAY_EVENT_READ_LIMIT = 100_000;
 const CONSOLE_LEVELS = new Set(["log", "info", "warn", "error", "debug"]);
 
 function queryString(value: unknown): string {
@@ -69,9 +71,45 @@ export default defineEventHandler(async (event) => {
     Math.max(1, queryInt(query.limit) ?? DEFAULT_DIAGNOSTICS_LIMIT),
   );
 
+  const rawOffset = queryString(query.offset);
+  if (rawOffset && queryInt(query.offset) === undefined) {
+    setResponseStatus(event, 400);
+    return { error: "offset must be a non-negative integer" };
+  }
+  const offset = Math.max(0, queryInt(query.offset) ?? 0);
+
+  const rawFromMs = queryString(query.fromMs);
+  if (rawFromMs && queryInt(query.fromMs) === undefined) {
+    setResponseStatus(event, 400);
+    return { error: "fromMs must be a non-negative integer" };
+  }
+  const fromMs = queryInt(query.fromMs);
+
+  const rawToMs = queryString(query.toMs);
+  if (rawToMs && queryInt(query.toMs) === undefined) {
+    setResponseStatus(event, 400);
+    return { error: "toMs must be a non-negative integer" };
+  }
+  const toMs = queryInt(query.toMs);
+
+  if (fromMs !== undefined && toMs !== undefined && fromMs > toMs) {
+    setResponseStatus(event, 400);
+    return { error: "fromMs must be less than or equal to toMs" };
+  }
+
   try {
+    const timeWindowed = fromMs !== undefined || toMs !== undefined;
+    const replayEventReadLimit = Math.min(
+      MAX_REPLAY_EVENT_READ_LIMIT,
+      Math.max(
+        DEFAULT_REPLAY_EVENT_READ_LIMIT,
+        timeWindowed
+          ? MAX_REPLAY_EVENT_READ_LIMIT
+          : (rawOffset ? offset : 0) + limit,
+      ),
+    );
     const eventsResponse = await getSessionReplayTokenizedEvents(id, {
-      limit: 10_000,
+      limit: replayEventReadLimit,
     });
     const events = eventsResponse.chunks.flatMap((chunk) =>
       chunk.events.filter(
@@ -83,12 +121,18 @@ export default defineEventHandler(async (event) => {
       maxConsoleEntries: kind === "network" ? 0 : limit,
       maxNetworkEntries: kind === "console" ? 0 : limit,
       consoleLevel: level,
+      ...(rawOffset ? { offset } : {}),
+      ...(fromMs !== undefined ? { fromMs } : {}),
+      ...(toMs !== undefined ? { toMs } : {}),
     });
     return {
       recordingId: eventsResponse.recording.id,
       kind,
       ...(level ? { level } : {}),
       limit,
+      ...(rawOffset ? { offset } : {}),
+      ...(fromMs !== undefined ? { fromMs } : {}),
+      ...(toMs !== undefined ? { toMs } : {}),
       ...(kind !== "network" ? { console: diagnostics.console } : {}),
       ...(kind !== "console" ? { network: diagnostics.network } : {}),
       eventsTruncated: eventsResponse.truncated,

package/corpus/templates/analytics/shared/session-replay-diagnostics.ts

@@ -41,6 +41,12 @@ export interface SessionReplayNetworkEventPayload {
   ok: boolean;
   durationMs: number;
   error?: string;
+  /**
+   * Bounded, redacted response-body snippet. Present only for 5xx
+   * responses -- request bodies and headers are never captured, and
+   * non-5xx/network-failure responses never carry a body.
+   */
+  responseBody?: string;
 }
 
 export interface SessionReplayConsoleDiagnosticsEntry extends SessionReplayConsoleEventPayload {
@@ -64,12 +70,16 @@ export interface SessionReplayDiagnostics {
     warnCount: number;
     entries: SessionReplayConsoleDiagnosticsEntry[];
     truncated: boolean;
+    /** True when more console entries remain after this page/response. */
+    hasMore: boolean;
   };
   network: {
     total: number;
     failedCount: number;
     entries: SessionReplayNetworkDiagnosticsEntry[];
     truncated: boolean;
+    /** True when more network entries remain after this page/response. */
+    hasMore: boolean;
   };
 }
 

package/corpus/templates/assets/.agents/skills/real-time-collab/SKILL.md

@@ -249,34 +249,97 @@ type PatchDeckOp =
 Concurrent edits to different slides both succeed at the action level; there
 is no whole-deck LWW. Forms use the same shape with field-level ops.
 
-## Collaborative Undo Scoping (Y.UndoManager)
+## Agent Presence & Lingering Edit Highlights
+
+The agent is a *visible* collaborator, not a silent content-swapper. Core
+handles most of this automatically:
+
+- **Auto-presence on agent writes** — any `applyText` / `searchAndReplace` /
+  `applyJson` / `applyPatchOps` call with `requestSource: "agent"` publishes
+  an agent awareness entry plus a `recentEdits` attribution describing what
+  changed. Actions that route writes through the collab layer get full
+  presence UX with zero extra wiring.
+- **Linger** — `agentLeaveDocument` (and the auto-presence path) keeps the
+  agent's awareness entry alive for ~6s (`AGENT_PRESENCE_LINGER_MS`) after the
+  last edit so viewers see who just changed what. Pass `{ lingerMs: 0 }` to
+  clear immediately. On serverless the linger degrades to the 30s awareness
+  expiry.
+- **`agentTouchDocument(docId, { edit, metadata })`** — refcount-neutral
+  presence + attribution for actions that write SQL directly (no collab doc).
+  `edit.descriptor` is one of `{kind:"text",quote}`, `{kind:"selector",selector}`,
+  `{kind:"paths",paths}`, `{kind:"doc"}`.
+- **Durable across instances** — awareness is mirrored to the additive
+  `_collab_awareness` table, so presence written by an action in one
+  serverless invocation is visible to clients polling any other instance.
+
+Client rendering:
+
+```tsx
+import {
+  usePresence, useRecentEdits, RecentEditHighlights,
+  PresenceBar, LiveCursorOverlay, RemoteSelectionRings,
+} from "@agent-native/core/client";
+
+const { others, setPresence } = usePresence(awareness, ydoc?.clientID);
+const recentEdits = useRecentEdits(others); // non-expired, ~6s TTL
+
+<RecentEditHighlights
+  edits={recentEdits}
+  containerRef={containerRef}
+  resolveRect={(edit) => /* map descriptor → DOMRect, or null */ null}
+/>
+```
+
+Humans get the same treatment: call `publishRecentEdit(awareness, { descriptor })`
+from local mutation paths so peers see lingering highlights for human edits
+too. `CollabUser.avatarUrl` puts faces on avatars, cursors, and edit tags.
+
+## Per-User Undo (never revert someone else's work)
 
-Scope undo/redo to the local user's own edits so peer and agent changes are
-never accidentally reversed:
+Undo must only reverse the local user's edits — and must never restore a
+whole-document snapshot (that clobbers concurrent edits by peers/the agent).
+Core ships two primitives:
+
+**Yjs surfaces — `useCollabUndo`** (wraps `Y.UndoManager` lifecycle):
 
 ```ts
-import * as Y from "yjs";
+import { useCollabUndo } from "@agent-native/core/client";
+
+const { undo, redo, canUndo, canRedo, transactLocal, localOrigin } =
+  useCollabUndo({
+    ydoc,
+    scope: (doc) => doc.getText("content"),
+    captureTimeout: 500,
+    enableKeyboardShortcuts: true, // Mod+Z / Shift+Mod+Z / Mod+Y
+  });
 
-const LOCAL_EDIT_ORIGIN = "local";
+// Tag every local mutation so it is captured:
+transactLocal(() => { /* mutate shared types */ });
+```
 
-const undoManager = new Y.UndoManager(ydoc.getText("content"), {
-  trackedOrigins: new Set([LOCAL_EDIT_ORIGIN]),
-  captureTimeout: 800, // coalesces rapid slider drags into one undo step
-});
+Remote (`"remote"`) and agent (`"agent"`/`"server"`) origins are never
+captured. The manager is recreated/destroyed automatically when `ydoc`
+changes. (TipTap's Collaboration extension already provides this behavior
+for its own editor content.)
 
-// Mark local edits with the tracked origin
-ydoc.transact(() => {
-  // apply local change
-}, LOCAL_EDIT_ORIGIN);
+**Op-based surfaces (slides/forms) — `useLocalOpUndo`**: record inverse
+granular ops for each local mutation; undo replays the inverse ops through
+your normal granular mutation path:
 
-undoManager.undo(); // only reverses LOCAL_EDIT_ORIGIN transactions
-undoManager.redo();
+```ts
+const { push, undo, redo, canUndo, canRedo } = useLocalOpUndo({
+  apply: (ops) => applyGranularOps(ops), // your patch path
+});
+
+push({
+  undo: [{ type: "patch", slideId, fields: prevFields }],
+  redo: [{ type: "patch", slideId, fields: nextFields }],
+  coalesceKey: `${slideId}:content`, // merge rapid bursts into one step
+});
 ```
 
-Rules:
-- Pass a `Set` to `trackedOrigins` — not an array.
-- Remote (`"remote"`) and agent (`"agent"`) origins are never captured.
-- Recreate and destroy the manager when the active document changes.
+Entries whose target no longer exists should fail soft (skip), never reset
+the whole history — external/agent edits must not wipe the user's undo stack.
 
 ## Common Pitfalls
 

package/corpus/templates/assets/.agents/skills/real-time-sync/SKILL.md

@@ -58,6 +58,21 @@ The agent modifies data in SQL, but the UI runs in the browser. SSE bridges same
 
 - Don't create manual polling loops — `useDbSync()` handles SSE plus fallback polling
 - Don't create your own fetch-based polling alongside `useDbSync` — use the `onEvent` callback for custom handling
+- Don't open your own `EventSource` to `/_agent-native/events`. A tab must hold exactly ONE SSE connection no matter how many features listen — extra streams eat the browser's per-origin connection budget and can starve ordinary data fetches (worst on HTTP/1.1 dev servers). Subscribe to the shared transport instead:
+
+  ```ts
+  import { subscribeSyncEvents } from "@agent-native/core/client";
+
+  const unsubscribe = subscribeSyncEvents({
+    onEvents: (events) => {
+      // filter by event.source and handle push-style updates
+    },
+    // Optional: relax your own fallback cadence while push is healthy.
+    onSseStateChange: (connected) => {},
+  });
+  ```
+
+  `useDbSync` and every `subscribeSyncEvents` subscriber share one `EventSource` and one fallback poll loop per tab — this is how collaborative documents receive doc updates and cursor/awareness events.
 
 ## Which sources to depend on
 

package/corpus/templates/assets/.agents/skills/storing-data/SKILL.md

@@ -25,6 +25,14 @@ Agent-native apps use Drizzle ORM over the configured SQL backend. Local develop
 
 For app code, use Drizzle's schema/query DSL by default. Raw SQL is an escape hatch for additive migrations, health checks, or one-off maintenance, not the normal way to build features.
 
+### Naming migrations
+
+When you add an entry to a `runMigrations([...])` list (`@agent-native/core/db`), always give it a unique `name:` slug (e.g. `name: "analytics-alert-rules-table"`) alongside its `version`. Never renumber or reuse version numbers on existing entries.
+
+Why: version numbers alone are not a safe identity. Two branches that each independently extend the same migration list can ship different DDL under the same version numbers — whichever branch deploys first "claims" those version numbers in the bookkeeping table, and the other branch's DDL is silently treated as already applied even though it never ran. This exact collision took down analytics: parallel branches both extended their migration list through v75-v83 with different DDL, so `analytics_alert_rules`, `analytics_alert_incidents`, and `session_recordings.network_error_count` never made it to production despite the bookkeeping table showing every version as applied. A `name:` slug is tracked independently of version numbers, so it applies exactly once per database regardless of what any other branch already recorded.
+
+Existing unnamed migrations don't need to be renamed retroactively (the two gating strategies coexist), but any new entry should always carry a name.
+
 ### Core SQL Stores (auto-created, available in all templates)
 
 | Store               | Purpose                                              | Access                                     |

package/corpus/templates/assets/package.json

@@ -46,8 +46,8 @@
     "@radix-ui/react-tabs": "^1.1.12",
     "@radix-ui/react-toast": "^1.2.15",
     "@radix-ui/react-tooltip": "^1.2.7",
-    "@react-router/dev": "^8.0.1",
-    "@react-router/fs-routes": "^8.0.1",
+    "@react-router/dev": "^8.1.0",
+    "@react-router/fs-routes": "^8.1.0",
     "@tailwindcss/typography": "^0.5.20",
     "@tailwindcss/vite": "catalog:",
     "@tanstack/react-query": "^5.99.2",
@@ -61,7 +61,7 @@
     "oxfmt": "catalog:",
     "react": "catalog:",
     "react-dom": "catalog:",
-    "react-router": "^8.0.1",
+    "react-router": "^8.1.0",
     "sonner": "^2.0.7",
     "tailwind-merge": "^3.5.0",
     "tailwindcss": "catalog:",