@agent-native/core 0.157.9 → 0.157.10

package/corpus/templates/analytics/scripts/first-party-analytics-postgres-retention-dry-run.sql

@@ -10,11 +10,14 @@
 -- never included in the candidate count. Session replay, exception issues,
 -- public-key metadata, rollups, alerts, and pressure data are reported as
 -- preserved SQL rows; they are not deletion candidates.
+-- The organization and owner values below are intentionally fake safe
+-- defaults. Supply scoped values in a local copy or SQL-client parameters;
+-- never commit real organization IDs or employee addresses here.
 
 WITH params AS (
   SELECT
-    'PlRt3bfcpJNnOyF_Wfgsh'::text AS org_id,
-    'steve@builder.io'::text AS owner_email,
+    'org-example'::text AS org_id,
+    'owner@example.com'::text AS owner_email,
     '2026-06-10T18:50:43.370Z'::text AS lookback_start,
     '2026-08-09T19:11:44.834Z'::text AS cutoff,
     'http.response'::text AS excluded_event_name

package/corpus/templates/analytics/server/lib/first-party-analytics-backend.ts

@@ -1130,7 +1130,9 @@ export async function getFirstPartyAnalyticsBigQueryMetrics(
     WITH scoped_events AS (
       SELECT *
       FROM \`${physical.events}\`
-      WHERE ${tenantFilter}${startDateFilter} AND event_date <= ${today}
+      WHERE ${tenantFilter}${startDateFilter}
+        AND event_name IS DISTINCT FROM 'http.response'
+        AND event_date <= ${today}
     )
     SELECT
       COUNT(*) AS event_count,

package/corpus/templates/analytics/server/lib/first-party-analytics-purge.ts

@@ -1,5 +1,5 @@
 import { getDbExec } from "@agent-native/core/db";
-import { and, eq, gte, isNull, or } from "drizzle-orm";
+import { and, eq, gte, isNull, ne, or } from "drizzle-orm";
 
 import { getDb, schema } from "../db/index.js";
 
@@ -67,6 +67,10 @@ async function countScopedRows(
   const args: unknown[] = includeLegacyOwnerRows
     ? [scope.orgId, scope.userEmail]
     : [scope.orgId];
+  const eventFilter =
+    table === "analytics_events"
+      ? "\n             AND event_name IS DISTINCT FROM 'http.response'"
+      : "";
   args.push(
     timeColumn === "received_at"
       ? window.startReceivedAt
@@ -75,8 +79,9 @@ async function countScopedRows(
 
   const { rows } = await getDbExec().execute({
     sql: `SELECT COUNT(*) AS row_count
-            FROM ${table}
+           FROM ${table}
            WHERE ${scopeSql}
+             ${eventFilter}
              AND ${timeColumn} >= ?`,
     args,
     timeoutMs: 5_000,
@@ -135,10 +140,17 @@ export async function purgeFirstPartyAnalyticsPostgresRows(
     await tx
       .delete(schema.analyticsEvents)
       .where(
-        windowPredicate(
-          schema.analyticsEvents,
-          scopePredicate(schema.analyticsEvents, scope, includeLegacyOwnerRows),
-          window,
+        and(
+          windowPredicate(
+            schema.analyticsEvents,
+            scopePredicate(
+              schema.analyticsEvents,
+              scope,
+              includeLegacyOwnerRows,
+            ),
+            window,
+          ),
+          ne(schema.analyticsEvents.eventName, "http.response"),
         ),
       );
     await tx

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

@@ -1,6 +1,11 @@
 import {
+  deferMigration,
   ensureAdditiveColumns,
+  createDbExec,
   getDbExec,
+  getDatabaseUrl,
+  isPostgres,
+  MIGRATION_DEFERRED,
   runMigrations,
   withMigrationRuntime,
 } from "@agent-native/core/db";
@@ -34,6 +39,102 @@ const schemaTables = Object.values(schema).filter(isDrizzleTable);
 // 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 ANALYTICS_EVENT_CURSOR_INDEX_REPAIR_TIMEOUT_MS = 15 * 60 * 1000;
+
+function getAnalyticsMigrationDatabaseUrl(): string {
+  const appName = process.env.APP_NAME?.toUpperCase().replace(/-/g, "_");
+  const directUrl = appName
+    ? process.env[`${appName}_DATABASE_URL_UNPOOLED`]
+    : undefined;
+  const url =
+    directUrl ||
+    process.env.NETLIFY_DATABASE_URL_UNPOOLED ||
+    process.env.DATABASE_URL_UNPOOLED ||
+    getDatabaseUrl();
+  return url.replace(/-pooler(\.[a-z0-9.-]+\.neon\.tech)/, "$1");
+}
+
+const ANALYTICS_EVENT_CURSOR_INDEX_REPAIR_LOCK =
+  "hashtext('agent-native:analytics-event-cursor-index-repair')";
+
+async function repairAnalyticsEventCursorIndexes(): Promise<
+  void | typeof MIGRATION_DEFERRED
+> {
+  if (!isPostgres()) return;
+
+  const repairIndexes = [
+    {
+      name: "analytics_events_org_received_id_non_http_idx",
+      createSql: `CREATE INDEX CONCURRENTLY IF NOT EXISTS analytics_events_org_received_id_non_http_idx
+        ON analytics_events (org_id, received_at, id)
+        WHERE event_name IS DISTINCT FROM 'http.response'`,
+    },
+    {
+      name: "analytics_events_owner_received_id_non_http_idx",
+      createSql: `CREATE INDEX CONCURRENTLY IF NOT EXISTS analytics_events_owner_received_id_non_http_idx
+        ON analytics_events (owner_email, received_at, id)
+        WHERE org_id IS NULL AND event_name IS DISTINCT FROM 'http.response'`,
+    },
+    {
+      name: "analytics_event_daily_rollups_org_event_date_idx",
+      createSql: `CREATE INDEX CONCURRENTLY IF NOT EXISTS analytics_event_daily_rollups_org_event_date_idx
+        ON analytics_event_daily_rollups (org_id, event_date)`,
+    },
+    {
+      name: "analytics_user_days_org_event_date_idx",
+      createSql: `CREATE INDEX CONCURRENTLY IF NOT EXISTS analytics_user_days_org_event_date_idx
+        ON analytics_user_days (org_id, event_date)`,
+    },
+  ];
+
+  const exec = await createDbExec({ url: getAnalyticsMigrationDatabaseUrl() });
+  const query = (sql: string) =>
+    exec.execute({
+      sql,
+      timeoutMs: ANALYTICS_EVENT_CURSOR_INDEX_REPAIR_TIMEOUT_MS,
+      maxAttempts: 1,
+    });
+
+  try {
+    const lockResult = await query(
+      `SELECT pg_try_advisory_lock(${ANALYTICS_EVENT_CURSOR_INDEX_REPAIR_LOCK}) AS acquired`,
+    );
+    if (lockResult.rows[0]?.acquired !== true) return deferMigration();
+
+    let lockHeld = true;
+    try {
+      const { rows } = await query(`
+      SELECT c.relname, i.indisvalid, i.indisready
+      FROM pg_class c
+      JOIN pg_index i ON i.indexrelid = c.oid
+      WHERE c.relname IN (${repairIndexes.map(({ name }) => `'${name}'`).join(", ")})
+    `);
+      const readyIndexes = new Set(
+        rows
+          .filter((row) => row.indisvalid === true && row.indisready === true)
+          .map((row) => String(row.relname)),
+      );
+      const expectedIndexes = repairIndexes.map(({ name }) => name);
+      if (expectedIndexes.every((name) => readyIndexes.has(name))) return;
+
+      for (const { name, createSql } of repairIndexes) {
+        if (readyIndexes.has(name)) continue;
+        await query(`DROP INDEX CONCURRENTLY IF EXISTS ${name}`);
+        await query(createSql);
+      }
+    } finally {
+      if (lockHeld) {
+        await query(
+          `SELECT pg_advisory_unlock(${ANALYTICS_EVENT_CURSOR_INDEX_REPAIR_LOCK})`,
+        );
+        lockHeld = false;
+      }
+    }
+  } finally {
+    await exec.close?.();
+  }
+}
+
 export const runAnalyticsMigrations = runMigrations(
   [
     {
@@ -1660,6 +1761,44 @@ export const runAnalyticsMigrations = runMigrations(
           ON analytics_bigquery_backfill_shards (job_id, status, next_run_at, lease_expires_at, start_at);`,
       },
     },
+    {
+      version: 144,
+      name: "analytics-events-backfill-filtered-cursor-index-repair",
+      sql: {
+        postgres: `DROP INDEX CONCURRENTLY IF EXISTS analytics_events_org_received_id_non_http_idx;
+        CREATE INDEX CONCURRENTLY IF NOT EXISTS analytics_events_org_received_id_non_http_idx
+          ON analytics_events (org_id, received_at, id)
+          WHERE event_name IS DISTINCT FROM 'http.response';
+        DROP INDEX CONCURRENTLY IF EXISTS analytics_events_owner_received_id_non_http_idx;
+        CREATE INDEX CONCURRENTLY IF NOT EXISTS analytics_events_owner_received_id_non_http_idx
+          ON analytics_events (owner_email, received_at, id)
+          WHERE org_id IS NULL AND event_name IS DISTINCT FROM 'http.response';`,
+        sqlite: `CREATE INDEX IF NOT EXISTS analytics_events_org_received_id_non_http_idx
+          ON analytics_events (org_id, received_at, id)
+          WHERE event_name IS NOT 'http.response';
+        CREATE INDEX IF NOT EXISTS analytics_events_owner_received_id_non_http_idx
+          ON analytics_events (owner_email, received_at, id)
+          WHERE org_id IS NULL AND event_name IS NOT 'http.response';`,
+      },
+    },
+    {
+      version: 145,
+      name: "analytics-events-backfill-filtered-cursor-index-direct-repair",
+      run: repairAnalyticsEventCursorIndexes,
+      sql: {
+        postgres: "SELECT 1",
+        sqlite: "SELECT 1",
+      },
+    },
+    {
+      version: 146,
+      name: "analytics-events-purge-inventory-index-direct-repair",
+      run: repairAnalyticsEventCursorIndexes,
+      sql: {
+        postgres: "SELECT 1",
+        sqlite: "SELECT 1",
+      },
+    },
   ],
   { table: "analytics_migrations" },
 );

package/corpus/templates/slides/AGENTS.md

@@ -89,16 +89,20 @@ Deck data lives in SQL and all writes go through server-side actions. Read
 
 ## Export Behavior
 
-- Browser PowerPoint export uses the rendered slide DOM to generate native,
-  editable PPTX text/shapes/images. Do not replace it with full-slide images
-  unless the user explicitly asks for non-editable visual snapshots.
-- The server-side `export-pptx` action cannot measure browser-rendered
-  freeform geometry. It must fail clearly for positioned objects and direct the
-  user to the editor's Export > PowerPoint path instead of silently reflowing
-  them.
-- Google Slides export is a PPTX import workflow: generate the same editable
-  PPTX and have the user import it into Google Slides. Creating a native Google
-  Slides file directly requires a separate Google Slides API batchUpdate path.
+- PowerPoint and Google Slides export share two paths. Source-imported decks
+  with no browser-authored freeform objects export through the server
+  `export-pptx`, which writes their source geometry as real vector shapes; the
+  browser exporter can only rasterize it. Every other deck exports from the
+  rendered slide DOM, the one place editor-authored geometry is measurable. Do
+  not substitute full-slide images unless the user asks for non-editable
+  snapshots.
+- Browser-authored means `data-slide-object-id` without
+  `data-pptx-element-kind`, or `fmd-freeform-object`. `export-pptx` cannot
+  measure those and fails loudly; show that failure instead of quietly
+  re-exporting at lower fidelity.
+- Google Slides export is a PPTX import workflow: generate that PPTX and have
+  the user import it into Google Slides. Creating a native Google Slides file
+  directly requires a separate Google Slides API batchUpdate path.
 
 ## Source Changes