@agent-native/core 0.120.1 → 0.120.2

package/corpus/templates/analytics/.agents/skills/adhoc-analysis/SKILL.md

@@ -2,12 +2,12 @@
 name: adhoc-analysis
 description: >-
   How to conduct ad-hoc analyses: gather data from multiple sources, synthesize
-  findings, save reusable analysis artifacts that anyone can re-run for fresh results.
+  findings, and save durable results as dashboard artifacts that anyone can re-run.
 ---
 
 # Ad-Hoc Analysis
 
-Ad-hoc analyses are deep-dive investigations that cross-reference multiple data sources and produce a written report with findings. Saving a reusable artifact is optional: answer in chat first unless the user explicitly asks to save the analysis, create a reusable artifact, or re-run/update an existing saved analysis.
+Ad-hoc analyses are deep-dive investigations that cross-reference multiple data sources and produce a written report with findings. The durable user-facing result is a dashboard. Answer in chat first unless the user explicitly asks to save the result, create a reusable artifact, or re-run/update an existing saved analysis.
 
 ## When to Use
 
@@ -17,21 +17,20 @@ Use the ad-hoc analysis workflow when:
 - The investigation involves cross-referencing (e.g., CRM deals matched against call recordings)
 - The user explicitly asks for an "analysis" or "deep dive"
 
-Save a reusable analysis only when:
+Save a reusable dashboard artifact when:
 
 - The user explicitly asks to save, create, publish, or re-run a saved analysis
 - The user is already viewing or re-running an existing saved analysis
 - The output needs a durable artifact because it includes generated chart images or a reusable refresh workflow
 
-For one-off questions and exploratory deep dives, query the data and answer in chat. Do not call `save-analysis` just because the user said "analysis" or "deep dive".
+For one-off questions and exploratory deep dives, query the data and answer in chat. Do not create a dashboard or call the legacy `save-analysis` action just because the user said "analysis" or "deep dive".
 
 If the user asks for an analysis output that needs a bespoke interactive
 surface, custom visualization, multi-step workflow, or UI that cannot be
-faithfully represented as saved-analysis Markdown, generated chart images, and
-structured `resultData`, create an extension instead of forcing the request into
-the saved-analysis format. In production mode, call `create-extension`
-automatically and tell the user the requested analysis needed bespoke UI/code, so
-you built it as an extension.
+faithfully represented by native dashboard panels, create an extension and
+immediately embed it in the dashboard as one or more `chartType: "extension"`
+panels with `config.extensionId`. Never leave the extension as a standalone
+Analytics result or direct the user to an Extensions page.
 
 ## Workflow
 
@@ -159,46 +158,33 @@ Time range: Jan 1 – Mar 31, 2026
 Filters: S1+ pipeline, closed-lost only
 ```
 
-### Step 6: Save the Analysis (only when requested)
+### Step 6: Save the Dashboard Artifact (only when requested)
 
-Call `save-analysis` with all required fields only when the user asked for a saved/re-runnable analysis or this turn is updating an existing saved analysis:
+Call `update-dashboard` with a complete dashboard config when the user asks for a saved/re-runnable analysis or this turn is creating a durable report. If the requested report needs bespoke UI, create the extension first and include its id in an extension panel.
 
 ```
-save-analysis
-  --id "closed-lost-q1-2026"
-  --name "Q1 2026 Closed-Lost Analysis"
-  --description "Deep dive into 54 Fusion deals closed-lost in Q1, cross-referenced with Gong calls and Slack activity"
-  --question "Why are we losing deals in Q1? Cross-reference with Gong calls and Slack."
-  --dataSources '["hubspot", "gong", "slack"]'
-  --instructions "1. Fetch closed-lost S1+ deals from HubSpot (pipeline: Fusion, close date: Q1 2026)
-2. For each deal, fetch associated contacts and their emails
-3. Search Gong calls matching those contact emails (lookback: 6 months before close date)
-4. For top 15 deals by amount, search Slack for '{company name} fusion'
-5. Calculate: total deals, avg deal size, win rate, Gong coverage rate
-6. Break down by: lost reason, stage reached, deal size tier
-7. Highlight deals with no Gong coverage (blind spots)
-8. Save results with save-analysis using id='closed-lost-q1-2026'"
-  --resultMarkdown "[the full markdown report]"
-  --resultData '{"deals": [...], "metrics": {...}}'
+update-dashboard
+  --dashboardId "closed-lost-q1-2026"
+  --config '{"name":"Q1 2026 Closed-Lost Analysis","panels":[{"id":"findings","title":"Findings","source":"first-party","chartType":"table","width":2,"sql":"...","config":{"description":"Evidence-backed report for the requested cohort."}}]}'
 ```
 
-`resultData` is required. Fill it with compact structured evidence from the real data-source action results you used: row samples, aggregate metrics, match decisions, call/message IDs, short transcript/message excerpts, coded themes, sentiment labels, and explicit provider errors for any gaps. Do not include full Gong transcripts, full tool outputs, or raw provider payload dumps. If you cannot query a source, do not save a guessed analysis; report the unavailable/error result instead.
+The dashboard config must preserve compact evidence from the real data-source action results you used: row samples, aggregate metrics, match decisions, call/message IDs, short transcript/message excerpts, coded themes, sentiment labels, and explicit provider errors for any gaps. Do not include full Gong transcripts, full tool outputs, or raw provider payload dumps. If you cannot query a source, do not save guessed dashboard content; report the unavailable/error result instead.
 
-**Critical: Write good instructions.** The `instructions` field is what gets sent to the agent on re-run. Be specific:
+**Critical: Write good dashboard definitions.** The dashboard description/config is what the agent uses on re-run. Be specific:
 
 - Which actions to call with which parameters
 - What filters to apply
 - How to match records across sources
 - What metrics to calculate
 - What structure the output should have
-- End with "Save results with save-analysis using id='...'"
+- End with "Update dashboard with id='...'"
 
 ### Step 7: Navigate to the Result
 
-After saving, navigate the user to see the saved analysis:
+After saving, navigate the user to see the saved dashboard:
 
 ```
-navigate --view=analyses --analysisId=closed-lost-q1-2026
+navigate --view=adhoc --dashboardId=closed-lost-q1-2026
 ```
 
 ## Re-Running an Analysis
@@ -209,7 +195,7 @@ When a user clicks "Re-run" on a saved analysis, the agent receives:
 - The saved instructions (step-by-step)
 - The analysis ID to update
 
-Follow the instructions to gather fresh data, then call `save-analysis` with the same `id` to update the results. The `createdAt` timestamp is preserved; `updatedAt` is refreshed.
+Follow the instructions to gather fresh data, then call `update-dashboard` with the same `dashboardId` to update the panels/report. Existing legacy analysis deep links remain readable, but new durable results must be written to dashboards.
 
 If the user challenges the coverage of a chat answer or saved analysis ("why
 aren't you pulling more deals?", "where is the updated response?"), rerun the
@@ -221,21 +207,19 @@ showing it or saving it.
 
 | Action            | Purpose                                                          |
 | ----------------- | ---------------------------------------------------------------- |
-| `save-analysis`   | Save or update an analysis (id, name, instructions, results)     |
-| `get-analysis`    | Retrieve a saved analysis by ID                                  |
-| `list-analyses`   | List all saved analyses (id, name, description, timestamps)      |
-| `delete-analysis` | Delete a saved analysis                                          |
-| `navigate`        | Navigate to analyses view: `--view=analyses [--analysisId=<id>]` |
+| `update-dashboard` | Save or update the dashboard artifact and its panels             |
+| `get-sql-dashboard` | Retrieve a dashboard by ID                                      |
+| `list-sql-dashboards` | List dashboard artifacts                                       |
+| `navigate`        | Navigate to a dashboard: `--view=adhoc --dashboardId=<id>`       |
 
 ## Storage
 
-Analyses are stored in the SQL settings table with key prefix `adhoc-analysis-{id}`. They respect org/user scoping — org-scoped analyses are visible to all org members.
+Dashboard artifacts are stored in SQL and respect the normal dashboard access model. Legacy analyses remain in their existing SQL tables for compatibility and should not be used for new artifacts.
 
 API endpoints (for UI consumption):
 
-- `GET /api/analyses` — list all
-- `GET /api/analyses/{id}` — get one
-- `DELETE /api/analyses/{id}` — delete one
+- `GET /api/sql-dashboards` — list dashboard artifacts
+- `GET /api/sql-dashboards/{id}` — get one
 
 ## Best Practices
 
@@ -257,7 +241,7 @@ hold everything in one pass:
    from the primary source (HubSpot, BigQuery, etc.).
 2. **Chunk and persist** — process 5-10 items per iteration. For each chunk,
    write a short per-item findings note (key signals, gaps, theme tags) as an
-   intermediate result to `save-analysis` or agent scratch.
+   intermediate result to the dashboard definition or agent scratch.
 3. **Synthesize** — after all chunks are complete, read the intermediate notes
    back in and produce the final cross-item synthesis (patterns, rankings,
    themes, recommendations).

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

@@ -7,7 +7,7 @@ description: >-
 
 # Dashboard Management
 
-Dashboards are SQL-backed resources. New dashboards and analyses live in the template tables, not in settings KV rows.
+Dashboards are the canonical SQL-backed Analytics resources. New dashboards, saved analyses, reports, and bespoke extensions are represented as dashboard artifacts—not as separate user-facing Analytics objects. Legacy analysis tables and actions remain available only for compatibility.
 
 ## Storage
 
@@ -25,6 +25,15 @@ Current storage:
 
 Legacy settings keys such as `u:<email>:dashboard-*`, `u:<email>:sql-dashboard-*`, `o:<orgId>:sql-dashboard-*`, and `adhoc-analysis-*` are still read as a fallback and copied into SQL on access. Do not create new dashboard settings rows.
 
+For organization-wide consolidation, use `migrate-analytics-artifacts` first
+with `dryRun: true`. The write requires an organization owner/admin and the
+exact confirmation token `MIGRATE_ANALYTICS_ARTIFACTS`. It materializes
+organization-scoped legacy settings, creates dashboard blocks for saved
+analyses and standalone extensions, archives exact duplicates, copies shares,
+and removes legacy settings keys only after SQL rows are materialized. Source
+rows remain recoverable. Private member-only rows are intentionally outside
+this organization-scoped operation.
+
 Use `mutate-dashboard` for existing dashboard edits. It resolves the current
 user/org context, validates the resulting config, writes the SQL-backed record,
 syncs collab, and returns compact proof. Use `update-dashboard` for new
@@ -104,13 +113,15 @@ standard panels, supported chart types, filters, variables, sections, and grid
 layout.
 
 If the user asks for a dashboard or analytical surface that needs bespoke UI or
-code beyond the dashboard JSON/component model, create an extension instead.
-Examples include custom interaction flows, non-standard visualizations, complex
-multi-step workflows, highly custom layouts, custom client-side state, or a
-dashboard-like app that needs behavior the built-in renderer cannot express. In
-production mode, call `create-extension` automatically and then tell the user
-that the request needed a bespoke surface, so you built it as an extension
-rather than forcing it into a native dashboard config.
+code beyond the dashboard JSON/component model, create an extension and embed it
+in the dashboard. Examples include custom interaction flows, non-standard
+visualizations, complex multi-step workflows, highly custom layouts, custom
+client-side state, or a dashboard-like app that needs behavior the built-in
+renderer cannot express. In production mode, call `create-extension`
+automatically, then call `update-dashboard` with one or more
+`chartType: "extension"` panels using `config.extensionId`. Never leave the
+extension as a standalone Analytics result or direct the user to the Extensions
+page.
 
 ## Embedding An Extension As A Panel
 

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

@@ -36,7 +36,7 @@ through `2026-05-02T04:00:00Z`.
 
 ## Showing Charts In Chat
 
-For an in-chat answer, **emit a live `/chart` embed** — never `generate-chart`. The embed mounts a live `SqlChart` that re-queries when its source changes, and it doesn't choke on rigid JSON params the way the PNG action does. Full shape in `AGENTS.md` ("Inline Charts in Chat" section). Reach for `generate-chart` only when you're building a `save-analysis` artifact whose markdown will render outside the app.
+For an in-chat answer, **emit a live `/chart` embed** — never `generate-chart`. The embed mounts a live `SqlChart` that re-queries when its source changes, and it doesn't choke on rigid JSON params the way the PNG action does. Full shape in `AGENTS.md` ("Inline Charts in Chat" section). Reach for `generate-chart` only when you're building a dashboard artifact that needs a persisted report image.
 
 If `generate-chart` returns an error in any chat-answering flow, the recovery is to switch to the live embed, not to retry with reformatted params.
 
@@ -136,7 +136,7 @@ future analyses.
 - Before finalizing an analytics answer, make the evidence trail explicit enough
   to audit: source(s), time window, filters, sample size or row count, join or
   match method, caveats/gaps, and what action to take next when useful.
-- Data-source status, data-dictionary reads, dashboard dry-runs, `update-dashboard`, `generate-chart`, and `save-analysis` are not data queries. For analyses and dashboards, run at least one provider query action and preserve the result evidence in the final answer or `resultData`.
+- Data-source status, data-dictionary reads, dashboard dry-runs, `update-dashboard`, and `generate-chart` are not data queries. For dashboard artifacts, run at least one provider query action and preserve the result evidence in the final answer or dashboard config/description.
 - Use action arguments such as `query`, `objectType`, `properties`, `owner`, `limit`, or provider-specific filters to narrow output; if an action returns a broad batch, filter it in your analysis and cite the records used.
 - Update the relevant `.agents/skills/<provider>/SKILL.md` when you discover new patterns.
 - For BigQuery queries, check `.agents/skills/bigquery/SKILL.md` first; if the data dictionary does not contain the exact table/columns, call `search-bigquery-schema`.

package/corpus/templates/analytics/AGENTS.md

@@ -1,8 +1,9 @@
 # Analytics — Agent Guide
 
 Analytics is an agent-native BI workspace. The agent manages data sources,
-queries, dashboards, charts, analyses, and connected warehouse integrations
-through actions and SQL-backed state.
+queries, dashboards, charts, and connected warehouse integrations through
+actions and SQL-backed state. Dashboards are the canonical user-facing
+analytics artifact; legacy analyses remain readable only for compatibility.
 
 Keep this file essential. Querying, dashboard, warehouse, and implementation
 details live in `.agents/skills/`.
@@ -175,13 +176,22 @@ membership id when its native update status reports `update-available`.
   `/agents?view=dashboards` shows the
   admin-only dashboard usage audit; call `list-dashboard-usage-stats` when
   admins ask about dashboard created/modified dates, owners, last tracked
-  modifier, views, engagements, saved views, or cleanup candidates. The
+  modifier, views, edits, engagements, saved views, or cleanup candidates. The
+  dashboard overflow menu shows created/updated timestamps and their tracked
+  actors for both SQL and Explorer dashboards. The
   Advanced menu opens `/agents?view=database`, where organization owners/admins
   can connect other agent-native app databases and use the shared database admin
   tool for table browsing, row editing, and SQL inspection. This database
   surface is for connected target app databases, not broad access to all
   Analytics data. Keep future admin additions inside this route instead of
   adding many top-level sidebar tabs.
+- The `migrate-analytics-artifacts` action is the organization-scoped
+  consolidation path. Run it first with `dryRun: true`, then use the exact
+  `confirm: "MIGRATE_ANALYTICS_ARTIFACTS"` token for an owner/admin-approved
+  write. It materializes legacy settings, turns saved analyses and standalone
+  extensions into dashboard blocks, archives exact duplicates, copies shares,
+  and keeps source rows recoverable. It intentionally covers organization-
+  scoped rows, not private member-only rows.
 - For dashboard edits, default to `mutate-dashboard` with its typed
   `dashboard.*` script API. It supports id-based panel moves, title/SQL/config
   edits, inserts, duplication, removal, and dashboard field patches in one
@@ -212,11 +222,13 @@ membership id when its native update status reports `update-available`.
 - `get-sql-dashboard` is compact by default for agents. Use its `panels`
   summaries and `layout.panelOrder` / `layout.firstPanelIds` for orientation and
   proof. Pass `includeConfig: true` only when full panel SQL/config is needed.
-- Native dashboards and saved analyses are constrained artifacts. If a requested
-  dashboard, analysis surface, visualization, interaction model, custom layout,
-  or bespoke workflow cannot be done faithfully with the built-in dashboard JSON
-  config/components or saved-analysis markdown/chart format, automatically build
-  it as an extension instead and tell the user why.
+- Native dashboards are constrained artifacts. If a requested dashboard,
+  analysis/report surface, visualization, interaction model, custom layout, or
+  bespoke workflow cannot be done faithfully with the built-in dashboard JSON
+  config/components, automatically create an extension and embed it as one or
+  more `chartType: "extension"` panels using `config.extensionId`. Never leave
+  the extension standalone or direct the user to an Extensions page from
+  Analytics.
 - For an existing extension-backed dashboard or migrated surface such as Risk
   Meeting, separate data repair from visual redesign. Inspect the dashboard and
   extension first, then call `update-extension` with exactly `id`,

package/corpus/templates/analytics/actions/get-explorer-dashboard.ts

@@ -33,6 +33,9 @@ export default defineAction({
       ownerEmail: dash.ownerEmail,
       orgId: dash.orgId,
       visibility: dash.visibility,
+      createdAt: dash.createdAt,
+      updatedAt: dash.updatedAt,
+      updatedBy: dash.updatedBy,
       role: dash.role,
       canEdit: dash.canEdit,
       canManage: dash.canManage,

package/corpus/templates/analytics/actions/list-dashboard-usage-stats.ts

@@ -1,6 +1,6 @@
 import { defineAction } from "@agent-native/core/action";
 import { buildDeepLink } from "@agent-native/core/server";
-import { and, eq, like, or, sql } from "drizzle-orm";
+import { and, eq, isNull, like, or, sql } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -21,6 +21,7 @@ type DashboardUsageStats = {
   viewCount: number;
   engagementCount: number;
   eventEngagementCount: number;
+  editCount: number;
   savedViewCount: number;
   uniqueUserCount: number;
   lastViewedAt: string | null;
@@ -96,6 +97,8 @@ export function dashboardIdFromEventLocation(
   if (!raw) return null;
   try {
     const parsed = new URL(raw, "https://analytics.local");
+    const parsedDashboardId = dashboardIdFromPath(parsed.pathname);
+    if (parsedDashboardId) return parsedDashboardId;
     if (
       /(?:^|\/)(?:dashboards|adhoc)\/explorer-dashboard$/.test(parsed.pathname)
     ) {
@@ -124,7 +127,7 @@ function dashboardUrl(row: { id: string; kind: string }): string {
 
 export default defineAction({
   description:
-    "List admin-only dashboard usage and cleanup stats for every dashboard in the active organization. Includes lifecycle metadata, owner, last tracked modifier, pageviews, engagement events, unique viewers, saved view counts, archive/hidden state, and dashboard links. Requires active organization owner/admin role.",
+    "List admin-only dashboard usage and cleanup stats for every dashboard in the active organization. Includes lifecycle metadata, owner, last tracked modifier, pageviews, edit counts, engagement events, unique viewers, saved view counts, archive/hidden state, and dashboard links. Requires active organization owner/admin role.",
   schema: z.object({}),
   http: { method: "GET" },
   readOnly: true,
@@ -144,24 +147,120 @@ export default defineAction({
     // guard:allow-unscoped — org owner/admin audit intentionally spans all
     // dashboard rows in the active org after requireDbAdminContextFromRequest.
     const dashboardRows = await db
-      .select()
+      .select({
+        id: schema.dashboards.id,
+        kind: schema.dashboards.kind,
+        title: schema.dashboards.title,
+        config: schema.dashboards.config,
+        ownerEmail: schema.dashboards.ownerEmail,
+        visibility: schema.dashboards.visibility,
+        createdAt: schema.dashboards.createdAt,
+        updatedAt: schema.dashboards.updatedAt,
+        updatedBy: schema.dashboards.updatedBy,
+        archivedAt: schema.dashboards.archivedAt,
+        hiddenAt: schema.dashboards.hiddenAt,
+        hiddenBy: schema.dashboards.hiddenBy,
+      })
       .from(schema.dashboards)
       .where(eq(schema.dashboards.orgId, admin.orgId));
 
+    if (dashboardRows.length === 0) return [];
+
     const dashboardIds = new Set<string>(
       dashboardRows.map((row: { id: string }) => row.id),
     );
 
-    const savedViewRows = await db
-      .select({
-        dashboardId: schema.dashboardViews.dashboardId,
-        count: sql<number>`count(*)`,
-        lastSavedViewAt: sql<
-          string | null
-        >`max(${schema.dashboardViews.createdAt})`,
-      })
-      .from(schema.dashboardViews)
-      .groupBy(schema.dashboardViews.dashboardId);
+    const analyticsUserIdentity = sql<
+      string | null
+    >`coalesce(nullif(${schema.analyticsEvents.userKey}, ''), nullif(${schema.analyticsEvents.userId}, ''), nullif(${schema.analyticsEvents.anonymousId}, ''), nullif(${schema.analyticsEvents.sessionId}, ''))`;
+    const indexedDashboardEventLocation = or(
+      like(schema.analyticsEvents.path, "/dashboards/%"),
+      like(schema.analyticsEvents.path, "/adhoc/%"),
+    );
+    const legacyAbsoluteUrlDashboardEventLocation = and(
+      or(
+        isNull(schema.analyticsEvents.path),
+        eq(schema.analyticsEvents.path, ""),
+      ),
+      or(
+        like(schema.analyticsEvents.url, "%/dashboards/%"),
+        like(schema.analyticsEvents.url, "%/adhoc/%"),
+      ),
+    );
+    const dashboardEventLocation = or(
+      indexedDashboardEventLocation,
+      legacyAbsoluteUrlDashboardEventLocation,
+    );
+
+    const [savedViewRows, revisionRows, eventRows, eventUserRows] =
+      await Promise.all([
+        db
+          .select({
+            dashboardId: schema.dashboardViews.dashboardId,
+            count: sql<number>`count(*)`,
+            lastSavedViewAt: sql<
+              string | null
+            >`max(${schema.dashboardViews.createdAt})`,
+          })
+          .from(schema.dashboardViews)
+          .innerJoin(
+            schema.dashboards,
+            and(
+              eq(schema.dashboardViews.dashboardId, schema.dashboards.id),
+              eq(schema.dashboards.orgId, admin.orgId),
+            ),
+          )
+          .groupBy(schema.dashboardViews.dashboardId),
+        db
+          .select({
+            dashboardId: schema.dashboardRevisions.dashboardId,
+            count: sql<number>`count(*)`,
+          })
+          .from(schema.dashboardRevisions)
+          .where(eq(schema.dashboardRevisions.orgId, admin.orgId))
+          .groupBy(schema.dashboardRevisions.dashboardId),
+        db
+          .select({
+            path: schema.analyticsEvents.path,
+            url: schema.analyticsEvents.url,
+            eventName: schema.analyticsEvents.eventName,
+            count: sql<number>`count(*)`,
+            lastSeenAt: sql<
+              string | null
+            >`max(${schema.analyticsEvents.receivedAt})`,
+          })
+          .from(schema.analyticsEvents)
+          .where(
+            and(
+              eq(schema.analyticsEvents.orgId, admin.orgId),
+              dashboardEventLocation,
+            ),
+          )
+          .groupBy(
+            schema.analyticsEvents.path,
+            schema.analyticsEvents.url,
+            schema.analyticsEvents.eventName,
+          ),
+        db
+          .select({
+            path: schema.analyticsEvents.path,
+            url: schema.analyticsEvents.url,
+            userIdentity: analyticsUserIdentity,
+          })
+          .from(schema.analyticsEvents)
+          .where(
+            and(
+              eq(schema.analyticsEvents.orgId, admin.orgId),
+              dashboardEventLocation,
+              sql`${analyticsUserIdentity} IS NOT NULL`,
+            ),
+          )
+          .groupBy(
+            schema.analyticsEvents.path,
+            schema.analyticsEvents.url,
+            analyticsUserIdentity,
+          ),
+      ]);
 
     const savedViewsByDashboard = new Map<
       string,
@@ -179,38 +278,15 @@ export default defineAction({
       });
     }
 
-    const analyticsUserIdentity = sql<
-      string | null
-    >`coalesce(nullif(${schema.analyticsEvents.userKey}, ''), nullif(${schema.analyticsEvents.userId}, ''), nullif(${schema.analyticsEvents.anonymousId}, ''), nullif(${schema.analyticsEvents.sessionId}, ''))`;
-    const eventRows = await db
-      .select({
-        path: schema.analyticsEvents.path,
-        url: schema.analyticsEvents.url,
-        eventName: schema.analyticsEvents.eventName,
-        count: sql<number>`count(*)`,
-        userIdentity: analyticsUserIdentity,
-        lastSeenAt: sql<
-          string | null
-        >`max(${schema.analyticsEvents.receivedAt})`,
-      })
-      .from(schema.analyticsEvents)
-      .where(
-        and(
-          eq(schema.analyticsEvents.orgId, admin.orgId),
-          or(
-            like(schema.analyticsEvents.path, "%/dashboards/%"),
-            like(schema.analyticsEvents.path, "%/adhoc/%"),
-            like(schema.analyticsEvents.url, "%/dashboards/%"),
-            like(schema.analyticsEvents.url, "%/adhoc/%"),
-          ),
-        ),
-      )
-      .groupBy(
-        schema.analyticsEvents.path,
-        schema.analyticsEvents.url,
-        schema.analyticsEvents.eventName,
-        analyticsUserIdentity,
-      );
+    const editsByDashboard = new Map<string, number>();
+    for (const row of revisionRows as Array<{
+      dashboardId: string;
+      count: unknown;
+    }>) {
+      if (dashboardIds.has(row.dashboardId)) {
+        editsByDashboard.set(row.dashboardId, toNumber(row.count));
+      }
+    }
 
     const eventsByDashboard = new Map<
       string,
@@ -226,7 +302,6 @@ export default defineAction({
       url: string | null;
       eventName: string;
       count: unknown;
-      userIdentity: string | null;
       lastSeenAt: string | null;
     }>) {
       const dashboardId = dashboardIdFromEventLocation(row.path, row.url);
@@ -248,6 +323,22 @@ export default defineAction({
       } else {
         current.eventEngagementCount += count;
       }
+      eventsByDashboard.set(dashboardId, current);
+    }
+
+    for (const row of eventUserRows as Array<{
+      path: string | null;
+      url: string | null;
+      userIdentity: string | null;
+    }>) {
+      const dashboardId = dashboardIdFromEventLocation(row.path, row.url);
+      if (!dashboardId || !dashboardIds.has(dashboardId)) continue;
+      const current = eventsByDashboard.get(dashboardId) ?? {
+        viewCount: 0,
+        eventEngagementCount: 0,
+        uniqueUsers: new Set<string>(),
+        lastViewedAt: null,
+      };
       if (row.userIdentity) current.uniqueUsers.add(row.userIdentity);
       eventsByDashboard.set(dashboardId, current);
     }
@@ -281,6 +372,7 @@ export default defineAction({
           hiddenBy: row.hiddenBy ?? null,
           viewCount: events.viewCount,
           eventEngagementCount: events.eventEngagementCount,
+          editCount: editsByDashboard.get(row.id) ?? 0,
           savedViewCount: savedViews.count,
           engagementCount: events.eventEngagementCount + savedViews.count,
           uniqueUserCount: events.uniqueUsers.size,
@@ -293,6 +385,8 @@ export default defineAction({
       .sort((a, b) => {
         const views = b.viewCount - a.viewCount;
         if (views !== 0) return views;
+        const edits = b.editCount - a.editCount;
+        if (edits !== 0) return edits;
         return b.updatedAt.localeCompare(a.updatedAt);
       });
   },

package/corpus/templates/analytics/actions/migrate-analytics-artifacts.ts

@@ -0,0 +1,48 @@
+import { defineAction } from "@agent-native/core/action";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { requireAnalyticsAdminContext } from "../server/lib/db-admin-connections";
+import {
+  migrateAnalyticsArtifacts,
+  type AnalyticsArtifactMigrationContext,
+} from "../server/lib/migrate-analytics-artifacts.js";
+
+const confirmation = "MIGRATE_ANALYTICS_ARTIFACTS" as const;
+
+export default defineAction({
+  description:
+    "Inventory or consolidate all organization-scoped Analytics dashboards, saved analyses, and extensions into the canonical Dashboards list. The default is a read-only dry run. A write requires an organization owner/admin and confirm=MIGRATE_ANALYTICS_ARTIFACTS; exact duplicates are archived/hidden, source rows remain recoverable, shares are copied, and legacy settings keys are removed only after SQL materialization.",
+  schema: z.object({
+    dryRun: z
+      .boolean()
+      .optional()
+      .default(true)
+      .describe("Inspect the migration without writing when true (default)."),
+    confirm: z
+      .literal(confirmation)
+      .optional()
+      .describe(
+        "Required for writes: MIGRATE_ANALYTICS_ARTIFACTS. Do not send this for a dry run.",
+      ),
+  }),
+  needsApproval: ({ dryRun }) => !dryRun,
+  run: async ({ dryRun, confirm }, ctx) => {
+    const userEmail = getRequestUserEmail() || ctx?.userEmail;
+    const orgId = getRequestOrgId() || ctx?.orgId || null;
+    const admin = await requireAnalyticsAdminContext({ userEmail, orgId });
+    if (!dryRun && confirm !== confirmation) {
+      throw new Error(
+        `Refusing the Analytics organization migration without confirm=${confirmation}. Run a dry run first, then repeat with the exact confirmation token.`,
+      );
+    }
+    const migrationContext: AnalyticsArtifactMigrationContext = {
+      userEmail: admin.userEmail,
+      orgId: admin.orgId,
+    };
+    return migrateAnalyticsArtifacts(migrationContext, { dryRun });
+  },
+});

package/corpus/templates/analytics/actions/save-analysis.ts

@@ -113,9 +113,8 @@ function assertCompactAnalysisPayload(args: {
 
 export default defineAction({
   description:
-    "Save an ad-hoc analysis as a reusable artifact. Do not call this for ordinary in-chat analysis or deep-dive answers unless the user explicitly asks to save/create a reusable analysis, or this turn is re-running an existing saved analysis. Stores the analysis question, instructions for re-running, data sources used, and compact results. " +
-    "This creates a reusable analysis that anyone can re-run later to get updated results. " +
-    "Saved analyses appear in the Analyses sidebar, so do not use this as scratch storage, as a transient summary, or as a duplicate companion artifact when creating a dashboard or extension unless the user explicitly asked for a saved analysis too. " +
+    "Legacy compatibility only: use this to re-run or update an existing saved analysis when the user explicitly names its legacy analysis id or asks to preserve that legacy record. Do not call this to create a new saved analysis, report, visualization, or bespoke workflow; new requests become dashboards, using update-dashboard and embedding any bespoke extension as one or more dashboard panels. Stores the legacy analysis question, instructions for re-running, data sources used, and compact results. " +
+    "Do not use this as scratch storage, a transient summary, or a duplicate companion artifact for a dashboard. " +
     "Call this only after you've gathered real evidence and include non-empty, compact resultData with structured evidence from those data-source action results. For qualitative analyses, resultData may include call/message IDs, short transcript excerpts, coded themes, mention counts, and sentiment labels derived from actual source records. Never include full Gong transcripts, full tool outputs, or bulk raw provider payloads.",
   schema: z.object({
     id: z

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

@@ -438,7 +438,7 @@ export default defineAction({
           includes: [
             "dashboard created and modified dates",
             "last tracked modifier",
-            "view and engagement counts",
+            "view, edit, and engagement counts",
             "saved view counts",
             "hidden and archived state",
           ],