@agent-native/core 0.145.5 → 0.145.6

package/corpus/templates/analytics/app/pages/adhoc/sql-dashboard/index.tsx

@@ -119,6 +119,7 @@ import {
 } from "@/lib/dashboard-report-capture";
 import { incrementItemView } from "@/lib/item-popularity";
 import {
+  dashboardCacheScope,
   sqlDashboardPrefetchKey,
   type PrefetchSnapshot,
 } from "@/lib/prefetch-keys";
@@ -570,6 +571,7 @@ function SqlDashboardPageContent({
   const { id: routeId } = useParams<{ id: string }>();
   const queryClient = useQueryClient();
   const navigate = useNavigate();
+  const dashboardScope = dashboardCacheScope(session);
   const dashboardId = searchParams.get("id") || routeId;
   const reportSettingsRequested = searchParams.get("reportSettings") === "1";
 
@@ -689,7 +691,7 @@ function SqlDashboardPageContent({
   // writes show up without a manual refresh"; see `use-change-version.ts`.
   const sync = useChangeVersions(["dashboards", "action"]);
   const dashboardQuery = useQuery({
-    queryKey: ["data", "sql-dashboard", dashboardId, sync],
+    queryKey: ["data", "sql-dashboard", dashboardId, dashboardScope, sync],
     enabled: !!dashboardId,
     queryFn: async () => {
       if (!dashboardId) return null;
@@ -700,17 +702,16 @@ function SqlDashboardPageContent({
       ? DASHBOARD_REPORT_BOOTSTRAP_RETRY_DELAY_MS
       : undefined,
     staleTime: 30_000,
-    placeholderData: (prev) => prev,
     initialData: () => {
       if (!dashboardId) return undefined;
       const snapshot = queryClient.getQueryData<
         PrefetchSnapshot<FetchedDashboard | null>
-      >(sqlDashboardPrefetchKey(dashboardId));
+      >(sqlDashboardPrefetchKey(dashboardId, dashboardScope));
       return dashboardPrefetchInitialData(snapshot, sync);
     },
     initialDataUpdatedAt: () => {
       if (!dashboardId) return undefined;
-      const queryKey = sqlDashboardPrefetchKey(dashboardId);
+      const queryKey = sqlDashboardPrefetchKey(dashboardId, dashboardScope);
       const snapshot =
         queryClient.getQueryData<PrefetchSnapshot<FetchedDashboard | null>>(
           queryKey,
@@ -754,18 +755,20 @@ function SqlDashboardPageContent({
     (updated: SqlDashboardConfig) => {
       if (!dashboardId) return;
       queryClient.setQueriesData<FetchedDashboard | null>(
-        { queryKey: ["data", "sql-dashboard", dashboardId] },
+        {
+          queryKey: ["data", "sql-dashboard", dashboardId, dashboardScope],
+        },
         (prev) => (prev ? { ...prev, config: updated } : prev),
       );
       queryClient.setQueryData<PrefetchSnapshot<FetchedDashboard | null>>(
-        sqlDashboardPrefetchKey(dashboardId),
+        sqlDashboardPrefetchKey(dashboardId, dashboardScope),
         (prev) =>
           prev?.data
             ? { ...prev, data: { ...prev.data, config: updated } }
             : prev,
       );
     },
-    [dashboardId, queryClient],
+    [dashboardId, dashboardScope, queryClient],
   );
 
   const holdDashboardConfig = useCallback(() => {
@@ -775,10 +778,12 @@ function SqlDashboardPageContent({
       currentUpdatedAt: dashboardUpdatedAt,
     });
     void queryClient.cancelQueries(
-      { queryKey: ["data", "sql-dashboard", dashboardId] },
+      {
+        queryKey: ["data", "sql-dashboard", dashboardId, dashboardScope],
+      },
       { revert: false },
     );
-  }, [dashboardId, dashboardUpdatedAt, queryClient]);
+  }, [dashboardId, dashboardScope, dashboardUpdatedAt, queryClient]);
 
   // Track which panels remote users are editing (from awareness)
   const [remoteEditingPanels, setRemoteEditingPanels] = useState<
@@ -872,7 +877,7 @@ function SqlDashboardPageContent({
     resetRevisionNavigation();
     revisionRestoreInFlightRef.current = false;
     if (!dashboardId) setLoaded(true);
-  }, [dashboardId, resetRevisionNavigation]);
+  }, [dashboardId, dashboardScope, resetRevisionNavigation]);
 
   useEffect(() => {
     if (!dashboardId || !dashboardQuery.isSuccess) return;
@@ -1075,16 +1080,16 @@ function SqlDashboardPageContent({
         .then(({ isLatest }) => {
           if (!isLatest) return;
           queryClient.removeQueries({
-            queryKey: sqlDashboardPrefetchKey(dashboardId),
+            queryKey: sqlDashboardPrefetchKey(dashboardId, dashboardScope),
           });
           queryClient.invalidateQueries({
-            queryKey: ["sql-dashboards-sidebar"],
+            queryKey: ["sql-dashboards-sidebar", dashboardScope],
           });
           queryClient.invalidateQueries({
-            queryKey: ["sql-dashboards-palette"],
+            queryKey: ["sql-dashboards-palette", dashboardScope],
           });
           queryClient.invalidateQueries({
-            queryKey: ["data", "sql-dashboard", dashboardId],
+            queryKey: ["data", "sql-dashboard", dashboardId, dashboardScope],
           });
         })
         .catch((err) => {
@@ -1099,6 +1104,7 @@ function SqlDashboardPageContent({
     },
     [
       dashboardId,
+      dashboardScope,
       canEdit,
       enqueueDashboardSave,
       holdDashboardConfig,
@@ -1126,16 +1132,21 @@ function SqlDashboardPageContent({
       setDashboard(updated);
       updateCachedDashboardConfig(updated);
       queryClient.removeQueries({
-        queryKey: sqlDashboardPrefetchKey(dashboardId),
+        queryKey: sqlDashboardPrefetchKey(dashboardId, dashboardScope),
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["sql-dashboards-sidebar", dashboardScope],
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["sql-dashboards-palette", dashboardScope],
       });
-      queryClient.invalidateQueries({ queryKey: ["sql-dashboards-sidebar"] });
-      queryClient.invalidateQueries({ queryKey: ["sql-dashboards-palette"] });
       queryClient.invalidateQueries({
-        queryKey: ["data", "sql-dashboard", dashboardId],
+        queryKey: ["data", "sql-dashboard", dashboardId, dashboardScope],
       });
     },
     [
       dashboardId,
+      dashboardScope,
       canEdit,
       enqueueDashboardSave,
       holdDashboardConfig,
@@ -1596,16 +1607,27 @@ function SqlDashboardPageContent({
     if (!dashboardId) return;
     if (!canManage) return;
     await deleteDashboardAction({ id: dashboardId });
-    queryClient.invalidateQueries({ queryKey: ["sql-dashboards-sidebar"] });
-    queryClient.invalidateQueries({ queryKey: ["sql-dashboards-palette"] });
+    queryClient.invalidateQueries({
+      queryKey: ["sql-dashboards-sidebar", dashboardScope],
+    });
+    queryClient.invalidateQueries({
+      queryKey: ["sql-dashboards-palette", dashboardScope],
+    });
     queryClient.removeQueries({
-      queryKey: sqlDashboardPrefetchKey(dashboardId),
+      queryKey: sqlDashboardPrefetchKey(dashboardId, dashboardScope),
     });
     queryClient.invalidateQueries({
-      queryKey: ["data", "sql-dashboard", dashboardId],
+      queryKey: ["data", "sql-dashboard", dashboardId, dashboardScope],
     });
     navigate("/");
-  }, [dashboardId, canManage, deleteDashboardAction, queryClient, navigate]);
+  }, [
+    dashboardId,
+    dashboardScope,
+    canManage,
+    deleteDashboardAction,
+    queryClient,
+    navigate,
+  ]);
 
   const dismissDemoIntro = useCallback(() => {
     setSearchParams(
@@ -1624,12 +1646,14 @@ function SqlDashboardPageContent({
     if (archivedAt) return;
     try {
       await archiveDashboardAction({ id: dashboardId, archived: true });
-      queryClient.invalidateQueries({ queryKey: ["sql-dashboards-sidebar"] });
+      queryClient.invalidateQueries({
+        queryKey: ["sql-dashboards-sidebar", dashboardScope],
+      });
       queryClient.removeQueries({
-        queryKey: sqlDashboardPrefetchKey(dashboardId),
+        queryKey: sqlDashboardPrefetchKey(dashboardId, dashboardScope),
       });
       queryClient.invalidateQueries({
-        queryKey: ["data", "sql-dashboard", dashboardId],
+        queryKey: ["data", "sql-dashboard", dashboardId, dashboardScope],
       });
       toast.success(`Archived "${dashboard?.name ?? "dashboard"}"`);
       navigate("/");
@@ -1640,6 +1664,7 @@ function SqlDashboardPageContent({
     }
   }, [
     dashboardId,
+    dashboardScope,
     canEdit,
     archivedAt,
     archiveDashboardAction,
@@ -1659,13 +1684,17 @@ function SqlDashboardPageContent({
       if (typeof result?.ownerEmail === "string") {
         setDashboardOwner(result.ownerEmail);
       }
-      queryClient.invalidateQueries({ queryKey: ["sql-dashboards-sidebar"] });
-      queryClient.invalidateQueries({ queryKey: ["sql-dashboards-palette"] });
+      queryClient.invalidateQueries({
+        queryKey: ["sql-dashboards-sidebar", dashboardScope],
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["sql-dashboards-palette", dashboardScope],
+      });
       queryClient.removeQueries({
-        queryKey: sqlDashboardPrefetchKey(dashboardId),
+        queryKey: sqlDashboardPrefetchKey(dashboardId, dashboardScope),
       });
       queryClient.invalidateQueries({
-        queryKey: ["data", "sql-dashboard", dashboardId],
+        queryKey: ["data", "sql-dashboard", dashboardId, dashboardScope],
       });
       toast.success(`Unhid "${dashboard?.name ?? "dashboard"}"`);
     } catch (err) {
@@ -1673,7 +1702,13 @@ function SqlDashboardPageContent({
         err instanceof Error ? err.message : "Couldn't unhide dashboard",
       );
     }
-  }, [dashboardId, dashboard?.name, hideDashboardAction, queryClient]);
+  }, [
+    dashboardId,
+    dashboardScope,
+    dashboard?.name,
+    hideDashboardAction,
+    queryClient,
+  ]);
 
   const handleSaveView = useCallback(
     async (name: string, filters: Record<string, string>) => {

package/corpus/templates/analytics/app/root.tsx

@@ -95,6 +95,10 @@ function DbSyncBridge() {
   const queryClient = useQueryClient();
   useDbSync({
     queryClient,
+    // Netlify functions cannot reliably hold the local long-lived SSE
+    // response. Analytics uses the poll safety net until a hosted realtime
+    // gateway is configured for this deployment.
+    sseUrl: false,
     ignoreSource: TAB_ID,
     onEvent: notifyProviderCorpusJobSyncEvent,
     actionInvalidatePredicate: shouldInvalidateAnalyticsQueryForAction,

package/corpus/templates/analytics/app/routes/dashboards._index.tsx

@@ -1 +1,5 @@
-export { clientLoader, default, loader } from "./dashboard";
+import DashboardOverview from "../pages/DashboardOverview";
+
+export default function DashboardsOverviewRoute() {
+  return <DashboardOverview />;
+}

package/corpus/templates/analytics/changelog/2026-08-07-added-a-dashboards-overview-with-personal-and-shared-folders.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-08-07
+---
+
+Added a dashboards overview with personal and shared folders.

package/corpus/templates/analytics/changelog/2026-08-07-analytics-tracking-and-chat-startup-no-longer-emit-avoidable.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-07
+---
+
+Analytics tracking and chat startup no longer emit avoidable request errors

package/corpus/templates/analytics/changelog/2026-08-07-dashboard-panels-now-load-custom-api-data-programs-reliably.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-07
+---
+
+Dashboard panels now load custom API data programs reliably

package/corpus/templates/analytics/changelog/2026-08-07-gong-searches-conserve-api-quota-and-report-incomplete-coverage.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-08-07
+---
+
+Gong searches conserve API quota and clearly report incomplete coverage

package/corpus/templates/analytics/changelog/2026-08-07-searchable-dashboards-make-personal-and-shared-folders-easie.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-08-07
+---
+
+Searchable dashboards make personal and shared folders easier to scan.

package/corpus/templates/analytics/netlify.toml

@@ -45,3 +45,6 @@ timeout = 120
 [functions.analytics-rollup-backfill-background]
 timeout = 300
 memory = "2gb"
+
+[functions.session-replay-retention-sweep-background]
+timeout = 120

package/corpus/templates/analytics/scripts/emit-netlify-dashboard-report-cron.ts

@@ -26,6 +26,10 @@ const ROLLUP_SCHEDULED_NAME = "analytics-rollup-backfill-cron";
 const ROLLUP_WORKER_NAME = "analytics-rollup-backfill-background";
 const ROLLUP_ROUTE_PATH = "/api/analytics-rollups/backfill";
 const ROLLUP_SCHEDULE = "*/15 * * * *";
+const RETENTION_SCHEDULED_NAME = "session-replay-retention-cron";
+const RETENTION_WORKER_NAME = "session-replay-retention-sweep-background";
+const RETENTION_ROUTE_PATH = "/api/session-replay/retention";
+const RETENTION_SCHEDULE = "0 3 * * *";
 
 function ensureDir(dir: string) {
   mkdirSync(dir, { recursive: true });
@@ -495,6 +499,108 @@ export const config = {
   writeFileSync(path.join(dest, `${ROLLUP_WORKER_NAME}.mjs`), source);
 }
 
+function emitRetentionScheduledTrigger(token: string) {
+  const dest = path.join(FUNCTIONS_DIR, RETENTION_SCHEDULED_NAME);
+  rmSync(dest, { recursive: true, force: true });
+  ensureDir(dest);
+
+  const source = `const WORKER_PATH = "/.netlify/functions/${RETENTION_WORKER_NAME}";
+const CRON_TOKEN = ${JSON.stringify(token)};
+
+function siteOrigin(request) {
+  const configured = process.env.URL || process.env.DEPLOY_URL;
+  if (configured) return configured;
+  const url = new URL(request.url);
+  return url.origin;
+}
+
+export default async function handler(request) {
+  const url = new URL(WORKER_PATH, siteOrigin(request));
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-agent-native-session-replay-retention-cron": CRON_TOKEN,
+    },
+    body: JSON.stringify({ scheduled: true }),
+  });
+
+  if (!response.ok && response.status !== 202) {
+    console.error(
+      "[session-replay-retention-cron] Background retention trigger failed:",
+      response.status,
+      // coercion-ok: the non-2xx status remains the failure signal; the body is diagnostics only.
+      await response.text().catch(() => ""),
+    );
+  }
+}
+
+export const config = {
+  name: "session replay retention cron trigger",
+  generator: "agent-native analytics build",
+  schedule: ${JSON.stringify(RETENTION_SCHEDULE)},
+};
+`;
+
+  writeFileSync(path.join(dest, `${RETENTION_SCHEDULED_NAME}.mjs`), source);
+}
+
+function emitRetentionBackgroundWorker(token: string) {
+  const dest = path.join(FUNCTIONS_DIR, RETENTION_WORKER_NAME);
+  rmSync(dest, { recursive: true, force: true });
+  cloneServerBundleForFunction(SERVER_DIR, dest);
+  rmSync(path.join(dest, "server.mjs"), { force: true });
+
+  const source = `globalThis.__AGENT_NATIVE_BACKGROUND_RUNTIME__ = true;
+globalThis.__AGENT_NATIVE_LOW_CONNECTION_BACKGROUND_RUNTIME__ = true;
+globalThis.__AGENT_NATIVE_SESSION_REPLAY_RETENTION_SCHEDULED_RUNTIME__ = true;
+
+const CRON_TOKEN = ${JSON.stringify(token)};
+const ROUTE_PATH = ${JSON.stringify(RETENTION_ROUTE_PATH)};
+let cachedHandler;
+
+function timingSafeEquals(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i += 1) {
+    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return diff === 0;
+}
+
+export default async function handler(request, context) {
+  const token = request.headers.get("x-agent-native-session-replay-retention-cron") || "";
+  if (!timingSafeEquals(token, CRON_TOKEN)) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+
+  cachedHandler ??= (await import("./main.mjs")).default;
+  const url = new URL(request.url);
+  url.pathname = ROUTE_PATH;
+  url.search = "";
+
+  const rewritten = new Request(url.toString(), {
+    method: "POST",
+    headers: new Headers({ "content-type": "application/json" }),
+    body: JSON.stringify({ scheduled: true }),
+  });
+
+  return await cachedHandler(rewritten, context);
+}
+
+export const config = {
+  name: "session replay retention background sweep",
+  generator: "agent-native analytics build",
+  background: true,
+  nodeBundler: "none",
+  includedFiles: ["**"],
+  preferStatic: false,
+};
+`;
+
+  writeFileSync(path.join(dest, `${RETENTION_WORKER_NAME}.mjs`), source);
+}
+
 function isDirectRun(): boolean {
   const entrypoint = process.argv[1];
   return Boolean(
@@ -515,6 +621,7 @@ function main(): void {
   const alertToken = randomBytes(32).toString("hex");
   const uptimeToken = randomBytes(32).toString("hex");
   const rollupToken = randomBytes(32).toString("hex");
+  const retentionToken = randomBytes(32).toString("hex");
   emitScheduledTrigger(token);
   emitBackgroundWorker(token);
   emitAlertScheduledTrigger(alertToken);
@@ -523,6 +630,8 @@ function main(): void {
   emitUptimeBackgroundWorker(uptimeToken);
   emitRollupScheduledTrigger(rollupToken);
   emitRollupBackgroundWorker(rollupToken);
+  emitRetentionScheduledTrigger(retentionToken);
+  emitRetentionBackgroundWorker(retentionToken);
   console.log(
     `[dashboard-report-cron] Emitted Netlify scheduled trigger "${SCHEDULED_NAME}" (${SCHEDULE}) and background worker "${WORKER_NAME}".`,
   );
@@ -535,6 +644,9 @@ function main(): void {
   console.log(
     `[analytics-rollup-backfill-cron] Emitted Netlify scheduled trigger "${ROLLUP_SCHEDULED_NAME}" (${ROLLUP_SCHEDULE}) and background worker "${ROLLUP_WORKER_NAME}".`,
   );
+  console.log(
+    `[session-replay-retention-cron] Emitted Netlify scheduled trigger "${RETENTION_SCHEDULED_NAME}" (${RETENTION_SCHEDULE}) and background worker "${RETENTION_WORKER_NAME}".`,
+  );
 }
 
 if (isDirectRun()) {

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

@@ -59,6 +59,18 @@ registerShareableResource({
   getDb,
 });
 
+registerShareableResource({
+  type: "dashboard-folder",
+  resourceTable: schema.dashboardFolders,
+  sharesTable: schema.dashboardFolderShares,
+  displayName: "Dashboard folder",
+  titleColumn: "name",
+  getResourcePath: (folder) => `/dashboards?folder=${folder.id}`,
+  allowPublic: false,
+  requireOrgMemberForUserShares: true,
+  getDb,
+});
+
 registerShareableResource({
   type: "analysis",
   resourceTable: schema.analyses,

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

@@ -38,6 +38,7 @@ export const dashboards = table("dashboards", {
   /** Hidden dashboards are omitted from default navigation but remain openable. */
   hiddenAt: text("hidden_at"),
   hiddenBy: text("hidden_by"),
+  folderId: text("folder_id"),
   /** Last authenticated user who changed dashboard metadata/config, if tracked. */
   updatedBy: text("updated_by"),
   ...ownableColumns(),
@@ -55,6 +56,19 @@ export const dashboardNameLocks = table("dashboard_name_locks", {
 
 export const dashboardShares = createSharesTable("dashboard_shares");
 
+export const dashboardFolders = table("dashboard_folders", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  scope: text("scope", { enum: ["personal", "shared"] }).notNull(),
+  createdAt: text("created_at").notNull().default(now()),
+  updatedAt: text("updated_at").notNull().default(now()),
+  ...ownableColumns(),
+});
+
+export const dashboardFolderShares = createSharesTable(
+  "dashboard_folder_shares",
+);
+
 /**
  * Bounded dashboard history. Each row snapshots the previous dashboard config
  * before a meaningful save so users and agents can restore known-good states.

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

@@ -137,6 +137,7 @@ const SQLITE_BACKFILL_STATEMENTS = [
 type BackfillStatus =
   | "completed"
   | "already-complete"
+  | "disabled"
   | "skipped-lock"
   | "already-running";
 
@@ -320,6 +321,9 @@ async function runD1Backfill(
  * each scan the full event history.
  */
 export async function runAnalyticsRollupBackfillOnce(): Promise<AnalyticsRollupBackfillResult> {
+  if (process.env.ANALYTICS_ROLLUP_BACKFILL_JOBS?.trim() === "0") {
+    return { status: "disabled", remaining: 1 };
+  }
   if (running) {
     return { status: "already-running", remaining: 1 };
   }

package/corpus/templates/analytics/server/lib/agent-chat-plan-mode.ts

@@ -37,6 +37,7 @@ export const INITIAL_TOOL_NAMES = [
   // tool-search round trip (~15 KB of results) before it can even start — or worse,
   // enumerates the cohort page by page through whatever it can already see.
   "provider-api-request",
+  "provider-corpus-job",
   "query-staged-dataset",
   "hubspot-records",
   "navigate",

package/corpus/templates/analytics/server/lib/analytics-query-catalog.ts

@@ -1,10 +1,16 @@
 import { getAllSettings, listOrgSettings } from "@agent-native/core/settings";
 
 import { dashboardCatalogEntries } from "./dashboard-catalog";
-import { listDashboards, type DashboardRecord } from "./dashboards-store";
+import {
+  listDashboardSummaries,
+  loadDashboardCatalogDashboards,
+  type DashboardCatalogRecord,
+  type DashboardSummaryRecord,
+} from "./dashboards-store";
 
 const DATA_DICTIONARY_KEY_PREFIX = "data-dict-";
 const MAX_QUERY_LENGTH = 12_000;
+const MAX_CATALOG_DASHBOARD_HYDRATION = 24;
 const STOP_WORDS = new Set([
   "a",
   "all",
@@ -106,6 +112,44 @@ function compactQuery(value: unknown): string | Record<string, unknown> | null {
   return null;
 }
 
+function summaryScore(
+  search: string,
+  dashboard: DashboardSummaryRecord,
+): number {
+  const { score } = matchScore(search, [
+    { value: dashboard.name, weight: 24 },
+    { value: dashboard.description, weight: 12 },
+    { value: dashboard.configName, weight: 10 },
+    { value: dashboard.catalogTemplateId, weight: 6 },
+    { value: dashboard.demoId, weight: 6 },
+  ]);
+  return score;
+}
+
+function shortlistDashboardSummaries(
+  search: string,
+  dashboards: DashboardSummaryRecord[],
+  limit: number,
+): DashboardSummaryRecord[] {
+  const maxHydration = Math.min(
+    Math.max(limit * 4, 12),
+    MAX_CATALOG_DASHBOARD_HYDRATION,
+  );
+  return dashboards
+    .map((dashboard) => ({
+      dashboard,
+      score: summaryScore(search, dashboard),
+    }))
+    .sort((a, b) => {
+      if (b.score !== a.score) return b.score - a.score;
+      return JSON.stringify(a.dashboard).localeCompare(
+        JSON.stringify(b.dashboard),
+      );
+    })
+    .slice(0, maxHydration)
+    .map(({ dashboard }) => dashboard);
+}
+
 // Analytics vocabulary the corpus spells out but users abbreviate (or vice versa).
 // Expansions match at reduced weight so they break ties without outranking a literal hit.
 const SYNONYM_EXPANSIONS: Record<string, string[]> = {
@@ -497,13 +541,15 @@ async function listDictionaryEntries(args: {
   return entries;
 }
 
-function savedDashboardInput(dashboard: DashboardRecord) {
-  const config = dashboard.config as Record<string, unknown>;
+function savedDashboardInput(
+  summary: DashboardSummaryRecord,
+  dashboard: DashboardCatalogRecord,
+) {
   return {
     id: dashboard.id,
-    title: text(config.name) || dashboard.title,
-    description: text(config.description) || undefined,
-    config,
+    title: summary.name,
+    description: summary.description ?? undefined,
+    config: dashboard.config,
     origin: "saved-dashboard" as const,
   };
 }
@@ -514,26 +560,46 @@ export async function searchAnalyticsQueryCatalog(args: {
   orgId: string | null;
   limit: number;
 }): Promise<AnalyticsQueryCatalogCandidate[]> {
-  const [savedDashboardsResult, dictionaryEntriesResult] =
+  const [savedSummariesResult, dictionaryEntriesResult] =
     await Promise.allSettled([
-      listDashboards(
+      listDashboardSummaries(
         { email: args.email, orgId: args.orgId },
-        { kind: "sql", archived: "active", hidden: "visible" },
+        {
+          kind: "sql",
+          archived: "active",
+          hidden: "visible",
+          includeCatalogMetadata: true,
+        },
       ),
       listDictionaryEntries({ email: args.email, orgId: args.orgId }),
     ]);
-  const savedDashboards =
-    savedDashboardsResult.status === "fulfilled"
-      ? savedDashboardsResult.value
+  const savedSummaries =
+    savedSummariesResult.status === "fulfilled"
+      ? savedSummariesResult.value
       : [];
   const dictionaryEntries =
     dictionaryEntriesResult.status === "fulfilled"
       ? dictionaryEntriesResult.value
       : [];
+  const savedSummaryIds = new Set(
+    savedSummaries.map((dashboard) => dashboard.id),
+  );
 
-  const savedIds = new Set(savedDashboards.map((dashboard) => dashboard.id));
+  const shortlistedSummaries = shortlistDashboardSummaries(
+    args.search,
+    savedSummaries,
+    args.limit,
+  );
+  const shortlistedIds = shortlistedSummaries.map((dashboard) => dashboard.id);
+  const savedDashboardsResult = await loadDashboardCatalogDashboards(
+    { email: args.email, orgId: args.orgId },
+    shortlistedIds,
+  );
+  const savedDashboards = new Map(
+    savedDashboardsResult.map((dashboard) => [dashboard.id, dashboard]),
+  );
   const templateDashboards = dashboardCatalogEntries
-    .filter((entry) => !savedIds.has(entry.defaultDashboardId))
+    .filter((entry) => !savedSummaryIds.has(entry.defaultDashboardId))
     .flatMap((entry) => {
       try {
         const config = entry.buildConfig() as unknown as Record<
@@ -557,7 +623,11 @@ export async function searchAnalyticsQueryCatalog(args: {
   return rankAnalyticsQueryCatalog({
     search: args.search,
     dashboards: [
-      ...savedDashboards.map(savedDashboardInput),
+      ...shortlistedSummaries.flatMap((summary) => {
+        const dashboard = savedDashboards.get(summary.id);
+        if (!dashboard) return [];
+        return [savedDashboardInput(summary, dashboard)];
+      }),
       ...templateDashboards,
     ],
     dictionaryEntries,