@agent-native/core-corpus 0.210.2 → 0.211.0-nightly-20261020183616

package/corpus/README.md

@@ -32,4 +32,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core-corpus/corpu
 
 ## Generated Counts
 
-- template files: 13165
+- template files: 13257

package/corpus/templates/analytics/.agents/skills/actions/references/action-fields.md

@@ -95,9 +95,9 @@ MCP clients see no `outputSchema` by default. Set `mcpOutputSchema: true` (requi
 
 `authorize` decides whether the caller may run the action at all. It wraps
 `run`, so it holds at **all six dispatch sites** — agent tool, HTTP, frontend
-hook, MCP, A2A, CLI — unlike `needsApproval`, which is honoured only in the
-agent loop. Use `authorize` for "not everyone may do this"; use `needsApproval`
-to ask a human to bless one call a permitted caller is already allowed to make.
+hook, MCP, A2A, CLI. Use `authorize` for "not everyone may do this"; use
+`needsApproval` to ask a human to bless one call a permitted caller is already
+allowed to make.
 
 ```ts
 import { coachAccess } from "../lib/access.js"; // defineAppRoles(...)
@@ -140,4 +140,6 @@ export default defineAction({
 
 When the gate is truthy and the call isn't yet approved, the loop emits an `approval_required` event and **stops the turn — `run()` never executes**. A predicate gates conditionally (e.g. only external recipients) and **fails closed**: a throw is treated as "approval required". It receives its own copy of the prepared snapshot of the validated arguments, defaults applied, and the approval binds to the snapshot's hash, so an approved call runs only with the arguments that were approved (a Date binds by its time). The human approves via the chat UI's Approve affordance, which re-issues the turn with the call's `approvalKey`, and only then does the action run.
 
+Approval is given in the app, so HTTP never grants it. The HTTP action route and the generated Workers entry run a gated call only for the proven app UI (a frontend call from the signed-in user, same origin, holding the short-lived UI capability; `isProvenUiRequest`, the proof `uiOnly` uses) or the app's MCP directory widget. Every other HTTP caller (bearer or API key, MCP OAuth token, org service token, A2A, extension iframe, mobile app) gets `409 approval_required`, and a service identity can never approve. The shared client presents the capability with every write from a signed-in session (minted once per user, reused for nine minutes, never for reads or public pages), so a gated button works on its first request. A call without proof gets `403 ui_capability_required`; the client then re-mints and retries once, which is only the fallback for an expired or rejected capability. Every surface evaluates the gate through `preparedCallNeedsApproval`, so a throwing predicate asks there too. A caller that must run unattended needs a different action, never a bypass of the gate.
+
 **Keep approvals rare** — the default is off and almost every action should leave it off. The canonical example is Mail's `send-email` (`needsApproval: true`). See the `security` skill and the Human Approval doc.

package/corpus/templates/analytics/.agents/skills/dashboard-management/SKILL.md

@@ -144,8 +144,32 @@ collection stays off until a property owner adds the service account that
 `get-content-collection` returns as `serviceAccount.email`; then set its
 `searchConsoleSites` and turn it on.
 
+The `signups` step writes `signups_first_touch` per article: people who
+first landed on the article and later signed up, on the day of that first
+visit, so a window's days add up to its total. It is the only step that reads
+the warehouse. It stays `not_configured` until `configure-content-collection`
+sets its `signups` tables, `signupSource`, `signupsSince` and
+`maxBytesBilled`. Measure the cap with `estimate-content-signups-cost` (a dry
+run, free) and get the spend approved before turning the step on. Each run
+dry-runs first, stops as `cost_limited` without querying when the estimate is
+over the cap, and runs the join with that cap as BigQuery's billing limit.
+
+The catalog's "Content" dashboard (`content-view`) is the reference for these
+tables: start from its panels before writing new content SQL. Its Articles
+panel shows why a metric is missing (`failed`, `not set up`, `still
+arriving`) in a column next to the blank number; keep that pattern. The
+first-party SQL policy rejects functions outside its allow-list (for example
+`concat_ws`) and reads `CASE (` as a function call, so join a status column
+instead of a scalar subquery inside `CASE`. Its trend chart uses wide rows
+(`yKeys`), not `pivot`: a pivot fills a missing series with 0, so a day a
+source didn't report would draw as a zero instead of a gap. Content is a
+built-in: turning collection on with `configure-content-collection` lists it
+in the organization's Dashboards at `content-view` (`contentDashboardId` in the
+result). It is read-only; build on it with `duplicate-dashboard`.
+
 There is no dbt Semantic Layer panel source. For a Semantic Layer metric, answer in chat with `query-dbt-semantic-metric`; build a warehouse panel only on a table the owner names.
 
+
 AI-generated first-party panels are dashboard-time-bound by default. Set
 `config.timeScope` to `"dashboard"` and include the matching dashboard time
 filter in the SQL. The allowed values are:
@@ -467,8 +491,9 @@ visualizations outside these contracts may remain Custom Blocks.
 
 ## Sigma workbook import
 
-The dashboard menu opens the Sigma import flow, where users can browse and
-preview workbooks. Imports remain disabled for elements whose source project
+The dashboard menu opens the Sigma import flow: a searchable table of every
+workbook the user can see in Sigma, with the owner of each migrated one and a
+Migrate button on the rest. Imports remain disabled for elements whose source project
 Analytics cannot verify: Sigma's connection API reports provider type and
 metadata but does not expose a BigQuery project identifier. Do not call
 `migrate-sigma-workbook` for an unverified source or treat an Analytics
@@ -489,6 +514,16 @@ encrypted organization secrets and links them to an Analytics-only connection.
 Credential values must never pass through agent chat, action arguments, logs,
 source, or screenshots.
 
+Each Sigma workbook migrates to at most one Analytics dashboard per
+organization. `list-sigma-workbooks` reads migration status only for workbooks
+the caller's Sigma connection returns, so status follows Sigma access. For a
+migrated workbook it returns the dashboard id, link, and owner email and
+display name to every org member, and the title and `canOpen: true` only when the caller can open
+the dashboard. Point users at that dashboard, or its owner for access, instead
+of importing again. Anyone whose Sigma login can open a workbook may retry its
+failed import or take over an import stuck for ten minutes; only the person who
+migrated a workbook may re-import it.
+
 If Sigma adds verifiable source mapping in the future, the planned import will
 create a private snapshot in the user's personal `Sigma` folder. Other source
 types and unsupported elements will become review callouts. Preserve migration
@@ -768,6 +803,10 @@ When the user asks to change an existing panel on the open dashboard:
    `verified: false`, an error, or the user saying the change is not visible,
    call `inspect-dashboard-panel` for that panel, fix what it reports, and
    verify again. Never describe a visible change you have not verified.
+   An edit that changes a panel's query also returns `cost`: what one refresh
+   of the changed panels scans and costs at the default filters, and per month
+   for the dashboard's email reports. The summary repeats it; when it says the
+   cost is over a threshold, tell the user the number.
    `update-dashboard`, `compose-dashboard`, and `restore-dashboard-revision`
    return the same fields. Editing a dashboard you can only view fails with
    `dashboard_forbidden` before any SQL runs.

package/corpus/templates/analytics/.agents/skills/data-querying/SKILL.md

@@ -114,8 +114,10 @@ After cutover, an org admin can point charts at a scheduled warehouse events
 model with `configure-first-party-events-model`; run `check` first, which
 dry-runs as the app and saves nothing. With a model set, a first-party query
 reads `analytics_events` from the model only when its WHERE filters
-`event_name` to named events (`= 'x'` or `IN (...)`, ANDed, no OR or NOT),
-because the model has no `http.response` rows; its result carries
+`event_name` to named events (`= 'x'` or `IN (...)`) in a top-level AND
+conjunct, or in a parenthesized OR whose every branch does, because the model
+has no `http.response` rows. Other parenthesized conditions may use OR and
+NOT; an OR, NOT, or CASE at the WHERE's own level keeps the query raw; its result carries
 `eventsSource` and `sourceGeneration` (the model build it read). Unfiltered
 queries, `SELECT *`, and queries that name `public_key_id` or `context`, read
 `http.response`, or read `properties` other than through `JSON_VALUE`,

package/corpus/templates/analytics/.deploy-tmp/agent-native-provided-plugins.mjs

@@ -0,0 +1,10 @@
+// AUTO-GENERATED by @agent-native/core deploy build
+import { markDefaultPluginProvided } from "@agent-native/core/server/edge";
+
+const pluginStems = ["agent-chat","analytics-alert-jobs","analytics-rollup-backfill-jobs","auth","collab","config","content-metrics-collection-jobs","core-routes","creative-context","dashboard-report-jobs","db","feature-flags","labs","onboarding","otel","session-replay-retention-jobs","transactional-emails","uptime-monitor-jobs"];
+
+export default function markBuildDiscoveredPlugins(nitroApp) {
+  for (const stem of pluginStems) {
+    markDefaultPluginProvided(nitroApp, stem);
+  }
+}

package/corpus/templates/analytics/actions/build-data-index.ts

@@ -1,7 +1,9 @@
 import { defineAction, fail } from "@agent-native/core/action";
 import {
+  getRequestContext,
   getRequestOrgId,
   getRequestUserEmail,
+  runWithRequestContext,
 } from "@agent-native/core/server";
 import { getOrgSetting, mutateOrgSetting } from "@agent-native/core/settings";
 import { z } from "zod";
@@ -110,8 +112,15 @@ export default defineAction({
     });
     let outcome: SourceIndexRunOutcome;
     try {
-      const { bundle: builtBundle } =
-        await buildDbtSourceIndexFromGitHub(repository);
+      const { bundle: builtBundle } = await runWithRequestContext(
+        {
+          ...(getRequestContext() ?? {}),
+          userEmail: admin.userEmail,
+          orgId,
+          credentialScope: "org",
+        },
+        () => buildDbtSourceIndexFromGitHub(repository),
+      );
       // Computed before the write so a bad source fails the run instead of
       // leaving a stored index with no recorded revisions.
       // Check the new build before the write, then report its final source IDs

package/corpus/templates/analytics/actions/configure-content-collection.ts

@@ -5,9 +5,12 @@ import {
 } from "@agent-native/core/server";
 import { z } from "zod";
 
+import { installBuiltinDashboardOnce } from "../server/lib/builtin-dashboards.js";
 import {
   contentCollectionConfigSchema,
   searchConsoleSiteSchema,
+  signupsSettingsUpdateSchema,
+  storedSearchConsoleSiteSchema,
 } from "../server/lib/content-metrics/config.js";
 import { readContentCollectionStatus } from "../server/lib/content-metrics/status.js";
 import {
@@ -17,6 +20,8 @@ import {
 import { requireAnalyticsAdminContext } from "../server/lib/db-admin-connections.js";
 import { cliBoolean } from "./schema-helpers.js";
 
+const CONTENT_VIEW_DASHBOARD_ID = "content-view";
+
 export default defineAction({
   mcpAnnotations: {
     readOnlyHint: false,
@@ -24,7 +29,7 @@ export default defineAction({
     openWorldHint: false,
   },
   description:
-    "Turn the organization's daily Content view collection on or off and choose its steps. Requires an organization owner or admin. The caller becomes the stored owner: the daily job resolves provider connections as them. Omitted step settings keep their saved values.",
+    "Turn the organization's daily Content view collection on or off and choose its steps. Requires an organization owner or admin. The caller becomes the stored owner: the daily job resolves provider connections as them. Omitted step settings keep their saved values. Turning collection on also lists the built-in Content dashboard in the organization's Dashboards; the result's contentDashboardId opens it at /dashboards/<id>.",
   schema: z.object({
     enabled: cliBoolean.describe("Whether the daily collection runs."),
     builderBlog: cliBoolean
@@ -39,15 +44,20 @@ export default defineAction({
         "Collect daily Search Console clicks and impressions. Turn on only after a property owner has given the service account access.",
       ),
     searchConsoleSites: z
-      .array(searchConsoleSiteSchema)
+      .array(storedSearchConsoleSiteSchema)
       .max(20)
       .optional()
       .describe(
         'Search Console properties to collect, replacing the saved list, e.g. [{"siteUrl":"sc-domain:example.com","pathPrefix":"/blog/"}].',
       ),
+    signups: signupsSettingsUpdateSchema
+      .optional()
+      .describe(
+        "Per-article signups settings, merged into the saved ones: enabled, signupEventsTable and firstPageviewsTable (project.dataset.table), signupSource (its signups are also counted on their own, as Source signups), signupsSince (YYYY-MM-DD) and maxBytesBilled. The step stays not set up until all are set; measure maxBytesBilled with estimate-content-signups-cost, and get it approved before turning the step on, since every run scans the warehouse.",
+      ),
   }),
   run: async (
-    { enabled, builderBlog, ga4, searchConsole, searchConsoleSites },
+    { enabled, builderBlog, ga4, searchConsole, searchConsoleSites, signups },
     ctx,
   ) => {
     const admin = await requireAnalyticsAdminContext({
@@ -67,8 +77,23 @@ export default defineAction({
         enabled: searchConsole ?? saved.searchConsole.enabled,
         sites: searchConsoleSites ?? saved.searchConsole.sites,
       },
+      signups: { ...saved.signups, ...signups },
     });
+    if (enabled && config.searchConsole.enabled) {
+      z.array(searchConsoleSiteSchema)
+        .max(20)
+        .parse(config.searchConsole.sites);
+    }
+    if (enabled) {
+      await installBuiltinDashboardOnce(
+        { email: admin.userEmail, orgId: admin.orgId },
+        CONTENT_VIEW_DASHBOARD_ID,
+      );
+    }
     await writeContentCollection(scope, { enabled, config });
-    return readContentCollectionStatus(admin.orgId, admin.userEmail);
+    return {
+      ...(await readContentCollectionStatus(admin.orgId, admin.userEmail)),
+      contentDashboardId: enabled ? CONTENT_VIEW_DASHBOARD_ID : null,
+    };
   },
 });

package/corpus/templates/analytics/actions/configure-first-party-events-model.ts

@@ -33,7 +33,9 @@ function utcDateDaysAgo(days: number): string {
 }
 
 // Dry runs only: BigQuery plans the query and reports the bytes it would
-// scan, but runs and bills nothing.
+// scan, but runs and bills nothing. Both read every projected column: BigQuery
+// bills only the columns a query reads, so COUNT(*) would report almost nothing
+// while a chart can read any of them.
 async function checkModel(
   table: string,
   signal?: AbortSignal,
@@ -47,7 +49,7 @@ async function checkModel(
   }
   const projection = `(${firstPartyEventsModelProjection(table)}) AS analytics_events`;
   const recent = await dryRunQuerySchema(
-    `SELECT COUNT(*) AS events FROM ${projection} WHERE event_date >= DATE '${utcDateDaysAgo(1)}'`,
+    `SELECT * FROM ${projection} WHERE event_date = DATE '${utcDateDaysAgo(1)}'`,
     { signal },
   );
   if (recent.error) {
@@ -60,10 +62,10 @@ async function checkModel(
   }
   // Eligible chart SQL need not bound event_date, so a model that refuses an
   // unbounded read (a required partition filter, say) would fail those charts.
-  const full = await dryRunQuerySchema(
-    `SELECT COUNT(*) AS events FROM ${projection}`,
-    { signal },
-  );
+  // guard:allow-unbounded-read — dry run: BigQuery plans it and bills nothing.
+  const full = await dryRunQuerySchema(`SELECT * FROM ${projection}`, {
+    signal,
+  });
   if (full.error) {
     return {
       status: "unavailable",
@@ -91,7 +93,7 @@ export default defineAction({
     openWorldHint: true,
   },
   description:
-    "Check or set the warehouse events model that first-party Analytics charts read instead of the raw event table. `check` (any org member) reads the model's table metadata and dry-runs the chart projection against it as the app, reporting whether the app can query it and the bytes a one-day and a full read would scan; it runs and bills no query. `set` (org admin, needs approval) runs the same check and saves the model only if it passes. `clear` (org admin, needs approval) sends charts back to the raw table. Charts that read columns or events the model lacks, alerts, and onboarding journeys keep reading the raw table either way.",
+    "Check or set the warehouse events model that first-party Analytics charts read instead of the raw event table. `check` (any org member) reads the model's table metadata and dry-runs the chart projection against it as the app, reporting whether the app can query it and the most bytes one read of yesterday's full UTC day, or of the whole model, could scan (every column; a chart that reads the model more than once, such as a self-join, scans that much per read); it runs and bills no query. `set` (org admin, needs approval) runs the same check and saves the model only if it passes. `clear` (org admin, needs approval) sends charts back to the raw table. Charts that read columns or events the model lacks, alerts, and onboarding journeys keep reading the raw table either way.",
   schema: z.object({
     mode: z.enum(["check", "set", "clear"]),
     table: z

package/corpus/templates/analytics/actions/create-analytics-public-key.ts

@@ -22,6 +22,10 @@ export default defineAction({
       .optional()
       .describe("Human label for this key, e.g. 'Hosted templates'."),
   }),
+  // It creates, changes, or revokes a credential or who may use one: every
+  // call needs the user's approval, and "always allow" is not offered.
+  needsApproval: true,
+  allowPersistentApproval: false,
   run: async (args) => {
     return createAnalyticsPublicKey(resolveScope(), args.name ?? "Default key");
   },

package/corpus/templates/analytics/actions/estimate-content-signups-cost.ts

@@ -0,0 +1,72 @@
+import { defineAction, fail } from "@agent-native/core/action";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { dryRunQuerySchema } from "../server/lib/bigquery.js";
+import { ContentStepStop } from "../server/lib/content-metrics/step.js";
+import {
+  buildSignupsQuery,
+  signupsTables,
+} from "../server/lib/content-metrics/steps/signups.js";
+import { readContentCollection } from "../server/lib/content-metrics/store.js";
+import { requireAnalyticsAdminContext } from "../server/lib/db-admin-connections.js";
+
+export default defineAction({
+  description:
+    "Dry-run today's per-article signups join for the organization's Content view and return the bytes BigQuery estimates it would scan, next to the saved maxBytesBilled cap. A dry run scans and bills nothing. Requires an organization owner or admin and the signups warehouse settings from configure-content-collection; use the estimate to choose maxBytesBilled before turning the signups step on.",
+  schema: z.object({}),
+  readOnly: true,
+  run: async (_args, ctx) => {
+    const admin = await requireAnalyticsAdminContext({
+      userEmail: getRequestUserEmail() || ctx?.userEmail,
+      orgId: getRequestOrgId() || ctx?.orgId || null,
+    });
+    const collection = await readContentCollection({
+      ownerEmail: admin.userEmail,
+      orgId: admin.orgId,
+    });
+    if (!collection) {
+      fail("Content collection isn't set up for this organization yet.", {
+        errorCode: "content_collection_not_configured",
+        statusCode: 412,
+      });
+    }
+    const signups = collection.config.signups;
+    let tables: ReturnType<typeof signupsTables>;
+    try {
+      tables = signupsTables(signups);
+    } catch (error) {
+      if (!(error instanceof ContentStepStop)) throw error;
+      fail(error.message, {
+        errorCode: error.failure.errorCode,
+        statusCode: 412,
+      });
+    }
+    const query = buildSignupsQuery(tables, new Date());
+    const estimate = await dryRunQuerySchema(query.sql);
+    if (estimate.error) {
+      fail(`The signups dry run failed: ${estimate.error}`, {
+        errorCode: "signups_dry_run_failed",
+        statusCode: 502,
+      });
+    }
+    if (estimate.totalBytesProcessed === undefined) {
+      fail("BigQuery returned no byte estimate for the signups join.", {
+        errorCode: "signups_estimate_unavailable",
+        statusCode: 502,
+      });
+    }
+    return {
+      estimatedBytes: estimate.totalBytesProcessed,
+      maxBytesBilled: signups.maxBytesBilled,
+      withinCap:
+        signups.maxBytesBilled === null
+          ? null
+          : estimate.totalBytesProcessed <= signups.maxBytesBilled,
+      window: { startDate: query.startDate, endDate: query.endDate },
+    };
+  },
+});

package/corpus/templates/analytics/actions/estimate-query-cost.ts

@@ -11,141 +11,35 @@ import { isSafeDashboardId } from "../server/lib/dashboard-id";
 import {
   pageDashboardConfig,
   resolveDashboardPanelQueries,
-  type ResolvedDashboardPanelQuery,
 } from "../server/lib/dashboard-panel-verification";
-import { countEnabledDashboardReportSubscriptions } from "../server/lib/dashboard-report-subscriptions";
 import { loadDashboardSeed } from "../server/lib/dashboard-seeds";
 import { getDashboard } from "../server/lib/dashboards-store";
 import type { AnalyticsScope } from "../server/lib/first-party-analytics";
 import {
-  DAYS_PER_MONTH,
+  describeEstimate,
+  describeReportSchedules,
   estimateBigQuerySql,
   estimateFirstPartySql,
-  estimateResolvedPanel,
+  estimateResolvedPanels,
   formatBytes,
   formatUsd,
   ON_DEMAND_USD_PER_TIB,
   QUERY_COST_CAVEATS,
   QUERY_COST_THRESHOLDS,
+  scheduledDashboardRuns,
   totalCost,
   type PanelCostEstimate,
-  type QueryCostEstimate,
 } from "../server/lib/query-cost-estimate";
 import { clipHead } from "../shared/panel-render-contract";
 
 const MAX_PANELS = 60;
-const DRY_RUN_CONCURRENCY = 6;
 /** Stop starting dry runs here so the action returns before its 55 s timeout. */
 const DASHBOARD_DEADLINE_MS = 40_000;
 
-function timedOutPanel(
-  panel: { panelId: string; title: string; source: string },
-  error: string,
-): PanelCostEstimate {
-  return {
-    panelId: panel.panelId,
-    title: panel.title,
-    source: panel.source,
-    status: "failed",
-    failure: "timeout",
-    error,
-  };
-}
-
-/**
- * Estimate one panel, but give up when the dashboard deadline passes, even
- * mid-way through credential, table, or backend lookups, so finished panels
- * still come back before the action's own timeout.
- */
-async function estimatePanelBefore(
-  deadline: number,
-  panel: ResolvedDashboardPanelQuery,
-  scope: AnalyticsScope,
-  runsPerMonth: number | null,
-  signal?: AbortSignal,
-): Promise<PanelCostEstimate> {
-  const remaining = deadline - Date.now();
-  if (remaining <= 0) {
-    return timedOutPanel(
-      panel,
-      "Skipped: this request ran out of time. Estimate this panel on its own with panelId.",
-    );
-  }
-  const controller = new AbortController();
-  const forwardAbort = () => controller.abort(signal?.reason);
-  if (signal?.aborted) forwardAbort();
-  signal?.addEventListener("abort", forwardAbort, { once: true });
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const timedOut = new Promise<PanelCostEstimate>((resolve) => {
-    timer = setTimeout(() => {
-      resolve(
-        timedOutPanel(
-          panel,
-          "Stopped: this panel's dry run didn't finish in time. Estimate it on its own with panelId.",
-        ),
-      );
-      controller.abort();
-    }, remaining);
-  });
-  try {
-    return await Promise.race([
-      estimateResolvedPanel(panel, scope, runsPerMonth, controller.signal),
-      timedOut,
-    ]);
-  } finally {
-    clearTimeout(timer);
-    signal?.removeEventListener("abort", forwardAbort);
-  }
-}
-
-async function mapPool<T, R>(
-  items: readonly T[],
-  concurrency: number,
-  fn: (item: T) => Promise<R>,
-): Promise<R[]> {
-  const results: R[] = Array(items.length);
-  let next = 0;
-  const worker = async () => {
-    while (next < items.length) {
-      const index = next++;
-      results[index] = await fn(items[index]);
-    }
-  };
-  await Promise.all(
-    Array.from({ length: Math.min(concurrency, items.length) }, worker),
-  );
-  return results;
-}
-
 function sentence(text: string): string {
   return /[.!?]$/.test(text) ? text : `${text}.`;
 }
 
-function describeEstimate(estimate: QueryCostEstimate): string {
-  if (
-    estimate.status === "not_bigquery" ||
-    estimate.status === "not_estimated"
-  ) {
-    return estimate.reason;
-  }
-  if (estimate.status === "failed") {
-    return `no estimate (${estimate.failure}): ${estimate.error}`;
-  }
-  const monthly =
-    estimate.usdPerMonth === null
-      ? "not scheduled"
-      : `~${formatUsd(estimate.usdPerMonth)}/month over ${estimate.runsPerMonth} scheduled runs`;
-  const flags = [
-    estimate.overPerRunThreshold
-      ? `over the ${formatUsd(QUERY_COST_THRESHOLDS.perRunUsd)}/run threshold`
-      : null,
-    estimate.overPerMonthThreshold
-      ? `over the ${formatUsd(QUERY_COST_THRESHOLDS.perMonthUsd)}/month threshold`
-      : null,
-  ].filter(Boolean);
-  return `~${formatBytes(estimate.estimatedBytes)}, ${formatUsd(estimate.usdPerRun)} per run, ${monthly}${flags.length ? ` (${flags.join("; ")})` : ""}`;
-}
-
 export default defineAction({
   description:
     "Free cost estimate for BigQuery SQL. Dry-runs the query through Analytics' own BigQuery connection (BigQuery reads and bills nothing) and returns the bytes it would scan, dollars per run at on-demand pricing, and dollars per month for scheduled runs. " +
@@ -312,20 +206,15 @@ export default defineAction({
       );
     }
 
-    const reportSchedules = await countEnabledDashboardReportSubscriptions(
-      dashboardId,
-      { email: userEmail, orgId },
-    );
-    const runsPerMonth =
-      args.runsPerMonth ??
-      (reportSchedules > 0 ? reportSchedules * DAYS_PER_MONTH : null);
-    const estimated = selected.slice(0, MAX_PANELS);
-    const deadline = startedAt + DASHBOARD_DEADLINE_MS;
-    const panels: PanelCostEstimate[] = await mapPool(
-      estimated,
-      DRY_RUN_CONCURRENCY,
-      (panel) =>
-        estimatePanelBefore(deadline, panel, scope, runsPerMonth, signal),
+    const schedule = await scheduledDashboardRuns(dashboardId, scope);
+    const reportSchedules = schedule.reportSchedules;
+    const runsPerMonth = args.runsPerMonth ?? schedule.runsPerMonth;
+    const panels: PanelCostEstimate[] = await estimateResolvedPanels(
+      selected.slice(0, MAX_PANELS),
+      scope,
+      runsPerMonth,
+      startedAt + DASHBOARD_DEADLINE_MS,
+      signal,
     );
     const total = totalCost(panels);
     const flagged = panels.filter(
@@ -358,16 +247,10 @@ export default defineAction({
         : args.runsPerMonth === undefined
           ? `~${formatUsd(total.usdPerMonth)}/month if its email reports use these filters`
           : `~${formatUsd(total.usdPerMonth)}/month in scheduled runs`;
-    const totalFlags = {
-      overPerRunThreshold: total.usdPerRun > QUERY_COST_THRESHOLDS.perRunUsd,
-      overPerMonthThreshold:
-        total.usdPerMonth !== null &&
-        total.usdPerMonth > QUERY_COST_THRESHOLDS.perMonthUsd,
-    };
     const totalOver = [
-      totalFlags.overPerRunThreshold &&
+      total.overPerRunThreshold &&
         `the ${formatUsd(QUERY_COST_THRESHOLDS.perRunUsd)}/run`,
-      totalFlags.overPerMonthThreshold &&
+      total.overPerMonthThreshold &&
         `the ${formatUsd(QUERY_COST_THRESHOLDS.perMonthUsd)}/month`,
     ].filter(Boolean);
 
@@ -383,11 +266,10 @@ export default defineAction({
         args.runsPerMonth !== undefined
           ? "caller"
           : reportSchedules > 0
-            ? `${reportSchedules} enabled daily email report${reportSchedules === 1 ? "" : "s"} ${orgId ? "in your org" : "of yours"}`
+            ? describeReportSchedules(reportSchedules, orgId)
             : "none",
       total: {
         ...total,
-        ...totalFlags,
         partial,
         scope: onePanel ? "panel" : "dashboard",
       },