@agent-native/core 0.146.8 → 0.148.0

package/corpus/templates/analytics/app/i18n-data.ts

@@ -1314,7 +1314,7 @@ const enUS = {
     storageSetupDescription:
       "Session replay recordings need storage before chunks can be saved. Connect Builder.io for free-tier storage, or configure your own S3-compatible bucket.",
     storageConnected: "Storage connected",
-    connectBuilder: "Use Builder.io (free)",
+    connectBuilder: "Use Builder.io",
     configureS3: "Configure S3 storage",
     devtools: "Dev Tools",
     devtoolsResize: "Resize Dev Tools",
@@ -10157,7 +10157,7 @@ const translatedSessionReplayTranslations = {
       storageSetupDescription:
         "保存会话回放录制片段前需要先配置存储。可连接 Builder.io 使用免费层存储，或配置您自己的 S3 兼容存储桶。",
       storageConnected: "存储已连接",
-      connectBuilder: "使用 Builder.io（免费）",
+      connectBuilder: "使用 Builder.io",
       configureS3: "配置 S3 存储",
       title: "会话",
       description:
@@ -10279,7 +10279,7 @@ const translatedSessionReplayTranslations = {
       storageSetupDescription:
         "Las grabaciones de repetición de sesión necesitan almacenamiento antes de poder guardar los fragmentos. Conecta Builder.io para usar almacenamiento de nivel gratuito o configura tu propio bucket compatible con S3.",
       storageConnected: "Almacenamiento conectado",
-      connectBuilder: "Usar Builder.io (gratis)",
+      connectBuilder: "Usar Builder.io",
       configureS3: "Configurar almacenamiento S3",
       title: "Sesiones",
       description:
@@ -10405,7 +10405,7 @@ const translatedSessionReplayTranslations = {
       storageSetupDescription:
         "Les enregistrements de relecture de session nécessitent un espace de stockage avant de pouvoir sauvegarder les fragments. Connectez Builder.io pour un stockage en formule gratuite, ou configurez votre propre bucket compatible S3.",
       storageConnected: "Stockage connecté",
-      connectBuilder: "Utiliser Builder.io (gratuit)",
+      connectBuilder: "Utiliser Builder.io",
       configureS3: "Configurer le stockage S3",
       title: "Sessions",
       description:
@@ -10534,7 +10534,7 @@ const translatedSessionReplayTranslations = {
       storageSetupDescription:
         "Aufzeichnungen der Sitzungswiedergabe benötigen einen Speicher, bevor Chunks gesichert werden können. Verbinden Sie Builder.io für Speicher im kostenlosen Kontingent oder konfigurieren Sie Ihren eigenen S3-kompatiblen Bucket.",
       storageConnected: "Speicher verbunden",
-      connectBuilder: "Builder.io verwenden (kostenlos)",
+      connectBuilder: "Builder.io verwenden",
       configureS3: "S3-Speicher konfigurieren",
       title: "Sitzungen",
       description:
@@ -10659,7 +10659,7 @@ const translatedSessionReplayTranslations = {
       storageSetupDescription:
         "セッションリプレイの録画を保存するには、まずストレージが必要です。Builder.io の無料枠ストレージを接続するか、独自の S3 互換バケットを設定してください。",
       storageConnected: "ストレージ接続済み",
-      connectBuilder: "Builder.io を使う（無料）",
+      connectBuilder: "Builder.io を使う",
       configureS3: "S3 ストレージを設定",
       title: "セッション",
       description:
@@ -10785,7 +10785,7 @@ const translatedSessionReplayTranslations = {
       storageSetupDescription:
         "세션 재생 녹화를 저장하려면 먼저 저장소가 필요합니다. 무료 등급 저장소를 사용하려면 Builder.io를 연결하거나, 직접 S3 호환 버킷을 구성하세요.",
       storageConnected: "저장소 연결됨",
-      connectBuilder: "Builder.io 사용 (무료)",
+      connectBuilder: "Builder.io 사용",
       configureS3: "S3 저장소 구성",
       title: "세션",
       description:
@@ -10910,7 +10910,7 @@ const translatedSessionReplayTranslations = {
       storageSetupDescription:
         "As gravações de replay de sessão precisam de armazenamento antes que os fragmentos possam ser salvos. Conecte o Builder.io para armazenamento no plano gratuito ou configure seu próprio bucket compatível com S3.",
       storageConnected: "Armazenamento conectado",
-      connectBuilder: "Usar Builder.io (gratuito)",
+      connectBuilder: "Usar Builder.io",
       configureS3: "Configurar armazenamento S3",
       title: "Sessões",
       description:
@@ -11034,7 +11034,7 @@ const translatedSessionReplayTranslations = {
       storageSetupDescription:
         "चंक्स सेव करने से पहले सेशन रीप्ले रिकॉर्डिंग के लिए स्टोरेज ज़रूरी है। फ्री-टियर स्टोरेज के लिए Builder.io कनेक्ट करें, या अपना खुद का S3-संगत बकेट कॉन्फ़िगर करें।",
       storageConnected: "स्टोरेज कनेक्ट हो गया",
-      connectBuilder: "Builder.io इस्तेमाल करें (मुफ़्त)",
+      connectBuilder: "Builder.io इस्तेमाल करें",
       configureS3: "S3 स्टोरेज कॉन्फ़िगर करें",
       title: "सत्र",
       description:
@@ -11155,7 +11155,7 @@ const translatedSessionReplayTranslations = {
       storageSetupDescription:
         "تحتاج تسجيلات إعادة عرض الجلسات إلى مساحة تخزين قبل أن يتسنى حفظ الأجزاء. اربط Builder.io للحصول على تخزين بالباقة المجانية، أو هيّئ حاوية متوافقة مع S3 خاصة بك.",
       storageConnected: "تم ربط مساحة التخزين",
-      connectBuilder: "استخدام Builder.io (مجاناً)",
+      connectBuilder: "استخدام Builder.io",
       configureS3: "تهيئة تخزين S3",
       title: "الجلسات",
       description:

package/corpus/templates/analytics/app/pages/Settings.tsx

@@ -20,13 +20,6 @@ import { Link } from "react-router";
 import { toast } from "sonner";
 
 import { Button } from "@/components/ui/button";
-import {
-  Card,
-  CardContent,
-  CardDescription,
-  CardHeader,
-  CardTitle,
-} from "@/components/ui/card";
 import { Label } from "@/components/ui/label";
 import { Switch } from "@/components/ui/switch";
 
@@ -218,22 +211,13 @@ export default function Settings() {
           </SettingsGroup>
 
           {replayStorageStatus.data?.configured ? (
-            <Card
+            <SettingsGroup
               id="replay-storage"
-              className="bg-card border-border/50 scroll-mt-16"
+              title={t("sessions.storageSetupTitle")}
+              description={t("sessions.storageSetupDescription")}
             >
-              <CardHeader>
-                <CardTitle className="text-base">
-                  {t("sessions.storageSetupTitle")}
-                </CardTitle>
-                <CardDescription>
-                  {t("sessions.storageSetupDescription")}
-                </CardDescription>
-              </CardHeader>
-              <CardContent>
-                <ReplayStorageHint embedded />
-              </CardContent>
-            </Card>
+              <ReplayStorageHint embedded />
+            </SettingsGroup>
           ) : null}
         </div>
       }

package/corpus/templates/analytics/app/pages/sessions/SessionsPage.tsx

@@ -621,9 +621,7 @@ export function ReplayStorageHint({
                 <IconLoader2 className="h-4 w-4 animate-spin" />
               ) : builderConnected ? (
                 <IconCheck className="h-4 w-4" />
-              ) : (
-                <IconExternalLink className="h-4 w-4" />
-              )}
+              ) : null}
               {builderConnected
                 ? t("sessions.storageConnected")
                 : t("sessions.connectBuilder")}

package/corpus/templates/analytics/app/routes/status.$slug.tsx

@@ -1,4 +1,5 @@
 import { useActionQuery } from "@agent-native/core/client/hooks";
+import { normalizeDocumentTitle } from "@agent-native/core/shared";
 import { IconActivity } from "@tabler/icons-react";
 import { useMemo } from "react";
 import { data, useLoaderData, useParams } from "react-router";
@@ -43,15 +44,16 @@ export const meta: MetaFunction<typeof loader> = ({ loaderData }) => {
       { name: "robots", content: "noindex" },
     ];
   }
+  const pageTitle = normalizeDocumentTitle(page.title, "Status page");
   const description =
     page.description ||
     (page.overall === "operational"
       ? "All systems operational."
       : "Current service status.");
   return [
-    { title: `${page.title} · Status` },
+    { title: `${pageTitle} · Status` },
     { name: "description", content: description },
-    { property: "og:title", content: `${page.title} · Status` },
+    { property: "og:title", content: `${pageTitle} · Status` },
     { property: "og:description", content: description },
     { property: "og:type", content: "website" },
   ];

package/corpus/templates/analytics/scripts/first-party-analytics-bigquery-backfill.ts

@@ -36,7 +36,13 @@ const MAX_CONCURRENCY = 4;
 const DEFAULT_MAX_BATCHES = 1_000;
 const MAX_MAX_BATCHES = 10_000;
 const DEFAULT_CHECKPOINT_PATH = ".analytics-first-party-bigquery-backfill.json";
+const DEFAULT_LOOKBACK_DAYS = 60;
+const MIN_LOOKBACK_DAYS = 30;
+const MAX_LOOKBACK_DAYS = 60;
+const DEFAULT_EXCLUDED_EVENT_NAMES = ["http.response"];
+const MAX_EXCLUDED_EVENT_NAMES = 32;
 const QUERY_TIMEOUT_MS = 30_000;
+const MAX_HYDRATION_IDS = 500;
 const JOB_TABLE = "analytics_bigquery_backfill_jobs";
 const FINALIZE_ALLOW_ENV =
   "AGENT_NATIVE_ANALYTICS_BIGQUERY_BACKFILL_FINALIZE_ALLOW";
@@ -58,13 +64,16 @@ export interface BranchCheckpoint {
 }
 
 export interface DedicatedBackfillCheckpoint {
-  version: 1;
+  version: 1 | 2;
   scope: {
     userEmail: string;
     orgId: string;
   };
   table: string | null;
   branches: Record<BranchName, BranchCheckpoint>;
+  lookbackDays?: number;
+  lookbackStart?: string | null;
+  excludedEventNames?: string[];
   updatedAt: string;
 }
 
@@ -75,6 +84,8 @@ export interface DedicatedBackfillOptions {
   concurrency: number;
   maxBatches: number;
   checkpointPath: string;
+  lookbackDays?: number;
+  excludedEventNames?: string[];
 }
 
 export interface FinalizeResult {
@@ -126,6 +137,8 @@ interface BranchSpec {
   name: BranchName;
   predicate: string;
   predicateArgs: string[];
+  lookbackStart?: string | null;
+  excludedEventNames?: string[];
 }
 
 const PROJECTED_COLUMNS = FIRST_PARTY_ANALYTICS_BACKFILL_COLUMNS.join(", ");
@@ -144,6 +157,49 @@ function positiveInteger(
   return Math.min(value, maximum);
 }
 
+function parseLookbackDays(raw: string | undefined): number {
+  if (raw === undefined) return DEFAULT_LOOKBACK_DAYS;
+  const value = Number(raw);
+  if (
+    !Number.isInteger(value) ||
+    value < MIN_LOOKBACK_DAYS ||
+    value > MAX_LOOKBACK_DAYS
+  ) {
+    throw new Error(
+      `--lookback-days must be an integer between ${MIN_LOOKBACK_DAYS} and ${MAX_LOOKBACK_DAYS}`,
+    );
+  }
+  return value;
+}
+
+function parseExcludedEventNames(raw: string | undefined): string[] {
+  if (raw === undefined) return [...DEFAULT_EXCLUDED_EVENT_NAMES];
+  const names = [...new Set(raw.split(",").map((name) => name.trim()))].filter(
+    Boolean,
+  );
+  if (names.length > MAX_EXCLUDED_EVENT_NAMES) {
+    throw new Error(
+      `--skip-events supports at most ${MAX_EXCLUDED_EVENT_NAMES} event names`,
+    );
+  }
+  return names;
+}
+
+function lookbackStart(now: string, days: number): string {
+  const date = new Date(now);
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(`Invalid backfill clock value: ${now}`);
+  }
+  date.setUTCDate(date.getUTCDate() - days);
+  return date.toISOString();
+}
+
+interface BackfillQueryConfig {
+  lookbackDays: number;
+  lookbackStart: string | null;
+  excludedEventNames: string[];
+}
+
 function requiredArg(args: Record<string, string>, name: string): string {
   const value = args[name]?.trim();
   if (!value) throw new Error(`--${name} is required`);
@@ -177,6 +233,8 @@ export function parseDedicatedBackfillOptions(
       MAX_MAX_BATCHES,
     ),
     checkpointPath: resolve(args.checkpoint || DEFAULT_CHECKPOINT_PATH),
+    lookbackDays: parseLookbackDays(args["lookback-days"]),
+    excludedEventNames: parseExcludedEventNames(args["skip-events"]),
     execute: args.execute === "true",
     finalize: args.finalize === "true",
   };
@@ -184,35 +242,70 @@ export function parseDedicatedBackfillOptions(
 
 function branchSpecs(
   scope: FirstPartyAnalyticsScope & { orgId: string },
+  queryConfig: BackfillQueryConfig = {
+    lookbackDays: DEFAULT_LOOKBACK_DAYS,
+    lookbackStart: null,
+    excludedEventNames: [],
+  },
 ): BranchSpec[] {
   return [
     {
       name: "org",
       predicate: "org_id = ?",
       predicateArgs: [scope.orgId],
+      ...queryConfig,
     },
     {
       name: "legacy",
       predicate: "org_id IS NULL AND owner_email = ?",
       predicateArgs: [scope.userEmail],
+      ...queryConfig,
     },
   ];
 }
 
+function sourceFilter(spec: BranchSpec): {
+  clauses: string[];
+  args: string[];
+} {
+  const clauses: string[] = [];
+  const args: string[] = [];
+  if (spec.lookbackStart) {
+    clauses.push("received_at >= ?");
+    args.push(spec.lookbackStart);
+  }
+  const excluded = spec.excludedEventNames ?? [];
+  if (excluded.length) {
+    if (
+      excluded.length === DEFAULT_EXCLUDED_EVENT_NAMES.length &&
+      excluded[0] === DEFAULT_EXCLUDED_EVENT_NAMES[0]
+    ) {
+      clauses.push("event_name IS DISTINCT FROM 'http.response'");
+    } else {
+      clauses.push(
+        `(event_name IS NULL OR event_name NOT IN (${excluded.map(() => "?").join(", ")}))`,
+      );
+      args.push(...excluded);
+    }
+  }
+  return { clauses, args };
+}
+
 export function buildHighWaterMarkQuery(spec: BranchSpec): DbQuery {
+  const filters = sourceFilter(spec);
   return {
     sql: `SELECT received_at, id
       FROM analytics_events
-      WHERE ${spec.predicate}
+      WHERE ${spec.predicate}${filters.clauses.length ? `\n        AND ${filters.clauses.join("\n        AND ")}` : ""}
       ORDER BY received_at DESC, id DESC
       LIMIT 1`,
-    args: spec.predicateArgs,
+    args: [...spec.predicateArgs, ...filters.args],
     timeoutMs: QUERY_TIMEOUT_MS,
     maxAttempts: 1,
   };
 }
 
-export function buildPageQuery(
+export function buildPageKeyQuery(
   spec: BranchSpec,
   state: BranchCheckpoint,
   batchSize: number,
@@ -220,27 +313,25 @@ export function buildPageQuery(
   if (!state.cutoff) {
     throw new Error(`Cannot page ${spec.name} without a high-water mark`);
   }
+  const filters = sourceFilter(spec);
   const args: unknown[] = [
     ...spec.predicateArgs,
-    state.cutoff.receivedAt,
+    ...filters.args,
     state.cutoff.receivedAt,
     state.cutoff.id,
   ];
   let cursorClause = "";
   if (state.cursor) {
-    cursorClause = " AND (received_at > ? OR (received_at = ? AND id > ?))";
-    args.push(
-      state.cursor.receivedAt,
-      state.cursor.receivedAt,
-      state.cursor.id,
-    );
+    cursorClause = " AND (received_at, id) > (?, ?)";
+    args.push(state.cursor.receivedAt, state.cursor.id);
   }
   args.push(batchSize);
   return {
-    sql: `SELECT ${PROJECTED_COLUMNS}
+    sql: `SELECT received_at, id
       FROM analytics_events
       WHERE ${spec.predicate}
-        AND (received_at < ? OR (received_at = ? AND id <= ?))${cursorClause}
+        ${filters.clauses.map((clause) => `AND ${clause}`).join("\n        ")}
+        AND (received_at, id) <= (?, ?)${cursorClause}
       ORDER BY received_at ASC, id ASC
       LIMIT ?`,
     args,
@@ -249,6 +340,22 @@ export function buildPageQuery(
   };
 }
 
+export function buildHydrationQuery(ids: string[]): DbQuery {
+  if (!ids.length || ids.length > MAX_HYDRATION_IDS) {
+    throw new Error(
+      `BigQuery backfill hydration requires 1-${MAX_HYDRATION_IDS} ids`,
+    );
+  }
+  return {
+    sql: `SELECT ${PROJECTED_COLUMNS}
+      FROM analytics_events
+      WHERE id IN (${ids.map(() => "?").join(", ")})`,
+    args: ids,
+    timeoutMs: QUERY_TIMEOUT_MS,
+    maxAttempts: 1,
+  };
+}
+
 function cursorFromRow(row: unknown, description: string): BackfillCursor {
   if (!row || typeof row !== "object") {
     throw new Error(`${description} is not an object`);
@@ -288,9 +395,10 @@ function emptyBranchCheckpoint(): BranchCheckpoint {
 function newCheckpoint(
   options: DedicatedBackfillOptions,
   now: string,
+  queryConfig: BackfillQueryConfig,
 ): DedicatedBackfillCheckpoint {
   return {
-    version: 1,
+    version: 2,
     scope: {
       userEmail: options.scope.userEmail,
       orgId: options.scope.orgId,
@@ -300,15 +408,54 @@ function newCheckpoint(
       org: emptyBranchCheckpoint(),
       legacy: emptyBranchCheckpoint(),
     },
+    lookbackDays: queryConfig.lookbackDays,
+    lookbackStart: queryConfig.lookbackStart ?? undefined,
+    excludedEventNames: queryConfig.excludedEventNames,
     updatedAt: now,
   };
 }
 
+function checkpointQueryConfig(
+  checkpoint: DedicatedBackfillCheckpoint,
+): BackfillQueryConfig {
+  return {
+    lookbackDays:
+      checkpoint.version === 2
+        ? (checkpoint.lookbackDays ?? DEFAULT_LOOKBACK_DAYS)
+        : DEFAULT_LOOKBACK_DAYS,
+    lookbackStart:
+      checkpoint.version === 2 ? (checkpoint.lookbackStart ?? null) : null,
+    excludedEventNames:
+      checkpoint.version === 2 ? (checkpoint.excludedEventNames ?? []) : [],
+  };
+}
+
+function upgradeCheckpoint(
+  checkpoint: DedicatedBackfillCheckpoint,
+  queryConfig: BackfillQueryConfig,
+): DedicatedBackfillCheckpoint {
+  if (checkpoint.version === 2) {
+    return checkpoint.lookbackDays === undefined
+      ? { ...checkpoint, lookbackDays: queryConfig.lookbackDays }
+      : checkpoint;
+  }
+  for (const branch of ["org", "legacy"] as const) {
+    checkpoint.branches[branch].complete = false;
+  }
+  return {
+    ...checkpoint,
+    version: 2,
+    lookbackDays: queryConfig.lookbackDays,
+    lookbackStart: queryConfig.lookbackStart ?? undefined,
+    excludedEventNames: queryConfig.excludedEventNames,
+  };
+}
+
 function assertCheckpointMatches(
   checkpoint: DedicatedBackfillCheckpoint,
   options: DedicatedBackfillOptions,
 ): void {
-  if (checkpoint.version !== 1) {
+  if (checkpoint.version !== 1 && checkpoint.version !== 2) {
     throw new Error(
       `Unsupported backfill checkpoint version: ${checkpoint.version}`,
     );
@@ -326,6 +473,23 @@ function assertCheckpointMatches(
       "Backfill checkpoint table does not match the current BigQuery table",
     );
   }
+  if (checkpoint.version === 2) {
+    const lookbackDays = checkpoint.lookbackDays;
+    if (
+      (checkpoint.lookbackStart !== undefined &&
+        typeof checkpoint.lookbackStart !== "string") ||
+      typeof lookbackDays !== "number" ||
+      !Number.isInteger(lookbackDays) ||
+      lookbackDays < MIN_LOOKBACK_DAYS ||
+      lookbackDays > MAX_LOOKBACK_DAYS ||
+      !Array.isArray(checkpoint.excludedEventNames) ||
+      checkpoint.excludedEventNames.some((name) => typeof name !== "string")
+    ) {
+      throw new Error(
+        "Backfill checkpoint has invalid lookback or event filter metadata",
+      );
+    }
+  }
   for (const branch of ["org", "legacy"] as const) {
     const state = checkpoint.branches[branch];
     if (!state)
@@ -370,12 +534,44 @@ function compareCursors(left: BackfillCursor, right: BackfillCursor): number {
   );
 }
 
+async function hydratePageRows(
+  keyRows: Array<Record<string, unknown>>,
+  db: DbExecutor,
+): Promise<Array<Record<string, unknown>>> {
+  const rowsById = new Map<string, Record<string, unknown>>();
+  for (let offset = 0; offset < keyRows.length; offset += MAX_HYDRATION_IDS) {
+    const ids = keyRows
+      .slice(offset, offset + MAX_HYDRATION_IDS)
+      .map((row, index) => {
+        const cursor = cursorFromRow(row, `backfill key row ${offset + index}`);
+        return cursor.id;
+      });
+    const result = await db.execute(buildHydrationQuery(ids));
+    for (const row of result.rows as Array<Record<string, unknown>>) {
+      const id = row.id;
+      if (typeof id !== "string" || !id) {
+        throw new Error("Backfill hydration row is missing id");
+      }
+      rowsById.set(id, row);
+    }
+  }
+
+  return keyRows.map((keyRow, index) => {
+    const { id } = cursorFromRow(keyRow, `backfill key row ${index}`);
+    const row = rowsById.get(id);
+    if (!row) {
+      throw new Error(`Backfill row ${id} disappeared during hydration`);
+    }
+    return row;
+  });
+}
+
 export async function assertSourceAtCheckpoint(
   scope: DedicatedBackfillOptions["scope"],
   checkpoint: DedicatedBackfillCheckpoint,
   db: DbExecutor = getDbExec(),
 ): Promise<void> {
-  for (const spec of branchSpecs(scope)) {
+  for (const spec of branchSpecs(scope, checkpointQueryConfig(checkpoint))) {
     const result = await db.execute(buildHighWaterMarkQuery(spec));
     const latestRow = result.rows[0];
     if (!latestRow) continue;
@@ -483,16 +679,44 @@ export async function runDedicatedBackfill(
   dependencies: DedicatedBackfillDependencies,
 ): Promise<DedicatedBackfillResult> {
   const now = dependencies.now ?? (() => new Date().toISOString());
-  const checkpoint =
-    (await dependencies.checkpointStore.load()) ??
-    newCheckpoint(options, now());
+  const checkpointNow = now();
+  const loadedCheckpoint = await dependencies.checkpointStore.load();
+  const requestedLookbackDays = options.lookbackDays ?? DEFAULT_LOOKBACK_DAYS;
+  const requestedExcludedEventNames = options.excludedEventNames ?? [
+    ...DEFAULT_EXCLUDED_EVENT_NAMES,
+  ];
+  const queryConfig: BackfillQueryConfig = loadedCheckpoint
+    ? checkpointQueryConfig(loadedCheckpoint)
+    : {
+        lookbackDays: requestedLookbackDays,
+        lookbackStart: lookbackStart(checkpointNow, requestedLookbackDays),
+        excludedEventNames: requestedExcludedEventNames,
+      };
+  const checkpoint = loadedCheckpoint
+    ? upgradeCheckpoint(loadedCheckpoint, queryConfig)
+    : newCheckpoint(options, checkpointNow, queryConfig);
   assertCheckpointMatches(checkpoint, options);
+  if (checkpoint.version === 2) {
+    if (checkpoint.lookbackDays !== requestedLookbackDays) {
+      throw new Error(
+        "Backfill checkpoint lookback window does not match the current --lookback-days setting",
+      );
+    }
+    if (
+      JSON.stringify(checkpoint.excludedEventNames) !==
+      JSON.stringify(requestedExcludedEventNames)
+    ) {
+      throw new Error(
+        "Backfill checkpoint event filter does not match the current --skip-events setting",
+      );
+    }
+  }
   await dependencies.checkpointStore.save(checkpoint);
 
   let batches = 0;
   let copiedThisRun = 0;
   let stop = false;
-  for (const spec of branchSpecs(options.scope)) {
+  for (const spec of branchSpecs(options.scope, queryConfig)) {
     const state = checkpoint.branches[spec.name];
     if (state.complete) continue;
 
@@ -506,15 +730,16 @@ export async function runDedicatedBackfill(
         stop = true;
         break;
       }
-      const result = await dependencies.db.execute(
-        buildPageQuery(spec, state, options.batchSize),
+      const keyResult = await dependencies.db.execute(
+        buildPageKeyQuery(spec, state, options.batchSize),
       );
-      const rows = result.rows as Array<Record<string, unknown>>;
-      if (!rows.length) {
+      const keyRows = keyResult.rows as Array<Record<string, unknown>>;
+      if (!keyRows.length) {
         await refreshBranchCutoff(spec, state, checkpoint, dependencies, now);
         if (state.complete) break;
         continue;
       }
+      const rows = await hydratePageRows(keyRows, dependencies.db);
 
       const copied = await dependencies.upload(rows);
       if (copied !== rows.length) {
@@ -569,6 +794,8 @@ Options:
   --concurrency=<n>             BigQuery requests in flight, default 2, max 4
   --max-batches=<n>             Work budget per invocation, default 1000
   --checkpoint=<path>           Atomic local checkpoint path
+  --lookback-days=<n>           Source window, 30-60 days, default 60
+  --skip-events=<csv>           Event names to skip, default http.response
 
 After the checkpoint is complete, reconcile it into the shipped durable job
 after quiescing source event writes and checking the final high-water marks:
@@ -798,6 +1025,8 @@ async function main(): Promise<void> {
       batchSize: options.batchSize,
       concurrency: options.concurrency,
       maxBatches: options.maxBatches,
+      lookbackDays: options.lookbackDays,
+      excludedEventNames: options.excludedEventNames,
       checkpointPath: options.checkpointPath,
       message:
         "No data was copied. Pass --execute and AGENT_NATIVE_ANALYTICS_BIGQUERY_BACKFILL_ALLOW=1 after production approval.",

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

@@ -311,6 +311,29 @@ export const analyticsUserDays = table("analytics_user_days", {
   userKey: text("user_key").notNull(),
 });
 
+/** Atomic per-tenant event reservations used to cap future Postgres growth. */
+export const analyticsEventVolumeUsage = table(
+  "analytics_event_volume_usage",
+  {
+    id: text("id").primaryKey(),
+    tenantKey: text("tenant_key").notNull(),
+    ownerEmail: text("owner_email").notNull(),
+    orgId: text("org_id"),
+    windowStart: text("window_start").notNull(),
+    eventCount: integer("event_count").notNull().default(0),
+    eventLimit: integer("event_limit").notNull(),
+    updatedAt: text("updated_at").notNull().default(now()),
+  },
+  (t) => ({
+    tenantWindowUnique: uniqueIndex(
+      "analytics_event_volume_usage_tenant_window_idx",
+    ).on(t.tenantKey, t.windowStart),
+    updatedAtIdx: index("analytics_event_volume_usage_updated_at_idx").on(
+      t.updatedAt,
+    ),
+  }),
+);
+
 /**
  * Compact pressure signals for first-party queries that are already slow or
  * failing. Successful fast queries never write here, so the diagnostic path

package/corpus/templates/analytics/server/handlers/first-party-analytics.ts

@@ -49,7 +49,9 @@ export const handleAnalyticsTrack = defineEventHandler(async (event) => {
   } catch (err: any) {
     const message = err?.message || String(err);
     const invalidKey = /invalid analytics public key/i.test(message);
-    setResponseStatus(event, invalidKey ? 401 : 400);
+    const statusCode =
+      typeof err?.statusCode === "number" ? err.statusCode : undefined;
+    setResponseStatus(event, invalidKey ? 401 : (statusCode ?? 400));
     return { error: message };
   }
 });

package/corpus/templates/analytics/server/jobs/analytics-bigquery-backfill.ts

@@ -248,7 +248,7 @@ export async function acquireDedicatedFirstPartyAnalyticsBackfillLease(
                SET status = 'pending', lease_token = NULL,
                    lease_expires_at = NULL, next_run_at = ?, updated_at = ?
              WHERE id = ? AND lease_token = ?`,
-      args: [leaseExpiresAt, releasedAt, id, token],
+      args: [releasedAt, releasedAt, id, token],
       timeoutMs: 5_000,
       maxAttempts: 1,
     });