@agent-native/core 0.87.0 → 0.90.1

package/corpus/templates/analytics/learnings.defaults.md

@@ -3,3 +3,39 @@
 <!-- This file is your app's memory. The AI reads it at the start of every conversation and updates it when it learns something new. -->
 <!-- Your personal learnings.md is gitignored so preferences and private info stay local. -->
 <!-- This defaults file is what new checkouts start with. -->
+
+The entries below are illustrative examples with fake names — replace them with
+real discoveries as you analyze your own data. Keep this file tidy: revise,
+consolidate, and remove outdated entries rather than appending forever.
+
+## Metric Definitions
+
+- **Active workspace** (example): a workspace with >= 3 distinct users firing
+  `app_opened` in a rolling 28-day window. Confirmed with the data team on
+  2026-01-15; use `dbt_analytics.active_workspaces_28d`, not a hand-rolled
+  count over raw events.
+
+## Schema Discoveries
+
+- The deals table (`dbt_mart.dim_deals` in this example) stores the deal stage
+  as `stage_name`, not `deal_stage` as the spec doc says, and `amount` is a
+  STRING — `CAST(amount AS FLOAT64)` before arithmetic. Verified via
+  `search-bigquery-schema` on 2026-01-20.
+
+## Identity Stitching
+
+- Joining product signups to CRM contacts requires BOTH the stable id AND a
+  lowercased email match — join on `user_id` plus
+  `LOWER(signups.email) = LOWER(contacts.email)`. An id-only join produced ~40
+  phantom matches for Example Corp because ids get recycled after merges.
+
+## Provider Gotchas
+
+- HubSpot (example): filtering deals by "reached stage X in date window" must
+  use the `hs_v2_date_entered_<stageId>` property via `provider-api-request`,
+  not amount/keyword heuristics — heuristic cohorts diverged ~48% from
+  stage-date cohorts. Get stage ids from `hubspot-pipelines` first.
+- Warehouse event tables must always be date-bounded (for example
+  `WHERE event_date >= DATE_SUB(CURRENT_DATE(), INTERVAL 30 DAY)`); an
+  unbounded scan of `example_events.pageviews` hit the byte limit and returned
+  nothing usable.

package/corpus/templates/analytics/seeds/data-programs/risk-meeting-cohort.js

@@ -0,0 +1,254 @@
+/**
+ * Data program: Risk Meeting cohort.
+ *
+ * This file is a STORED PROGRAM PAYLOAD, not a build source file. It is
+ * plain JS text persisted in the `data_programs.code` column (see
+ * `packages/core/src/data-programs/`) and executed exclusively server-side
+ * inside the existing run-code sandbox (`executeSandboxCode`). It is never
+ * imported, bundled, or type-checked by the template build — the repo rule
+ * against new `.js` source files does not apply to seed payloads under
+ * `seeds/`. Keep it readable: it is also the canonical teaching example for
+ * the generic provider-access pattern (see the `data-programs` skill).
+ *
+ * THE PATTERN, in one paragraph: any provider endpoint the agent can reach
+ * through `provider-api-catalog` / `provider-api-docs` can be called directly
+ * here with `providerFetch` / `providerFetchAll` — no hardcoded per-vendor
+ * action is required. Big intermediate responses (raw deal search pages,
+ * association batches, full account lists) stay server-side inside this
+ * sandbox and are NEVER returned to the agent or the browser. Only the small,
+ * already-joined `rows` array emitted at the bottom ever leaves this program
+ * — that's the "curl | grep | jq" mental model applied to authenticated
+ * provider APIs instead of a shell pipe.
+ *
+ * What this program does:
+ *   1. Searches HubSpot deals for a configurable cohort of `risk_status`
+ *      values with an open close date (arbitrary property filter + IN-search
+ *      — exactly the shape a hardcoded action can't anticipate for every
+ *      customer's custom properties).
+ *   2. Resolves each deal's primary company via the deals->companies
+ *      association endpoint, batched 100 at a time.
+ *   3. Resolves each company's domain, batched 100 at a time.
+ *   4. Fetches Pylon accounts and builds a sentiment-by-domain map
+ *      (a second, unrelated provider — proves cross-source joins need no
+ *      bespoke glue action).
+ *   5. Joins HubSpot deal rows with Pylon sentiment by domain and computes
+ *      `cross_source_flag` — a derived signal that only exists because this
+ *      program stitched two providers together.
+ *
+ * Params (all optional, all have defaults so the program is dry-runnable
+ * with zero args):
+ *   riskStatuses  string[] — HubSpot `risk_status` values to include.
+ *                 Defaults to the four canonical Risk Meeting statuses.
+ *   enterpriseOnly boolean — when true, only counts Pylon sentiment for
+ *                 accounts whose `account_profile` is
+ *                 "Enterprise Active Customer" (does not filter OUT deal
+ *                 rows — it only narrows which Pylon signals are considered
+ *                 authoritative for the sentiment join).
+ */
+
+const DEFAULT_RISK_STATUSES = [
+  "On the Radar",
+  "Churn Risk",
+  "Confirmed Churn",
+  "No Save Attempted",
+];
+
+const riskStatuses =
+  Array.isArray(params.riskStatuses) && params.riskStatuses.length > 0
+    ? params.riskStatuses
+    : DEFAULT_RISK_STATUSES;
+const enterpriseOnly = Boolean(params.enterpriseOnly);
+
+const HIGH_RISK_SENTIMENTS = ["frustrated", "high_risk_detractor"];
+
+function chunk(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) {
+    out.push(items.slice(i, i + size));
+  }
+  return out;
+}
+
+async function main() {
+  // -------------------------------------------------------------------
+  // Step 1: HubSpot deal-property cohort IN-search.
+  // -------------------------------------------------------------------
+  const dealSearch = await providerFetchAll(
+    "hubspot",
+    "/crm/v3/objects/deals/search",
+    {
+      method: "POST",
+      body: {
+        filterGroups: [
+          {
+            filters: [
+              {
+                propertyName: "risk_status",
+                operator: "IN",
+                values: riskStatuses,
+              },
+              {
+                propertyName: "closedate",
+                operator: "GT",
+                value: String(Date.now()),
+              },
+            ],
+          },
+        ],
+        properties: [
+          "dealname",
+          "risk_status",
+          "risk_summary",
+          "risk_category",
+          "hs_next_step",
+          "churn_notes",
+          "total_contract_value",
+          "customer_success_owner",
+          "dealstage",
+          "closedate",
+        ],
+        limit: 100,
+      },
+      itemsPath: "results",
+      pagination: {
+        cursorBodyPath: "after",
+        nextCursorPath: "paging.next.after",
+        maxPages: 20,
+      },
+    },
+  );
+
+  const deals = dealSearch.items || [];
+  const dealIds = deals.map((deal) => deal && deal.id).filter(Boolean);
+
+  // -------------------------------------------------------------------
+  // Step 2: batched deal -> company associations. Big intermediate
+  // (per-deal association rows) never leaves this program.
+  // -------------------------------------------------------------------
+  const companyByDeal = {};
+  for (const batch of chunk(dealIds, 100)) {
+    if (batch.length === 0) continue;
+    const assoc = await providerFetch(
+      "hubspot",
+      "/crm/v3/associations/deals/companies/batch/read",
+      { method: "POST", body: { inputs: batch.map((id) => ({ id })) } },
+    );
+    const results = (assoc && assoc.results) || [];
+    for (const result of results) {
+      const dealId = result && result.from && result.from.id;
+      const companyId =
+        result && Array.isArray(result.to) && result.to.length > 0
+          ? result.to[0].id
+          : null;
+      if (dealId && companyId) companyByDeal[dealId] = companyId;
+    }
+  }
+
+  // -------------------------------------------------------------------
+  // Step 3: batched company -> domain lookup.
+  // -------------------------------------------------------------------
+  const companyIds = Array.from(new Set(Object.values(companyByDeal))).filter(
+    Boolean,
+  );
+  const domainByCompany = {};
+  for (const batch of chunk(companyIds, 100)) {
+    if (batch.length === 0) continue;
+    const companies = await providerFetch(
+      "hubspot",
+      "/crm/v3/objects/companies/batch/read",
+      {
+        method: "POST",
+        body: { inputs: batch.map((id) => ({ id })), properties: ["domain"] },
+      },
+    );
+    const results = (companies && companies.results) || [];
+    for (const result of results) {
+      const companyId = result && result.id;
+      const domain =
+        result && result.properties && result.properties.domain
+          ? String(result.properties.domain).toLowerCase()
+          : null;
+      if (companyId && domain) domainByCompany[companyId] = domain;
+    }
+  }
+
+  // -------------------------------------------------------------------
+  // Step 4: Pylon account sentiment, keyed by domain. Second provider,
+  // zero bespoke glue action required.
+  // -------------------------------------------------------------------
+  const pylonAccounts = await providerFetchAll("pylon", "/accounts", {
+    itemsPath: "data",
+    pagination: {
+      cursorParam: "cursor",
+      nextCursorPath: "pagination.cursor",
+      maxPages: 20,
+    },
+  });
+
+  const sentimentByDomain = {};
+  for (const account of pylonAccounts.items || []) {
+    if (!account) continue;
+    const domain =
+      typeof account.domain === "string" ? account.domain.toLowerCase() : null;
+    if (!domain) continue;
+    if (
+      enterpriseOnly &&
+      account.account_profile !== "Enterprise Active Customer"
+    ) {
+      continue;
+    }
+    if (account.general_sentiment) {
+      sentimentByDomain[domain] = account.general_sentiment;
+    }
+  }
+
+  // -------------------------------------------------------------------
+  // Step 5: join + emit. csm_name is computed HERE, in the program — never
+  // baked into a generic hubspot-deals action.
+  // -------------------------------------------------------------------
+  const rows = deals.map((deal) => {
+    const props = (deal && deal.properties) || {};
+    const dealId = deal && deal.id;
+    const companyId = dealId ? companyByDeal[dealId] : null;
+    const domain = companyId ? domainByCompany[companyId] : null;
+    const sentiment = domain ? sentimentByDomain[domain] || null : null;
+
+    return {
+      deal_id: dealId || null,
+      deal_name: props.dealname || null,
+      risk_status: props.risk_status || null,
+      risk_summary: props.risk_summary || null,
+      risk_category: props.risk_category || null,
+      next_step: props.hs_next_step || null,
+      churn_notes: props.churn_notes || null,
+      arr: Number(props.total_contract_value || 0),
+      csm_name: props.customer_success_owner || null,
+      dealstage: props.dealstage || null,
+      closedate: props.closedate || null,
+      domain: domain || null,
+      pylon_sentiment: sentiment,
+      cross_source_flag: Boolean(
+        domain && HIGH_RISK_SENTIMENTS.includes(sentiment),
+      ),
+    };
+  });
+
+  emit(rows, [
+    { name: "deal_id", type: "string" },
+    { name: "deal_name", type: "string" },
+    { name: "risk_status", type: "string" },
+    { name: "risk_summary", type: "string" },
+    { name: "risk_category", type: "string" },
+    { name: "next_step", type: "string" },
+    { name: "churn_notes", type: "string" },
+    { name: "arr", type: "number" },
+    { name: "csm_name", type: "string" },
+    { name: "dealstage", type: "string" },
+    { name: "closedate", type: "string" },
+    { name: "domain", type: "string" },
+    { name: "pylon_sentiment", type: "string" },
+    { name: "cross_source_flag", type: "boolean" },
+  ]);
+}
+
+await main();

package/corpus/templates/analytics/seeds/data-programs/risk-meeting-pylon-early-warning.js

@@ -0,0 +1,184 @@
+/**
+ * Data program: Risk Meeting Pylon early-warning accounts.
+ *
+ * Stored program payload (see the comment at the top of
+ * `risk-meeting-cohort.js` in this same directory for the full explanation
+ * of why this is a `.js` seed file, not a build source file, and how the
+ * generic provider-access pattern works).
+ *
+ * This program surfaces Pylon-only risk signal: enterprise accounts Pylon
+ * already flags as at-risk (by support/CS sentiment) that have NOT yet shown
+ * up as a HubSpot deal in the Risk Meeting cohort. That gap is exactly the
+ * "early warning" — support signal outrunning CRM signal — that a
+ * single-provider dashboard could never surface, because it requires
+ * excluding one provider's cohort from another provider's cohort. Nothing
+ * here is a hardcoded action: it is two `providerFetchAll` calls and a
+ * domain-set subtraction.
+ *
+ * Params (all optional):
+ *   riskStatuses  string[] — same HubSpot `risk_status` values used by
+ *                 risk-meeting-cohort.js, so the "already in the HubSpot
+ *                 cohort" exclusion set matches that program's definition.
+ *                 Defaults to the same four canonical statuses.
+ */
+
+const DEFAULT_RISK_STATUSES = [
+  "On the Radar",
+  "Churn Risk",
+  "Confirmed Churn",
+  "No Save Attempted",
+];
+
+const riskStatuses =
+  Array.isArray(params.riskStatuses) && params.riskStatuses.length > 0
+    ? params.riskStatuses
+    : DEFAULT_RISK_STATUSES;
+
+const HIGH_RISK_SENTIMENTS = ["frustrated", "high_risk_detractor"];
+const ENTERPRISE_PROFILE = "Enterprise Active Customer";
+
+function chunk(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) {
+    out.push(items.slice(i, i + size));
+  }
+  return out;
+}
+
+/**
+ * Lighter variant of risk-meeting-cohort.js's HubSpot resolution: we only
+ * need the set of domains already covered by the HubSpot cohort, not the
+ * full deal detail, so we skip fetching deal-only properties we won't use.
+ */
+async function hubspotCohortDomains() {
+  const dealSearch = await providerFetchAll(
+    "hubspot",
+    "/crm/v3/objects/deals/search",
+    {
+      method: "POST",
+      body: {
+        filterGroups: [
+          {
+            filters: [
+              {
+                propertyName: "risk_status",
+                operator: "IN",
+                values: riskStatuses,
+              },
+              {
+                propertyName: "closedate",
+                operator: "GT",
+                value: String(Date.now()),
+              },
+            ],
+          },
+        ],
+        properties: ["dealname"],
+        limit: 100,
+      },
+      itemsPath: "results",
+      pagination: {
+        cursorBodyPath: "after",
+        nextCursorPath: "paging.next.after",
+        maxPages: 20,
+      },
+    },
+  );
+
+  const dealIds = (dealSearch.items || [])
+    .map((deal) => deal && deal.id)
+    .filter(Boolean);
+
+  const companyByDeal = {};
+  for (const batch of chunk(dealIds, 100)) {
+    if (batch.length === 0) continue;
+    const assoc = await providerFetch(
+      "hubspot",
+      "/crm/v3/associations/deals/companies/batch/read",
+      { method: "POST", body: { inputs: batch.map((id) => ({ id })) } },
+    );
+    const results = (assoc && assoc.results) || [];
+    for (const result of results) {
+      const dealId = result && result.from && result.from.id;
+      const companyId =
+        result && Array.isArray(result.to) && result.to.length > 0
+          ? result.to[0].id
+          : null;
+      if (dealId && companyId) companyByDeal[dealId] = companyId;
+    }
+  }
+
+  const companyIds = Array.from(new Set(Object.values(companyByDeal))).filter(
+    Boolean,
+  );
+  const domains = new Set();
+  for (const batch of chunk(companyIds, 100)) {
+    if (batch.length === 0) continue;
+    const companies = await providerFetch(
+      "hubspot",
+      "/crm/v3/objects/companies/batch/read",
+      {
+        method: "POST",
+        body: { inputs: batch.map((id) => ({ id })), properties: ["domain"] },
+      },
+    );
+    const results = (companies && companies.results) || [];
+    for (const result of results) {
+      const domain =
+        result && result.properties && result.properties.domain
+          ? String(result.properties.domain).toLowerCase()
+          : null;
+      if (domain) domains.add(domain);
+    }
+  }
+  return domains;
+}
+
+async function main() {
+  const [pylonAccounts, coveredDomains] = await Promise.all([
+    providerFetchAll("pylon", "/accounts", {
+      itemsPath: "data",
+      pagination: {
+        cursorParam: "cursor",
+        nextCursorPath: "pagination.cursor",
+        maxPages: 20,
+      },
+    }),
+    hubspotCohortDomains(),
+  ]);
+
+  const rows = [];
+  for (const account of pylonAccounts.items || []) {
+    if (!account) continue;
+    const domain =
+      typeof account.domain === "string" ? account.domain.toLowerCase() : null;
+    const sentiment = account.general_sentiment || null;
+    const profile = account.account_profile || null;
+
+    const isEnterprise = profile === ENTERPRISE_PROFILE;
+    const isHighRisk = Boolean(
+      sentiment && HIGH_RISK_SENTIMENTS.includes(sentiment),
+    );
+    const alreadyInHubspotCohort = Boolean(
+      domain && coveredDomains.has(domain),
+    );
+
+    if (!isEnterprise || !isHighRisk || alreadyInHubspotCohort) continue;
+
+    rows.push({
+      account_name: account.name || account.account_name || null,
+      domain: domain || null,
+      pylon_sentiment: sentiment,
+      account_profile: profile,
+    });
+  }
+
+  emit(rows, [
+    { name: "account_name", type: "string" },
+    { name: "domain", type: "string" },
+    { name: "pylon_sentiment", type: "string" },
+    { name: "account_profile", type: "string" },
+  ]);
+}
+
+await main();

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

@@ -1,6 +1,12 @@
 import { createGetDb } from "@agent-native/core/db";
 import { registerShareableResource } from "@agent-native/core/sharing";
 
+import {
+  ANALYTICS_ANALYSIS_AGENT_CONTEXT_ENDPOINT,
+  ANALYTICS_ANALYSIS_AGENT_RESOURCE_KIND,
+  ANALYTICS_DASHBOARD_AGENT_CONTEXT_ENDPOINT,
+  ANALYTICS_DASHBOARD_AGENT_RESOURCE_KIND,
+} from "../../shared/resource-agent-access.js";
 import * as schema from "./schema.js";
 
 export const getDb = createGetDb(schema);
@@ -13,6 +19,10 @@ registerShareableResource({
   displayName: "Dashboard",
   titleColumn: "title",
   getResourcePath: (dashboard) => `/dashboards/${dashboard.id}`,
+  agentReadable: {
+    resourceKind: ANALYTICS_DASHBOARD_AGENT_RESOURCE_KIND,
+    getContextPath: () => ANALYTICS_DASHBOARD_AGENT_CONTEXT_ENDPOINT,
+  },
   getDb,
 });
 
@@ -23,6 +33,10 @@ registerShareableResource({
   displayName: "Analysis",
   titleColumn: "name",
   getResourcePath: (analysis) => `/analyses/${analysis.id}`,
+  agentReadable: {
+    resourceKind: ANALYTICS_ANALYSIS_AGENT_RESOURCE_KIND,
+    getContextPath: () => ANALYTICS_ANALYSIS_AGENT_CONTEXT_ENDPOINT,
+  },
   getDb,
 });
 

package/corpus/templates/analytics/server/handlers/sql-query.ts

@@ -19,7 +19,7 @@ export const handleSqlQuery = defineEventHandler(async (event) => {
       setResponseStatus(event, 400);
       return {
         error:
-          "Invalid source. Must be 'bigquery', 'ga4', 'amplitude', 'first-party', 'demo', or 'prometheus'",
+          "Invalid source. Must be 'bigquery', 'ga4', 'amplitude', 'first-party', 'demo', 'prometheus', or 'program'",
       };
     }
 

package/corpus/templates/analytics/server/lib/agent-readable-resource-context.ts

@@ -0,0 +1,156 @@
+import { getPanelOrder } from "../../actions/dashboard-panel-order.js";
+import { buildDashboardPanelGroups } from "../../app/pages/adhoc/sql-dashboard/dashboard-layout";
+import {
+  clampDashboardColumns,
+  type SqlPanel,
+} from "../../app/pages/adhoc/sql-dashboard/types";
+import type { AnalysisRecord, DashboardRecord } from "./dashboards-store.js";
+
+function dashboardLayoutSummary(config: Record<string, unknown>) {
+  const panels = Array.isArray(config.panels)
+    ? (config.panels as SqlPanel[])
+    : [];
+  const columns = clampDashboardColumns(config.columns);
+  const groups = buildDashboardPanelGroups(panels, columns);
+  const panelOrder = getPanelOrder(config);
+  let visibleRowNumber = 1;
+
+  return {
+    panelCount: panelOrder.length,
+    panelOrder,
+    firstPanelIds: panelOrder.slice(0, 10),
+    groups: groups.map((group) => ({
+      key: group.key,
+      sectionId: group.section?.id ?? null,
+      sectionTitle: group.section?.title ?? null,
+      columns: group.columns,
+      rows: group.rows.map((row, rowIndex) => {
+        const rowNumber = visibleRowNumber++;
+        return {
+          rowNumber,
+          rowIndex,
+          panelIds: row.panels.map((panel) => panel.id),
+        };
+      }),
+    })),
+  };
+}
+
+function panelSummaries(config: Record<string, unknown>) {
+  const panels = Array.isArray(config.panels)
+    ? (config.panels as Array<Record<string, unknown>>)
+    : [];
+  return panels.map((panel, index) => {
+    const panelConfig =
+      panel.config &&
+      typeof panel.config === "object" &&
+      !Array.isArray(panel.config)
+        ? (panel.config as Record<string, unknown>)
+        : {};
+    return {
+      index,
+      id: typeof panel.id === "string" ? panel.id : "",
+      title: typeof panel.title === "string" ? panel.title : "",
+      chartType: typeof panel.chartType === "string" ? panel.chartType : "",
+      source: typeof panel.source === "string" ? panel.source : undefined,
+      width: typeof panel.width === "number" ? panel.width : undefined,
+      columns: typeof panel.columns === "number" ? panel.columns : undefined,
+      tab: typeof panel.tab === "string" ? panel.tab : undefined,
+      description:
+        typeof panelConfig.description === "string"
+          ? panelConfig.description
+          : undefined,
+    };
+  });
+}
+
+export function buildDashboardAgentContext(
+  dashboard: DashboardRecord,
+  options: { includeConfig?: boolean } = {},
+): Record<string, unknown> {
+  const config = dashboard.config as Record<string, unknown>;
+  const base = {
+    resourceType: "analytics-dashboard",
+    id: dashboard.id,
+    kind: dashboard.kind,
+    name: typeof config.name === "string" ? config.name : dashboard.title,
+    title: dashboard.title,
+    description:
+      typeof config.description === "string" ? config.description : undefined,
+    filters: config.filters,
+    variables: config.variables,
+    columns: config.columns,
+    panels: panelSummaries(config),
+    layout: dashboardLayoutSummary(config),
+    ownerEmail: dashboard.ownerEmail,
+    orgId: dashboard.orgId,
+    visibility: dashboard.visibility,
+    role: dashboard.role,
+    canEdit: dashboard.canEdit,
+    canManage: dashboard.canManage,
+    archivedAt: dashboard.archivedAt,
+    hiddenAt: dashboard.hiddenAt,
+    hiddenBy: dashboard.hiddenBy,
+    createdAt: dashboard.createdAt,
+    updatedAt: dashboard.updatedAt,
+    url: `/dashboards/${dashboard.id}`,
+  };
+  return options.includeConfig === false ? base : { ...base, ...config };
+}
+
+export function buildDashboardSeedAgentContext(
+  id: string,
+  seed: Record<string, unknown>,
+  options: { includeConfig?: boolean } = {},
+): Record<string, unknown> {
+  const base = {
+    resourceType: "analytics-dashboard",
+    id,
+    kind: "sql",
+    name: typeof seed.name === "string" ? seed.name : id,
+    title: typeof seed.name === "string" ? seed.name : id,
+    description:
+      typeof seed.description === "string" ? seed.description : undefined,
+    filters: seed.filters,
+    variables: seed.variables,
+    columns: seed.columns,
+    panels: panelSummaries(seed),
+    layout: dashboardLayoutSummary(seed),
+    ownerEmail: null,
+    orgId: null,
+    visibility: "org",
+    archivedAt: null,
+    hiddenAt: null,
+    hiddenBy: null,
+    url: `/dashboards/${id}`,
+  };
+  return options.includeConfig === false ? base : { ...base, ...seed };
+}
+
+export function buildAnalysisAgentContext(
+  analysis: AnalysisRecord,
+): Record<string, unknown> {
+  return {
+    resourceType: "analytics-analysis",
+    id: analysis.id,
+    name: analysis.name,
+    description: analysis.description,
+    question: analysis.question,
+    instructions: analysis.instructions,
+    dataSources: analysis.dataSources,
+    resultMarkdown: analysis.resultMarkdown,
+    resultData: analysis.resultData,
+    author: analysis.author,
+    createdAt: analysis.createdAt,
+    updatedAt: analysis.updatedAt,
+    ownerEmail: analysis.ownerEmail,
+    orgId: analysis.orgId,
+    visibility: analysis.visibility,
+    role: analysis.role,
+    canEdit: analysis.canEdit,
+    canManage: analysis.canManage,
+    hiddenAt: analysis.hiddenAt,
+    hiddenBy: analysis.hiddenBy,
+    url: `/analyses/${analysis.id}`,
+  };
+}