@agent-native/core 0.77.24 → 0.78.1

package/corpus/templates/analytics/AGENTS.md

@@ -72,15 +72,46 @@ details live in `.agents/skills/`.
   it as an extension instead and tell the user why.
 - Use framework sharing and access helpers for dashboards, analyses, and saved
   resources.
+- Dashboard email reports live in SQL via the
+  `dashboard-report-subscriptions` actions. They send daily snapshots scoped to
+  the exact user/org context that created the subscription with saved URL
+  filters; do not hand-wire custom email routes around that action surface.
+  Report PNGs are Playwright captures of the real dashboard route in
+  `reportScreenshot=1` mode, authenticated by a short-lived embed-session token
+  and embedded inline in email with a CID image. Netlify builds emit a scheduled
+  trigger plus a background worker from
+  `scripts/emit-netlify-dashboard-report-cron.ts`, using a per-deploy internal
+  token and disabling the in-process interval scheduler on Netlify to avoid
+  duplicate sends. External cron callers can still sweep due reports by POSTing
+  `/api/dashboard-reports/run` with
+  `Authorization: Bearer $DASHBOARD_REPORTS_CRON_SECRET`. PNG rendering uses
+  local Chrome in development and `playwright-core` plus
+  `@sparticuz/chromium-min` in serverless runtimes; set
+  `DASHBOARD_REPORT_CHROMIUM_PACK_URL` only when overriding the default
+  Chromium pack location.
 
 ## Application State
 
 - `navigation` exposes current dashboard, analysis, source, chart, and selected
   context.
 - `navigate` moves the user to the relevant analytics view, including
-  `view="catalog"` for the template catalog.
+  `view="catalog"` for the template catalog and `view="sessions"` for session
+  replay.
 - Use `view-screen` when the active dashboard/chart context is unclear.
 
+## Session Replay
+
+- `/sessions` lists scoped first-party session recordings. Filters live in the
+  URL (`range`, `app`, `q`) and are mirrored through application state so
+  the agent sees the same list the user sees.
+- `/sessions/:recordingId` loads summary/timeline data through
+  `get-session-replay-summary` and fetches rrweb payloads only through scoped
+  chunk routes. Do not expose storage/provider URLs, raw chunk table access, or
+  unscoped replay blobs in UI, actions, dashboards, docs, or prompts.
+- Dashboard rows that include `recording_id` should link to
+  `/sessions/:recordingId`; rows that only include `session_id` can link to a
+  filtered `/sessions` search.
+
 ## Dashboard Template Catalog
 
 - To build or extend a LARGE first-party dashboard, prefer `compose-dashboard`:

package/corpus/templates/analytics/DEVELOPING.md

@@ -148,12 +148,20 @@ When a user asks for a **chart, metrics view, or data breakdown** → add it to
 ## Build & Dev Commands
 
 ```bash
-pnpm dev        # Start dev server (frontend + backend, port 8080)
+pnpm dev        # Start dev server with local SQLite (frontend + backend, port 8080)
 pnpm build      # Production build
 pnpm typecheck  # TypeScript validation
 pnpm test       # Run Vitest tests
 ```
 
+`pnpm dev` pins `DATABASE_URL` to `file:./data/app.db` so local work does not
+accidentally touch a production database from `.env`. To intentionally test
+against another local database, set `ANALYTICS_DATABASE_URL` for that command:
+
+```bash
+ANALYTICS_DATABASE_URL=postgres://localhost/analytics_dev pnpm dev
+```
+
 ## Creating Scripts
 
 ```typescript

package/corpus/templates/analytics/actions/delete-dashboard-report-subscription.ts

@@ -0,0 +1,24 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { deleteDashboardReportSubscription } from "../server/lib/dashboard-report-subscriptions";
+
+export default defineAction({
+  description:
+    "Delete a daily email report subscription for an analytics dashboard.",
+  schema: z.object({
+    id: z.string().describe("Subscription ID to delete"),
+  }),
+  http: { method: "DELETE" },
+  run: async (args) => {
+    const email = getRequestUserEmail();
+    if (!email) throw new Error("no authenticated user");
+    const orgId = getRequestOrgId() || null;
+    await deleteDashboardReportSubscription(args.id, { email, orgId });
+    return { id: args.id, success: true };
+  },
+});

package/corpus/templates/analytics/actions/get-session-replay-events.ts

@@ -0,0 +1,50 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { getSessionReplayEvents } from "../server/lib/session-replay.js";
+
+function resolveScope() {
+  const userEmail = getRequestUserEmail();
+  if (!userEmail) throw new Error("no authenticated user");
+  return { userEmail, orgId: getRequestOrgId() || null };
+}
+
+export default defineAction({
+  description:
+    "Read sanitized replay events for a first-party Analytics session recording. Results are capped and never expose storage provider URLs or raw chunk table access.",
+  schema: z.object({
+    recordingId: z.string().describe("The session_recordings id"),
+    startSeq: z.coerce
+      .number()
+      .int()
+      .min(0)
+      .optional()
+      .describe("Optional first chunk sequence to include"),
+    endSeq: z.coerce
+      .number()
+      .int()
+      .min(0)
+      .optional()
+      .describe("Optional last chunk sequence to include"),
+    limit: z.coerce
+      .number()
+      .int()
+      .min(1)
+      .max(10000)
+      .optional()
+      .describe("Maximum replay events to return"),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async (args) => {
+    return getSessionReplayEvents(args.recordingId, resolveScope(), {
+      startSeq: args.startSeq,
+      endSeq: args.endSeq,
+      limit: args.limit,
+    });
+  },
+});

package/corpus/templates/analytics/actions/get-session-replay-summary.ts

@@ -0,0 +1,27 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { getSessionReplaySummary } from "../server/lib/session-replay.js";
+
+function resolveScope() {
+  const userEmail = getRequestUserEmail();
+  if (!userEmail) throw new Error("no authenticated user");
+  return { userEmail, orgId: getRequestOrgId() || null };
+}
+
+export default defineAction({
+  description:
+    "Get a scoped summary for one first-party Analytics session replay recording. Does not return raw chunks or storage references.",
+  schema: z.object({
+    recordingId: z.string().describe("The session_recordings id"),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async (args) => {
+    return getSessionReplaySummary(args.recordingId, resolveScope());
+  },
+});

package/corpus/templates/analytics/actions/list-dashboard-report-subscriptions.ts

@@ -0,0 +1,24 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { listDashboardReportSubscriptions } from "../server/lib/dashboard-report-subscriptions";
+
+export default defineAction({
+  description:
+    "List daily email report subscriptions for an analytics dashboard.",
+  schema: z.object({
+    dashboardId: z.string().optional().describe("Optional dashboard ID filter"),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async (args) => {
+    const email = getRequestUserEmail();
+    if (!email) throw new Error("no authenticated user");
+    const orgId = getRequestOrgId() || null;
+    return listDashboardReportSubscriptions({ email, orgId }, args.dashboardId);
+  },
+});

package/corpus/templates/analytics/actions/list-session-recordings.ts

@@ -0,0 +1,59 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { listSessionRecordings } from "../server/lib/session-replay.js";
+
+function resolveScope() {
+  const userEmail = getRequestUserEmail();
+  if (!userEmail) throw new Error("no authenticated user");
+  return { userEmail, orgId: getRequestOrgId() || null };
+}
+
+export default defineAction({
+  description:
+    "List first-party Analytics session replay recordings accessible to the current user/org. Returns scoped recording summaries only, not raw replay chunks.",
+  schema: z.object({
+    query: z
+      .string()
+      .optional()
+      .describe(
+        "Optional broad search across recording, session, visitor, URL, app, and template fields",
+      ),
+    app: z.string().optional().describe("Optional app filter"),
+    template: z.string().optional().describe("Optional template filter"),
+    sessionId: z.string().optional().describe("Optional analytics session id"),
+    userId: z.string().optional().describe("Optional signed-in user id"),
+    anonymousId: z.string().optional().describe("Optional anonymous user id"),
+    path: z.string().optional().describe("Optional exact path filter"),
+    from: z
+      .string()
+      .optional()
+      .describe("Inclusive started_at lower bound as an ISO timestamp"),
+    to: z
+      .string()
+      .optional()
+      .describe("Inclusive started_at upper bound as an ISO timestamp"),
+    minDurationMs: z.coerce
+      .number()
+      .int()
+      .min(0)
+      .optional()
+      .describe("Only include recordings at least this long"),
+    hasErrors: z.boolean().optional().describe("Only recordings with errors"),
+    hasRageClicks: z
+      .boolean()
+      .optional()
+      .describe("Only recordings with detected rage clicks"),
+    status: z.enum(["active", "completed"]).optional(),
+    limit: z.coerce.number().int().min(1).max(100).optional().default(50),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async (args) => {
+    return listSessionRecordings(resolveScope(), args);
+  },
+});

package/corpus/templates/analytics/actions/navigate.ts

@@ -4,13 +4,13 @@ import { z } from "zod";
 
 export default defineAction({
   description:
-    "Navigate the UI to a specific view or dashboard. For filter changes (dashboard filter query params like ?f_date=...), use the framework-level `set-search-params` tool instead of this action.",
+    "Navigate the UI to a specific view, dashboard, analysis, extension, or Analytics session recording. For filter changes (dashboard filter query params like ?f_date=... or session filters like ?range=30d&q=signup), use the framework-level `set-search-params` tool instead of this action.",
   schema: z.object({
     view: z
       .string()
       .optional()
       .describe(
-        "View to navigate to (overview, ask, adhoc, analyses, extensions, catalog, data-dictionary, data-sources, settings)",
+        "View to navigate to (ask, adhoc, analyses, extensions, sessions, catalog, data-dictionary, data-sources, settings)",
       ),
     dashboardId: z
       .string()
@@ -24,6 +24,10 @@ export default defineAction({
       .string()
       .optional()
       .describe("Extension ID to open (used with view=extensions)"),
+    recordingId: z
+      .string()
+      .optional()
+      .describe("Session recording id to open (used with view=sessions)"),
   }),
   http: false,
   run: async (args) => {
@@ -31,14 +35,15 @@ export default defineAction({
       !args.view &&
       !args.dashboardId &&
       !args.analysisId &&
-      !args.extensionId
+      !args.extensionId &&
+      !args.recordingId
     ) {
       throw new Error(
-        "At least --view, --dashboardId, --analysisId, or --extensionId is required.",
+        "At least --view, --dashboardId, --analysisId, --extensionId, or --recordingId is required.",
       );
     }
     const nav: Record<string, string> = {};
-    if (args.view) nav.view = args.view;
+    if (args.view) nav.view = args.view === "overview" ? "ask" : args.view;
     if (args.dashboardId) {
       nav.dashboardId = args.dashboardId;
       if (!args.view) nav.view = "adhoc";
@@ -51,6 +56,10 @@ export default defineAction({
       nav.extensionId = args.extensionId;
       if (!args.view) nav.view = "extensions";
     }
+    if (args.recordingId) {
+      nav.recordingId = args.recordingId;
+      if (!args.view) nav.view = "sessions";
+    }
     await writeAppState("navigate", nav);
 
     const parts: string[] = [];
@@ -58,6 +67,7 @@ export default defineAction({
     if (nav.dashboardId) parts.push(`dashboard:${nav.dashboardId}`);
     if (nav.analysisId) parts.push(`analysis:${nav.analysisId}`);
     if (nav.extensionId) parts.push(`extension:${nav.extensionId}`);
+    if (nav.recordingId) parts.push(`recording:${nav.recordingId}`);
     return `Navigating to ${parts.join(" ")}`;
   },
 });

package/corpus/templates/analytics/actions/query-agent-native-analytics.ts

@@ -15,12 +15,12 @@ function resolveScope() {
 
 export default defineAction({
   description:
-    "Query first-party analytics events recorded through this app's analytics collector endpoint (/track). Use this for questions about app/site traffic, product events, template/app usage, conversions, and other first-party event data in the analytics_events table when the user is asking about data collected by this analytics app. Use source-specific actions such as BigQuery, GA4, Mixpanel, PostHog, or Amplitude when the user asks for those sources or the relevant data lives there. SQL may read analytics_events only; reads are automatically scoped to the current user/org.",
+    "Query first-party analytics events recorded through this app's analytics collector endpoint (/track) and session replay summaries recorded through /api/analytics/replay. Use this for questions about app/site traffic, product events, template/app usage, conversions, session recordings, and other first-party data collected by this analytics app. Use source-specific actions such as BigQuery, GA4, Mixpanel, PostHog, or Amplitude when the user asks for those sources or the relevant data lives there. SQL may read analytics_events and session_recordings only; session_replay_chunks is intentionally unavailable, and reads are automatically scoped to the current user/org.",
   schema: z.object({
     sql: z
       .string()
       .describe(
-        "Read-only SQL over analytics_events, e.g. SELECT event_name, COUNT(*) AS events FROM analytics_events WHERE timestamp >= '2026-05-01T04:00:00Z' AND timestamp < '2026-05-02T04:00:00Z' GROUP BY event_name ORDER BY events DESC",
+        "Read-only SQL over analytics_events and session_recordings, e.g. SELECT event_name, COUNT(*) AS events FROM analytics_events WHERE timestamp >= '2026-05-01T04:00:00Z' AND timestamp < '2026-05-02T04:00:00Z' GROUP BY event_name ORDER BY events DESC",
       ),
   }),
   http: false,

package/corpus/templates/analytics/actions/save-dashboard-report-subscription.ts

@@ -0,0 +1,36 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { saveDashboardReportSubscription } from "../server/lib/dashboard-report-subscriptions";
+
+export default defineAction({
+  description:
+    "Create or update a daily email report subscription for an analytics dashboard.",
+  schema: z.object({
+    id: z.string().optional().describe("Existing subscription ID to update"),
+    dashboardId: z.string().describe("Dashboard ID to email"),
+    name: z.string().optional().describe("Human-readable subscription name"),
+    recipients: z.array(z.string().email()).min(1).describe("Email recipients"),
+    filters: z
+      .record(z.string(), z.string())
+      .optional()
+      .describe("Dashboard URL filters to apply, including f_ keys"),
+    timeOfDay: z
+      .string()
+      .regex(/^([01]\d|2[0-3]):([0-5]\d)$/)
+      .describe("Local send time in HH:mm"),
+    timezone: z.string().describe("IANA timezone for the send time"),
+    enabled: z.boolean().default(true),
+  }),
+  http: { method: "POST" },
+  run: async (args) => {
+    const email = getRequestUserEmail();
+    if (!email) throw new Error("no authenticated user");
+    const orgId = getRequestOrgId() || null;
+    return saveDashboardReportSubscription(args, { email, orgId });
+  },
+});

package/corpus/templates/analytics/actions/send-dashboard-report-now.ts

@@ -0,0 +1,60 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { sendDashboardReportSubscription } from "../server/lib/dashboard-report";
+import {
+  claimDashboardReportSubscription,
+  getDashboardReportSubscription,
+  markDashboardReportResult,
+} from "../server/lib/dashboard-report-subscriptions";
+
+export default defineAction({
+  description:
+    "Send a dashboard email report subscription immediately to its saved recipients.",
+  schema: z.object({
+    id: z.string().describe("Subscription ID to send now"),
+  }),
+  http: { method: "POST" },
+  needsApproval: true,
+  run: async (args) => {
+    const email = getRequestUserEmail();
+    if (!email) throw new Error("no authenticated user");
+    const orgId = getRequestOrgId() || null;
+    const sub = await getDashboardReportSubscription(args.id, {
+      email,
+      orgId,
+    });
+    if (!sub) {
+      throw Object.assign(new Error("Report subscription not found"), {
+        statusCode: 404,
+      });
+    }
+
+    const claimed = await claimDashboardReportSubscription(sub.id, {
+      email,
+      orgId,
+    });
+    if (!claimed) {
+      throw Object.assign(new Error("Report subscription is already sending"), {
+        statusCode: 409,
+      });
+    }
+
+    try {
+      const result = await sendDashboardReportSubscription(claimed);
+      await markDashboardReportResult(claimed, "success");
+      return { id: claimed.id, success: true, ...result };
+    } catch (err: any) {
+      await markDashboardReportResult(
+        claimed,
+        "error",
+        err?.message ?? String(err),
+      );
+      throw err;
+    }
+  },
+});

package/corpus/templates/analytics/actions/view-screen.ts

@@ -12,10 +12,19 @@ import { z } from "zod";
 import { listDashboardCatalog } from "../server/lib/dashboard-catalog";
 import { getAnalysis, getDashboard } from "../server/lib/dashboards-store";
 import { listAnalyticsPublicKeys } from "../server/lib/first-party-analytics.js";
+import {
+  getSessionReplaySummary,
+  listSessionRecordings,
+  replayRangeToIso,
+  type ReplayRange,
+} from "../server/lib/session-replay.js";
+
+const SESSION_FILTER_KEYS = new Set(["range", "app", "q"]);
+const REPLAY_RANGES = new Set(["24h", "7d", "30d", "90d", "all"]);
 
 export default defineAction({
   description:
-    "See what the user is currently looking at on screen. Returns the current view, dashboard config (if on a dashboard), analysis details (if on an analysis), and any active URL filter params. Prefer the auto-included <current-screen> block; call this only when you need a refreshed snapshot.",
+    "See what the user is currently looking at on screen. Returns the current view, dashboard config (if on a dashboard), analysis details (if on an analysis), Analytics session replay context, and any active URL filter params. Prefer the auto-included <current-screen> block; call this only when you need a refreshed snapshot.",
   schema: z.object({}),
   http: false,
   readOnly: true,
@@ -38,6 +47,13 @@ export default defineAction({
       const activeFilters: Record<string, string> = {};
       for (const [k, v] of Object.entries(url.searchParams)) {
         if (k.startsWith("f_") && v) activeFilters[k] = v;
+        if (
+          url.pathname?.startsWith("/sessions") &&
+          SESSION_FILTER_KEYS.has(k) &&
+          v
+        ) {
+          activeFilters[k] = v;
+        }
       }
       if (Object.keys(activeFilters).length > 0) {
         screen.activeFilters = activeFilters;
@@ -107,8 +123,34 @@ export default defineAction({
       if (nav?.extensionId) {
         screen.extensionId = nav.extensionId;
       }
+    } else if (nav?.view === "sessions") {
+      screen.page = nav?.recordingId ? "session-replay-detail" : "sessions";
+      const email = getRequestUserEmail();
+      if (email) {
+        const scope = { userEmail: email, orgId: getRequestOrgId() || null };
+        try {
+          if (nav?.recordingId) {
+            screen.sessionReplay = await getSessionReplaySummary(
+              nav.recordingId,
+              scope,
+            );
+          } else {
+            const params = url?.searchParams ?? {};
+            const sessions = await listSessionRecordings(scope, {
+              from:
+                replayRangeToIso(readReplayRange(params.range)) ?? undefined,
+              app: params.app,
+              query: params.q,
+              limit: 25,
+            });
+            screen.sessionReplays = sessions;
+          }
+        } catch (error: any) {
+          screen.sessionReplayError = error?.message || String(error);
+        }
+      }
     } else if (nav?.view === "overview" || nav?.view === "home" || !nav?.view) {
-      screen.page = "overview";
+      screen.page = "ask";
     } else if (nav?.view === "ask") {
       screen.page = "ask";
     } else if (nav?.view === "query") {
@@ -161,3 +203,9 @@ export default defineAction({
     return JSON.stringify(screen, null, 2);
   },
 });
+
+function readReplayRange(value: unknown): ReplayRange {
+  return typeof value === "string" && REPLAY_RANGES.has(value)
+    ? (value as ReplayRange)
+    : "30d";
+}

package/corpus/templates/analytics/app/components/dashboard/SqlChart.tsx

@@ -906,7 +906,12 @@ export function SqlChart({
   const placeholderPadY = isMetric ? "py-2" : "py-8";
 
   if (!loadData || isLoading) {
-    return <Skeleton className={`w-full flex-1 ${placeholderMinH}`} />;
+    return (
+      <Skeleton
+        data-dashboard-report-loading="true"
+        className={`w-full flex-1 ${placeholderMinH}`}
+      />
+    );
   }
 
   if (error) {
@@ -1131,6 +1136,35 @@ function renderDeltaCell(value: unknown): ReactNode {
   );
 }
 
+function rowString(
+  row: Record<string, unknown>,
+  keys: string[],
+): string | null {
+  for (const key of keys) {
+    const value = row[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return null;
+}
+
+export function sessionReplayHref(row: Record<string, unknown>): string | null {
+  const recordingId = rowString(row, [
+    "recording_id",
+    "session_recording_id",
+    "sessionRecordingId",
+  ]);
+  if (recordingId) return `/sessions/${encodeURIComponent(recordingId)}`;
+
+  const sessionId = rowString(row, ["session_id", "sessionId"]);
+  if (!sessionId) return null;
+  const params = new URLSearchParams({ range: "all", q: sessionId });
+  return `/sessions?${params.toString()}`;
+}
+
+function isSessionColumn(key: string): boolean {
+  return key === "session_id" || key === "sessionId";
+}
+
 function TableRenderer({
   rows,
   panel,
@@ -1303,6 +1337,9 @@ function TableRenderer({
                     col.format === "delta"
                       ? renderDeltaCell(raw)
                       : formatCell(raw, col.format);
+                  const replayHref = isSessionColumn(col.key)
+                    ? sessionReplayHref(row)
+                    : null;
                   return (
                     <td
                       key={col.key}
@@ -1310,7 +1347,19 @@ function TableRenderer({
                         numeric ? "text-right tabular-nums" : ""
                       }`}
                     >
-                      {content}
+                      {replayHref ? (
+                        <span className="inline-flex flex-col gap-0.5">
+                          <span>{content}</span>
+                          <a
+                            href={replayHref}
+                            className="text-xs font-medium text-primary hover:underline"
+                          >
+                            {t("sessions.watchReplay")}
+                          </a>
+                        </span>
+                      ) : (
+                        content
+                      )}
                     </td>
                   );
                 })}

package/corpus/templates/analytics/app/components/layout/Header.tsx

@@ -13,11 +13,13 @@ import {
 } from "./HeaderActions";
 
 const pageTitleKeys: Record<string, string> = {
-  "/": "navigation.overview",
+  "/": "navigation.ask",
+  "/ask": "navigation.ask",
   "/data-sources": "navigation.dataSources",
   "/data-dictionary": "navigation.dataDictionary",
   "/catalog": "navigation.templateCatalog",
   "/analyses": "navigation.analyses",
+  "/sessions": "navigation.sessions",
   "/dashboards/explorer": "navigation.explorer",
   "/team": "navigation.team",
   "/settings": "navigation.settings",
@@ -34,6 +36,7 @@ function resolveTitle(pathname: string, t: (key: string) => string): ReactNode {
   }
 
   if (pathname.startsWith("/analyses/")) return t("navigation.analyses");
+  if (pathname.startsWith("/sessions/")) return t("navigation.sessions");
 
   return t("navigation.brand");
 }

package/corpus/templates/analytics/app/components/layout/Layout.tsx

@@ -31,12 +31,14 @@ export function Layout({ children }: LayoutProps) {
   const location = useLocation();
   const navigate = useNavigate();
   const t = useT();
+  const reportScreenshot =
+    new URLSearchParams(location.search).get("reportScreenshot") === "1";
 
   // Analytics has two distinct "primary resources" — dashboards
   // (`/dashboards/:id`, legacy `/adhoc/:id`) and ad-hoc analyses
   // (`/analyses/:id`). Each binds the chat to that artifact so a dashboard
   // chat doesn't leak into a different analysis (and vice versa). The list
-  // pages and overview leave scope null so general data questions still work.
+  // pages and Ask leave scope null so general data questions still work.
   const analyticsScope = useMemo(() => {
     const dashMatch = location.pathname.match(
       /^\/(?:adhoc|dashboards)\/([^/]+)/,
@@ -84,7 +86,7 @@ export function Layout({ children }: LayoutProps) {
   const chatHomeHandoffActive = useAgentChatHomeHandoff({
     storageKey: "analytics",
     activePath: location.pathname,
-    enabled: !isAskRoute,
+    enabled: !isAskRoute && !reportScreenshot,
   });
   useAgentChatHomeHandoffLinks({
     storageKey: "analytics",
@@ -101,6 +103,16 @@ export function Layout({ children }: LayoutProps) {
     return <>{children}</>;
   }
 
+  if (reportScreenshot) {
+    return (
+      <HeaderActionsProvider>
+        <main className="min-h-screen bg-background p-6 text-foreground md:p-8">
+          {children}
+        </main>
+      </HeaderActionsProvider>
+    );
+  }
+
   const contentFrame = (
     <div className="flex h-full flex-1 flex-col overflow-hidden">
       <MobileNav />