@agent-native/core 0.119.1 → 0.119.2

package/corpus/templates/analytics/server/jobs/dashboard-report.ts

@@ -9,10 +9,26 @@ import {
 
 let running = false;
 const DEFAULT_MAX_REPORTS_PER_SWEEP = 5;
+const SERVERLESS_REPORT_DELIVERY_BUDGET_MS = 220_000;
+
+async function persistDashboardReportResult(
+  ...args: Parameters<typeof markDashboardReportResult>
+): Promise<boolean> {
+  try {
+    await markDashboardReportResult(...args);
+    return true;
+  } catch (err) {
+    console.error(
+      `[dashboard-report] Failed to persist subscription ${args[0].id} result:`,
+      err instanceof Error ? err.message : String(err),
+    );
+    return false;
+  }
+}
 
 function maxReportsPerSweep(): number {
+  if (process.env.NETLIFY === "true") return 1;
   const raw = process.env.DASHBOARD_REPORT_SWEEP_LIMIT?.trim();
-  if (!raw && process.env.NETLIFY === "true") return 1;
   if (!raw) return DEFAULT_MAX_REPORTS_PER_SWEEP;
   const parsed = Number.parseInt(raw, 10);
   return Number.isFinite(parsed) && parsed > 0
@@ -31,6 +47,10 @@ export async function runDashboardReportsOnce(): Promise<{
 }> {
   if (running) return { processed: 0, failed: 0, remaining: 0 };
   running = true;
+  const deliveryDeadlineAt =
+    process.env.NETLIFY === "true"
+      ? Date.now() + SERVERLESS_REPORT_DELIVERY_BUDGET_MS
+      : undefined;
   let processed = 0;
   let failed = 0;
   let remaining = 0;
@@ -51,8 +71,21 @@ export async function runDashboardReportsOnce(): Promise<{
           () =>
             sendDashboardReportSubscription(sub, {
               skipEmailWithoutScreenshot: retryAt !== null,
+              ...(deliveryDeadlineAt ? { deadlineAt: deliveryDeadlineAt } : {}),
             }),
         );
+        if (result.screenshotMode === "partial" && result.emailsSent) {
+          failed++;
+          const message = result.screenshotError
+            ? `Dashboard screenshot partially available: ${result.screenshotError}`
+            : "Dashboard screenshot partially available";
+          console.error(
+            `[dashboard-report] Subscription ${sub.id} sent with a partial screenshot:`,
+            message,
+          );
+          await persistDashboardReportResult(sub, "error", message);
+          continue;
+        }
         if (!result.screenshotAttached) {
           const message = result.screenshotError
             ? `Dashboard screenshot unavailable: ${result.screenshotError}`
@@ -62,12 +95,13 @@ export async function runDashboardReportsOnce(): Promise<{
               `[dashboard-report] Subscription ${sub.id} skipped sending without a screenshot, will retry:`,
               message,
             );
-            await markDashboardReportResult(
+            const persisted = await persistDashboardReportResult(
               sub,
               "error",
               `${message} (retry scheduled)`,
               { nextRunAt: retryAt },
             );
+            if (!persisted) failed++;
             continue;
           }
           failed++;
@@ -75,10 +109,10 @@ export async function runDashboardReportsOnce(): Promise<{
             `[dashboard-report] Subscription ${sub.id} sent without a screenshot:`,
             message,
           );
-          await markDashboardReportResult(sub, "error", message);
+          await persistDashboardReportResult(sub, "error", message);
           continue;
         }
-        await markDashboardReportResult(sub, "success");
+        if (!(await persistDashboardReportResult(sub, "success"))) failed++;
       } catch (err: any) {
         failed++;
         const message = err?.message ?? String(err);
@@ -86,7 +120,7 @@ export async function runDashboardReportsOnce(): Promise<{
           `[dashboard-report] Subscription ${sub.id} failed:`,
           message,
         );
-        await markDashboardReportResult(sub, "error", message);
+        await persistDashboardReportResult(sub, "error", message);
       }
     }
   } finally {

package/corpus/templates/analytics/server/lib/dashboard-report.ts

@@ -24,6 +24,7 @@ import type {
   FilterType,
   SqlDashboardConfig,
 } from "../../app/pages/adhoc/sql-dashboard/types";
+import { DASHBOARD_REPORT_READY_TIMEOUT_MS } from "../../shared/dashboard-report-timeouts.js";
 import {
   getReportDashboard,
   normalizeDashboardReportRecipients,
@@ -55,10 +56,12 @@ const DASHBOARD_REPORT_CID = "dashboard-report-snapshot";
 const LOCAL_SCREENSHOT_TIMEOUT_MS = 90_000;
 const SERVERLESS_SCREENSHOT_TIMEOUT_MS = 90_000;
 const SERVERLESS_SECOND_READY_TIMEOUT_MS = 45_000;
-// Reserve 90s under Netlify's 300s background-function limit for bounded
-// browser cleanup plus delivery to the capped recipient list.
-const SERVERLESS_CHUNKED_ATTEMPT_TIMEOUT_MS = 210_000;
+// Cap browser work separately from the sweep-level delivery deadline.
+const SERVERLESS_CHUNKED_ATTEMPT_TIMEOUT_MS = 150_000;
 const BROWSER_CLEANUP_TIMEOUT_MS = 10_000;
+const DASHBOARD_REPORT_EMAIL_TIMEOUT_MS = 10_000;
+const DASHBOARD_REPORT_EMAIL_OVERHEAD_RESERVE_MS = 5_000;
+const MAX_CAPTURE_CLEANUP_RESERVE_MS = BROWSER_CLEANUP_TIMEOUT_MS * 3;
 const SCREENSHOT_VIEWPORT_PADDING = 64;
 const MAX_DASHBOARD_REPORT_CHUNKS = 10;
 const MAX_DASHBOARD_REPORT_ATTACHMENT_BYTES = 14 * 1024 * 1024;
@@ -78,6 +81,14 @@ type LaunchedScreenshotBrowser = {
   newPage: () => Promise<any>;
 };
 
+class DashboardReportPanelMismatchError extends Error {}
+
+type DashboardPngCapture = {
+  pngs: Array<Buffer | null> | null;
+  mode: "full" | "partial" | "none";
+  error?: string;
+};
+
 function daysAgo(n: number): string {
   const d = new Date();
   d.setDate(d.getDate() - n);
@@ -387,6 +398,33 @@ async function runWithinCaptureDeadline<T>(
   }
 }
 
+async function runWithinReportDeadline<T>(
+  label: string,
+  operation: () => Promise<T>,
+  deadlineAt?: number,
+): Promise<T> {
+  if (!deadlineAt) return operation();
+  const timeoutMs = deadlineAt - Date.now();
+  if (timeoutMs <= 0)
+    throw new Error(`${label} exceeded the report delivery deadline`);
+
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      operation(),
+      new Promise<never>((_, reject) => {
+        timeout = setTimeout(
+          () =>
+            reject(new Error(`${label} exceeded the report delivery deadline`)),
+          timeoutMs,
+        );
+      }),
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
 function positiveIntEnv(name: string): number | null {
   const raw = process.env[name]?.trim();
   if (!raw) return null;
@@ -397,6 +435,8 @@ function positiveIntEnv(name: string): number | null {
 async function waitForDashboardReportReady(
   page: any,
   timeout: number,
+  consoleErrors: string[] = [],
+  failedRequests: string[] = [],
 ): Promise<boolean> {
   try {
     await page.waitForFunction(
@@ -440,9 +480,13 @@ async function waitForDashboardReportReady(
         };
       })()`)
       .catch(() => null);
+    const captureDiagnostics = { consoleErrors, failedRequests };
     const message = detail
-      ? `${err?.message ?? String(err)}; dashboard state: ${JSON.stringify(detail)}`
-      : `${err?.message ?? String(err)}; dashboard page was not inspectable`;
+      ? `${err?.message ?? String(err)}; dashboard state: ${JSON.stringify({
+          ...detail,
+          ...captureDiagnostics,
+        })}`
+      : `${err?.message ?? String(err)}; dashboard page was not inspectable; capture diagnostics: ${JSON.stringify(captureDiagnostics)}`;
     throw new Error(message);
   }
 }
@@ -469,7 +513,7 @@ async function assertDashboardReportPanelWindow(
     actualPanelIds.length !== expectedPanelIds.length ||
     actualPanelIds.some((panelId, index) => panelId !== expectedPanelIds[index])
   ) {
-    throw new Error(
+    throw new DashboardReportPanelMismatchError(
       `report chunk panel mismatch; expected=${JSON.stringify(expectedPanelIds)} actual=${JSON.stringify(actualPanelIds)}`,
     );
   }
@@ -765,6 +809,8 @@ async function captureDashboardChunk(
     await waitForDashboardReportReady(
       page,
       boundedStageTimeout(attempt.readyTimeout ?? timeout, deadlineAt),
+      consoleErrors,
+      failedRequests,
     );
     captureStage = "validating the report chunk panels";
     await assertDashboardReportPanelWindow(page, expectedPanelIds);
@@ -777,6 +823,8 @@ async function captureDashboardChunk(
         attempt.secondReadyTimeout ?? secondReadyTimeoutMs(),
         deadlineAt,
       ),
+      consoleErrors,
+      failedRequests,
     );
     captureStage = "revalidating the report chunk panels";
     await assertDashboardReportPanelWindow(page, expectedPanelIds);
@@ -793,6 +841,7 @@ async function captureDashboardChunk(
     if (!image?.length) throw new Error("Dashboard screenshot was empty");
     return Buffer.from(image);
   } catch (err) {
+    if (err instanceof DashboardReportPanelMismatchError) throw err;
     throw new Error(`${captureStage}: ${errorMessage(err)}`);
   }
 }
@@ -800,7 +849,9 @@ async function captureDashboardChunk(
 async function captureDashboardPngChunks(
   sub: DashboardReportSubscription,
   snapshot: ReportSnapshot,
-): Promise<Buffer[]> {
+  allowPartialCapture: boolean,
+  totalTimeoutMs?: number,
+): Promise<DashboardPngCapture> {
   const offsets = reportChunkOffsets(snapshot.panelIds.length);
   if (offsets.length > MAX_DASHBOARD_REPORT_CHUNKS) {
     throw new Error(
@@ -814,9 +865,9 @@ async function captureDashboardPngChunks(
     captureScale: 0.7,
     ...(serverless
       ? {
-          readyTimeout: 35_000,
+          readyTimeout: DASHBOARD_REPORT_READY_TIMEOUT_MS,
           secondReadyTimeout: 15_000,
-          totalTimeout: SERVERLESS_CHUNKED_ATTEMPT_TIMEOUT_MS,
+          totalTimeout: totalTimeoutMs ?? SERVERLESS_CHUNKED_ATTEMPT_TIMEOUT_MS,
         }
       : {}),
   };
@@ -834,6 +885,7 @@ async function captureDashboardPngChunks(
         if (browser) void browser.close().catch(() => {});
       }, attempt.totalTimeout)
     : null;
+  const images: Array<Buffer | null> = Array(offsets.length).fill(null);
   try {
     launchPromise = launchScreenshotBrowser(attempt.viewport);
     const launched = attempt.totalTimeout
@@ -854,9 +906,8 @@ async function captureDashboardPngChunks(
       : await launchPromise;
     browser = launched.browser;
     cleanup = launched.cleanup;
-    const images: Buffer[] = [];
     let attachmentBytes = 0;
-    for (const offset of offsets) {
+    for (const [index, offset] of offsets.entries()) {
       if (attemptTimedOut)
         throw new Error(`capture exceeded ${attempt.totalTimeout}ms`);
       const page = await runWithinCaptureDeadline(
@@ -887,21 +938,35 @@ async function captureDashboardPngChunks(
             `complete dashboard images total ${attachmentBytes} bytes; email delivery supports at most ${MAX_DASHBOARD_REPORT_ATTACHMENT_BYTES} bytes`,
           );
         }
-        images.push(image);
+        images[index] = image;
       } finally {
         await runBoundedBrowserCleanup("Failed to close screenshot page", () =>
           page.close(),
         );
       }
     }
-    return images;
+    return { pngs: images, mode: "full" };
   } catch (err) {
+    const partialCapture =
+      allowPartialCapture &&
+      !(err instanceof DashboardReportPanelMismatchError) &&
+      images.some((image) => image !== null);
+    const suffix = attemptTimedOut
+      ? `${memoryDiagnostics()} ${attempt.label} capture exceeded ${attempt.totalTimeout}ms: ${errorMessage(err)}`
+      : `${attempt.label}: ${errorMessage(err)}`;
+    if (partialCapture) {
+      return {
+        pngs: images,
+        mode: "partial",
+        error: suffix.includes("lambdaMemoryMb=")
+          ? suffix
+          : `${suffix}; ${memoryDiagnostics()}`,
+      };
+    }
     if (attemptTimedOut) {
-      throw new Error(
-        `${memoryDiagnostics()} ${attempt.label} capture exceeded ${attempt.totalTimeout}ms: ${errorMessage(err)}`,
-      );
+      throw new Error(suffix);
     }
-    throw new Error(`${attempt.label}: ${errorMessage(err)}`);
+    throw new Error(suffix);
   } finally {
     if (attemptTimeout) clearTimeout(attemptTimeout);
     if (launchTimeout) clearTimeout(launchTimeout);
@@ -940,22 +1005,35 @@ function errorMessage(err: unknown): string {
 async function captureDashboardPngWithFallback(
   sub: DashboardReportSubscription,
   snapshot: ReportSnapshot,
-): Promise<{
-  pngs: Buffer[] | null;
-  mode: "full" | "none";
-  error?: string;
-}> {
+  allowPartialCapture: boolean,
+  totalTimeoutMs?: number,
+): Promise<DashboardPngCapture> {
+  if (totalTimeoutMs !== undefined && totalTimeoutMs <= 0) {
+    return {
+      pngs: null,
+      mode: "none",
+      error: `report delivery deadline left no time for capture; ${memoryDiagnostics()}`,
+    };
+  }
   try {
-    const pngs = await captureDashboardPngChunks(sub, snapshot);
+    const capture = await captureDashboardPngChunks(
+      sub,
+      snapshot,
+      allowPartialCapture,
+      totalTimeoutMs,
+    );
     if (isServerlessBrowserRuntime()) {
       console.info(
-        `[dashboard-report] complete chunked capture succeeded: chunks=${pngs.length} ${memoryDiagnostics()}`,
+        `[dashboard-report] ${capture.mode} chunked capture finished: chunks=${capture.pngs?.filter(Boolean).length ?? 0}/${capture.pngs?.length ?? 0} ${memoryDiagnostics()}`,
       );
     }
-    return {
-      pngs,
-      mode: "full",
-    };
+    if (capture.mode === "partial") {
+      console.error(
+        `[dashboard-report] partial chunked screenshot capture for subscription ${sub.id}:`,
+        capture.error,
+      );
+    }
+    return capture;
   } catch (err) {
     const rawError = errorMessage(err).replace(/\s+/g, " ").trim();
     const error = rawError.includes("lambdaMemoryMb=")
@@ -980,24 +1058,25 @@ function reportDate(snapshot: ReportSnapshot): string {
 function renderReportEmailHtml(
   snapshot: ReportSnapshot,
   options: {
-    screenshotAttached: boolean;
-    screenshotCount: number;
+    screenshotParts: Array<Buffer | null>;
   },
 ): string {
   const title = escapeHtml(snapshot.title);
   const dashboardUrl = escapeHtml(snapshot.dashboardUrl);
   const reportSettingsUrl = escapeHtml(snapshot.reportSettingsUrl);
   const date = escapeHtml(reportDate(snapshot));
-  const screenshotBlock = options.screenshotAttached
-    ? Array.from(
-        { length: options.screenshotCount },
-        (
-          _,
-          index,
-        ) => `<a href="${dashboardUrl}" style="display:block;text-decoration:none;">
-      <img src="cid:${DASHBOARD_REPORT_CID}-${index + 1}" alt="${title}${options.screenshotCount > 1 ? ` (part ${index + 1})` : ""}" width="100%" style="display:block;width:100%;max-width:1280px;height:auto;border:0;outline:0;border-radius:0;" />
-    </a>`,
-      ).join("\n")
+  const screenshotBlock = options.screenshotParts.some(Boolean)
+    ? options.screenshotParts
+        .map((screenshot, index) =>
+          screenshot
+            ? `<a href="${dashboardUrl}" style="display:block;text-decoration:none;">
+      <img src="cid:${DASHBOARD_REPORT_CID}-${index + 1}" alt="${title}${options.screenshotParts.length > 1 ? ` (part ${index + 1})` : ""}" width="100%" style="display:block;width:100%;max-width:1280px;height:auto;border:0;outline:0;border-radius:0;" />
+    </a>`
+            : `<div style="margin:18px 0;padding:14px 16px;border:1px solid #e5e7eb;border-radius:8px;background:#f9fafb;color:#374151;font-size:14px;line-height:1.5;">
+      Dashboard image part ${index + 1} was unavailable for this run. Open the live dashboard to view the latest report.
+    </div>`,
+        )
+        .join("\n")
     : `<div style="margin:18px 0;padding:14px 16px;border:1px solid #e5e7eb;border-radius:8px;background:#f9fafb;color:#374151;font-size:14px;line-height:1.5;">
       The dashboard image was unavailable for this run. Open the live dashboard to view the latest report.
     </div>`;
@@ -1021,7 +1100,7 @@ function renderReportEmailHtml(
 function renderReportText(
   snapshot: ReportSnapshot,
   options: {
-    screenshotAttached: boolean;
+    screenshotParts: Array<Buffer | null>;
   },
 ): string {
   const lines = [
@@ -1030,8 +1109,15 @@ function renderReportText(
     `Open dashboard: ${snapshot.dashboardUrl}`,
     `Edit subscription settings: ${snapshot.reportSettingsUrl}`,
   ];
-  if (!options.screenshotAttached) {
+  if (!options.screenshotParts.some(Boolean)) {
     lines.push("Dashboard image unavailable for this run.");
+  } else {
+    for (const [index, screenshot] of options.screenshotParts.entries()) {
+      if (!screenshot)
+        lines.push(
+          `Dashboard image part ${index + 1} unavailable for this run.`,
+        );
+    }
   }
   return lines.join("\n");
 }
@@ -1051,26 +1137,46 @@ export async function sendDashboardReportSubscription(
   options: {
     requireScreenshot?: boolean;
     skipEmailWithoutScreenshot?: boolean;
+    deadlineAt?: number;
   } = {},
 ): Promise<{
   dashboardUrl: string;
   recipientCount: number;
   screenshotAttached: boolean;
-  screenshotMode: "full" | "none";
+  screenshotMode: "full" | "partial" | "none";
   screenshotError?: string;
   emailsSent: boolean;
 }> {
   const recipients = normalizeDashboardReportRecipients(sub.recipients);
-  const snapshot = await collectReportSnapshot(sub);
-  const capture = await captureDashboardPngWithFallback(sub, snapshot);
-  if (!capture.pngs && options.requireScreenshot) {
+  const snapshot = await runWithinReportDeadline(
+    "Dashboard report snapshot",
+    () => collectReportSnapshot(sub),
+    options.deadlineAt,
+  );
+  const captureTimeoutMs = options.deadlineAt
+    ? Math.min(
+        SERVERLESS_CHUNKED_ATTEMPT_TIMEOUT_MS,
+        options.deadlineAt -
+          Date.now() -
+          MAX_CAPTURE_CLEANUP_RESERVE_MS -
+          recipients.length * DASHBOARD_REPORT_EMAIL_TIMEOUT_MS -
+          DASHBOARD_REPORT_EMAIL_OVERHEAD_RESERVE_MS,
+      )
+    : undefined;
+  const capture = await captureDashboardPngWithFallback(
+    sub,
+    snapshot,
+    !options.skipEmailWithoutScreenshot && !options.requireScreenshot,
+    captureTimeoutMs,
+  );
+  if (capture.mode !== "full" && options.requireScreenshot) {
     throw new Error(
       capture.error
         ? `Dashboard screenshot unavailable: ${capture.error}`
         : "Dashboard screenshot unavailable",
     );
   }
-  if (!capture.pngs && options.skipEmailWithoutScreenshot) {
+  if (capture.mode !== "full" && options.skipEmailWithoutScreenshot) {
     return {
       dashboardUrl: snapshot.dashboardUrl,
       recipientCount: recipients.length,
@@ -1080,35 +1186,53 @@ export async function sendDashboardReportSubscription(
       ...(capture.error ? { screenshotError: capture.error } : {}),
     };
   }
-  const screenshotAttached = Boolean(capture.pngs?.length);
+  const screenshotAttached = Boolean(capture.pngs?.some(Boolean));
+  const screenshotParts = capture.pngs ?? [];
   const html = renderReportEmailHtml(snapshot, {
-    screenshotAttached,
-    screenshotCount: capture.pngs?.length ?? 0,
+    screenshotParts,
   });
   const text = renderReportText(snapshot, {
-    screenshotAttached,
+    screenshotParts,
   });
   const subject = `Daily dashboard: ${snapshot.title}`;
 
   for (const to of recipients) {
+    const emailTimeoutMs = options.deadlineAt
+      ? Math.min(
+          DASHBOARD_REPORT_EMAIL_TIMEOUT_MS,
+          options.deadlineAt - Date.now(),
+        )
+      : DASHBOARD_REPORT_EMAIL_TIMEOUT_MS;
+    if (emailTimeoutMs <= 0) {
+      throw new Error(
+        "Dashboard email delivery exceeded the report delivery deadline",
+      );
+    }
     await sendEmail({
       to,
       subject,
       html,
       text,
       attachments: capture.pngs
-        ? capture.pngs.map((png, index) => ({
-            filename: reportFilename(
-              snapshot.title,
-              index + 1,
-              capture.pngs!.length,
-            ),
-            content: png,
-            contentType: "image/png",
-            contentId: `${DASHBOARD_REPORT_CID}-${index + 1}`,
-            disposition: "inline",
-          }))
+        ? capture.pngs.flatMap((png, index) =>
+            png
+              ? [
+                  {
+                    filename: reportFilename(
+                      snapshot.title,
+                      index + 1,
+                      capture.pngs!.length,
+                    ),
+                    content: png,
+                    contentType: "image/png",
+                    contentId: `${DASHBOARD_REPORT_CID}-${index + 1}`,
+                    disposition: "inline",
+                  },
+                ]
+              : [],
+          )
         : undefined,
+      timeoutMs: emailTimeoutMs,
     });
   }
 

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

@@ -1,6 +1,7 @@
 import { getDbExec } from "@agent-native/core/db";
 import { and, eq, isNull, or } from "drizzle-orm";
 
+import { FIRST_PARTY_ANALYTICS_QUERY_TIMEOUT_MS } from "../../shared/dashboard-report-timeouts.js";
 import { getDb, schema } from "../db/index.js";
 import {
   EXCEPTION_EVENT_NAME,
@@ -642,6 +643,8 @@ export async function queryFirstPartyAnalytics(
   const result = await exec.execute({
     sql: `SELECT * FROM (${scoped.sql}) AS first_party_analytics_query LIMIT ${MAX_QUERY_ROWS}`,
     args: scoped.args,
+    timeoutMs: FIRST_PARTY_ANALYTICS_QUERY_TIMEOUT_MS,
+    maxAttempts: 1,
   });
   const rows = result.rows as Record<string, unknown>[];
   return { rows, schema: inferSchema(rows) };

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

@@ -393,6 +393,20 @@ export function repairFirstPartyObservedRetentionPanels(
         description: RECURRING_USERS_WEEKLY_DESCRIPTION,
       },
     ],
+    [
+      "dau-over-time",
+      {
+        legacySql: [LEGACY_DAU_BY_TEMPLATE_SQL],
+        sql: DAU_BY_TEMPLATE_SQL,
+      },
+    ],
+    [
+      "wau-over-time",
+      {
+        legacySql: [LEGACY_WAU_BY_TEMPLATE_SQL],
+        sql: WAU_BY_TEMPLATE_SQL,
+      },
+    ],
     ...additionalReplacements.map(
       (replacement) => [replacement.id, replacement] as const,
     ),
@@ -437,8 +451,10 @@ export function repairFirstPartyObservedRetentionPanels(
     ? { config: { ...config, panels }, changed }
     : { config, changed };
 }
-const DAU_BY_TEMPLATE_SQL = `SELECT ${EVENT_DATE_SQL} AS date, ${TEMPLATE_EXPR} AS template, COUNT(DISTINCT ${SIGNED_IN_ACTIVITY_KEY_SQL}) AS visitors FROM analytics_events WHERE ${SIGNED_IN_ACTIVITY_FILTER} AND ${DASHBOARD_TIME_RANGE_FILTER} AND ${DASHBOARD_EMAIL_FILTER} AND ${KNOWN_PRODUCT_ACTIVITY_TEMPLATE_FILTER} GROUP BY ${EVENT_DATE_SQL}, ${TEMPLATE_EXPR} ORDER BY date, template`;
-const WAU_BY_TEMPLATE_SQL = `WITH base AS (SELECT ${SIGNED_IN_ACTIVITY_KEY_SQL} AS visitor_key, ${TEMPLATE_EXPR} AS template, ${EVENT_DATE_SQL} AS event_date, user_id FROM analytics_events WHERE ${SIGNED_IN_ACTIVITY_FILTER} AND ${DASHBOARD_EMAIL_FILTER} AND ${KNOWN_PRODUCT_ACTIVITY_TEMPLATE_FILTER} AND ${DASHBOARD_WAU_BASE_RANGE_FILTER}), days AS (SELECT DISTINCT event_date AS date FROM base WHERE ${DASHBOARD_EVENT_DATE_RANGE_FILTER}) SELECT d.date, b.template, COUNT(DISTINCT b.visitor_key) AS visitors FROM days d JOIN base b ON b.event_date >= to_char(d.date::date - INTERVAL '6 days', 'YYYY-MM-DD') AND b.event_date <= d.date GROUP BY d.date, b.template ORDER BY d.date, b.template`;
+export const LEGACY_DAU_BY_TEMPLATE_SQL = `SELECT ${EVENT_DATE_SQL} AS date, ${TEMPLATE_EXPR} AS template, COUNT(DISTINCT ${SIGNED_IN_ACTIVITY_KEY_SQL}) AS visitors FROM analytics_events WHERE ${SIGNED_IN_ACTIVITY_FILTER} AND ${DASHBOARD_TIME_RANGE_FILTER} AND ${DASHBOARD_EMAIL_FILTER} AND ${KNOWN_PRODUCT_ACTIVITY_TEMPLATE_FILTER} GROUP BY ${EVENT_DATE_SQL}, ${TEMPLATE_EXPR} ORDER BY date, template`;
+const DAU_BY_TEMPLATE_SQL = `SELECT ${EVENT_DATE_SQL} AS date, ${TEMPLATE_EXPR} AS template, COUNT(DISTINCT user_key) AS visitors FROM analytics_events WHERE ${SIGNED_IN_ACTIVITY_FILTER} AND ${DASHBOARD_TIME_RANGE_FILTER} AND ${DASHBOARD_EMAIL_FILTER} AND ${KNOWN_PRODUCT_ACTIVITY_TEMPLATE_FILTER} GROUP BY ${EVENT_DATE_SQL}, ${TEMPLATE_EXPR} ORDER BY date, template`;
+export const LEGACY_WAU_BY_TEMPLATE_SQL = `WITH base AS (SELECT ${SIGNED_IN_ACTIVITY_KEY_SQL} AS visitor_key, ${TEMPLATE_EXPR} AS template, ${EVENT_DATE_SQL} AS event_date, user_id FROM analytics_events WHERE ${SIGNED_IN_ACTIVITY_FILTER} AND ${DASHBOARD_EMAIL_FILTER} AND ${KNOWN_PRODUCT_ACTIVITY_TEMPLATE_FILTER} AND ${DASHBOARD_WAU_BASE_RANGE_FILTER}), days AS (SELECT DISTINCT event_date AS date FROM base WHERE ${DASHBOARD_EVENT_DATE_RANGE_FILTER}) SELECT d.date, b.template, COUNT(DISTINCT b.visitor_key) AS visitors FROM days d JOIN base b ON b.event_date >= to_char(d.date::date - INTERVAL '6 days', 'YYYY-MM-DD') AND b.event_date <= d.date GROUP BY d.date, b.template ORDER BY d.date, b.template`;
+const WAU_BY_TEMPLATE_SQL = `WITH base AS (SELECT user_key AS visitor_key, ${TEMPLATE_EXPR} AS template, ${EVENT_DATE_SQL} AS event_date, user_id FROM analytics_events WHERE ${SIGNED_IN_ACTIVITY_FILTER} AND ${DASHBOARD_EMAIL_FILTER} AND ${KNOWN_PRODUCT_ACTIVITY_TEMPLATE_FILTER} AND ${DASHBOARD_WAU_BASE_RANGE_FILTER}), days AS (SELECT DISTINCT event_date AS date FROM base WHERE ${DASHBOARD_EVENT_DATE_RANGE_FILTER}) SELECT d.date, b.template, COUNT(DISTINCT b.visitor_key) AS visitors FROM days d JOIN base b ON b.event_date >= to_char(d.date::date - INTERVAL '6 days', 'YYYY-MM-DD') AND b.event_date <= d.date GROUP BY d.date, b.template ORDER BY d.date, b.template`;
 
 /**
  * Catalog entries. Order here is the default panel order when a caller passes

package/corpus/templates/analytics/shared/dashboard-report-timeouts.ts

@@ -0,0 +1,3 @@
+export const FIRST_PARTY_ANALYTICS_QUERY_TIMEOUT_MS = 30_000;
+export const DASHBOARD_REPORT_ACTION_TIMEOUT_MS = 38_000;
+export const DASHBOARD_REPORT_READY_TIMEOUT_MS = 45_000;

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

@@ -35,6 +35,34 @@ Then implement working code that is cohesive, accessible, responsive, and polish
 
 Default to Apple/Linear-level restraint: make the primary workflow obvious, then remove everything that does not help that workflow right now. A polished UI often has fewer visible controls, fewer borders, fewer labels, and fewer explanatory surfaces than the first reasonable implementation.
 
+### Progressive Disclosure Is A Design Requirement
+
+Treat an all-at-once interface as a defect to fix during design, not as a
+styling preference. Before coding, inventory every piece of content and action
+on the surface, then assign each one to the smallest useful visibility level:
+
+1. **Immediate** — the page title, current state, one primary action, and the
+   compact context needed to choose what to do next.
+2. **Expanded** — the details needed for the selected item or active workflow.
+3. **On demand** — advanced settings, diagnostics, credentials, metadata,
+   destructive actions, documentation, and rarely used tools.
+
+Use single-select accordions or simple disclosure rows for sibling panels when
+the user is choosing one item at a time. Inside an expanded panel, keep another
+layer for independent concerns instead of dumping every form, explanation, and
+secondary action into the first reveal. Prefer one flat panel with alignment,
+dividers, and whitespace over nested cards; provider or product icons should
+not receive decorative borders or containers unless the container communicates
+state or interaction. A collapsed row should still show the item name, status,
+and a concise summary so the user can scan the whole surface without opening
+everything.
+
+Before shipping, ask: “What can disappear until the user asks for it?” Then
+verify collapsed, expanded, loading, empty, error, and narrow-width states.
+If the first viewport contains multiple forms, repeated explanatory copy,
+documentation links, and controls for unrelated tasks, the surface has not
+passed this requirement yet.
+
 - **Start by subtracting**: Before adding a visible control, banner, toolbar row, card, or explanatory block, ask what can be removed, merged, renamed, or moved into an existing affordance.
 - **One primary action**: Each surface should have one dominant next action. Secondary actions belong in menus, popovers, command palettes, disclosure rows, or contextual hover/focus states unless they are used constantly.
 - **Progressively disclose rare work**: Advanced options, diagnostics, metadata, settings, import/export, destructive actions, and inspection tools should stay tucked away until requested. Prefer small icon triggers with tooltips, popovers, drawers, or detail panels over permanent chrome.

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

@@ -68,10 +68,9 @@ export function Layout({ children }: LayoutProps) {
   useAgentChatHomeHandoffLinks({
     storageKey: ASSETS_CHAT_STORAGE_KEY,
     isChatPath: (pathname) => pathname === "/" || pathname.startsWith("/chat/"),
-    // A direct /chat/:id link already names the thread and must preserve the
-    // normal chat-to-sidebar transition. Only the empty home chat needs the
-    // recent marker that proves an agent handoff is in flight.
-    requireActiveHandoff: false,
+    // Only preserve the transition when chat activity has recorded an active
+    // handoff; an empty home chat should keep the destination sidebar closed.
+    requireActiveHandoff: true,
   });
 
   useEffect(() => {

package/corpus/templates/assets/app/components/layout/Sidebar.tsx

@@ -240,7 +240,7 @@ function AssetsChatsSection() {
   }
 
   return (
-    <div className="mt-2 border-s border-border/70 ps-3">
+    <div className="mt-2 ms-4">
       <ChatHistoryRail
         items={chatItems}
         activeId={displayedActiveThreadId}

package/corpus/templates/assets/app/global.css

@@ -92,11 +92,6 @@
   background: hsl(var(--muted-foreground) / 0.4);
 }
 
-.assets-create-chat-panel [data-agent-empty-state="centered"] {
-  justify-content: center;
-  padding-bottom: clamp(4rem, 12vh, 8rem);
-}
-
 .assets-create-chat-intro {
   display: none;
 }