@agent-native/core 0.96.0 → 0.98.0

package/corpus/core/src/triggers/dispatcher.ts

@@ -14,9 +14,11 @@ import {
 import {
   runAgentLoop,
   actionsToEngineTools,
+  filterInitialEngineTools,
   getOwnerActiveApiKey,
   type ActionEntry,
 } from "../agent/production-agent.js";
+import { attachToolSearch } from "../agent/tool-search.js";
 import type { AgentChatEvent } from "../agent/types.js";
 import { createThread } from "../chat-threads/store.js";
 import { subscribe, unsubscribe } from "../event-bus/index.js";
@@ -152,6 +154,13 @@ export function buildTriggerContent(
 export interface TriggerDispatcherDeps {
   getActions: () => Record<string, ActionEntry>;
   getSystemPrompt: (owner: string) => Promise<string>;
+  /**
+   * Tool names to expose on the FIRST engine request for a trigger run. See
+   * `SchedulerDeps.getInitialToolNames` (`jobs/scheduler.ts`) — same
+   * semantics. Omit to keep the full `getActions()` set visible up front
+   * (current behavior).
+   */
+  getInitialToolNames?: () => string[] | undefined;
   apiKey?: string;
   model?: string;
   /** App/template id used for org-scoped per-app model defaults. */
@@ -401,9 +410,20 @@ async function dispatchAgentic(
     { userEmail: jobUserEmail, orgId: jobOrgId },
     async () => {
       try {
-        const actions = _deps!.getActions();
+        const baseActions = _deps!.getActions();
         const systemPrompt = await _deps!.getSystemPrompt(jobUserEmail);
-        const tools = actionsToEngineTools(actions);
+        const initialToolNames = _deps!.getInitialToolNames?.();
+        // Only attach tool-search (and pay its schema cost) when the caller
+        // actually supplied an initial subset to filter down to — otherwise
+        // this is byte-for-byte the prior unfiltered behavior.
+        const actions = initialToolNames
+          ? attachToolSearch({ ...baseActions })
+          : baseActions;
+        const availableTools = actionsToEngineTools(actions);
+        const tools = filterInitialEngineTools(
+          availableTools,
+          initialToolNames,
+        );
 
         const engine = await resolveEngine({
           apiKey,
@@ -457,6 +477,7 @@ ${body}`;
             model,
             systemPrompt,
             tools,
+            availableTools,
             messages,
             actions,
             send: (event) => events.push(event),

package/corpus/core/src/triggers/types.ts

@@ -15,7 +15,13 @@ export interface TriggerFrontmatter {
   event?: string;
   /** Natural-language condition evaluated by Haiku before dispatch. */
   condition?: string;
-  /** "agentic" = full runAgentLoop. "deterministic" = fixed action set. */
+  /**
+   * "agentic" = full runAgentLoop; the only mode `manage-automations` will
+   * define/update going forward. "deterministic" was removed from the
+   * advertised surface (never implemented) and is legacy-only: rows created
+   * before the removal may still carry it, and the dispatcher's
+   * warn-and-skip branch keeps them inert by design — do not make them fire.
+   */
   mode: "agentic" | "deterministic";
   /** Domain tag for filtering in per-template UIs. */
   domain?: string;

package/corpus/core/src/vite/client.ts

@@ -5,7 +5,13 @@ import { createRequire, syncBuiltinESMExports } from "module";
 import path from "path";
 import { fileURLToPath } from "url";
 
-import type { ConfigEnv, Plugin, UserConfig } from "vite";
+import type {
+  ConfigEnv,
+  HotUpdateOptions,
+  NormalizedHotChannel,
+  Plugin,
+  UserConfig,
+} from "vite";
 
 import {
   mergePendingChangelog,
@@ -224,7 +230,124 @@ function nitroVitePlugin(
   ...args: Parameters<typeof import("nitro/vite").nitro>
 ) {
   installNitroFsWatchGuard();
-  return require("nitro/vite").nitro(...args);
+  const plugins = require("nitro/vite").nitro(...args) as Plugin[];
+  return plugins.map(debounceNitroFullReloadHotUpdate);
+}
+
+/**
+ * Debounce window for coalescing Nitro's dev-mode full-reload broadcasts.
+ *
+ * Nitro's own Vite plugin (the `hotUpdate` hook inside `nitro/vite`)
+ * invalidates each changed server module in the module graph synchronously,
+ * then sends `{ type: "full-reload" }` over that environment's hot channel —
+ * once per file-change event, with no debounce of its own. Every full-reload
+ * makes the Nitro dev worker re-import the entire SSR/server entry point,
+ * which is expensive. AI coding agents routinely write dozens of files in a
+ * single burst, so one edit session can trigger dozens of sequential
+ * re-imports back to back and pin a CPU core for minutes. This is a distinct
+ * concern from `fullReloadOnOptimizeDep504` elsewhere in this file (which
+ * rate-limits an unrelated client-reload nudge); keep the two independent.
+ */
+const NITRO_FULL_RELOAD_DEBOUNCE_MS = 300;
+
+/**
+ * Wraps a single Nitro-provided Vite plugin so that, if it defines a
+ * `hotUpdate` hook, any `environment.hot.send({ type: "full-reload" })` call
+ * made from inside that hook is coalesced with a trailing debounce (leading
+ * edge suppressed) instead of firing immediately for every changed file.
+ * Everything else — module-graph invalidation, non-reload hot messages, the
+ * hook's return value — passes through unchanged and immediate. A burst of
+ * N changes within the debounce window collapses into exactly one
+ * full-reload once things go quiet; a single isolated change still reloads,
+ * just delayed by up to `NITRO_FULL_RELOAD_DEBOUNCE_MS`.
+ *
+ * `hotUpdate` only ever runs on Vite's dev server (never during a build), so
+ * this has no effect outside `vite dev`.
+ */
+function debounceNitroFullReloadHotUpdate(plugin: Plugin): Plugin {
+  const originalHook = plugin.hotUpdate;
+  if (!originalHook) return plugin;
+
+  // Vite hook properties are either a plain function or `{ handler, ... }`
+  // ("object form", used to attach hook metadata like `order`). Support both.
+  const isHandlerForm = typeof originalHook === "object";
+  const originalHandler = (
+    isHandlerForm
+      ? (originalHook as { handler: unknown }).handler
+      : originalHook
+  ) as (
+    this: { environment: { name: string; hot: NormalizedHotChannel } },
+    options: HotUpdateOptions,
+  ) => unknown;
+
+  // One pending-reload timer per Vite environment name ("ssr" by default, or
+  // a named Nitro service environment), so unrelated environments can never
+  // block or coalesce into each other.
+  const pendingReloadTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+  function wrappedHotUpdate(
+    this: { environment: { name: string; hot: NormalizedHotChannel } },
+    options: HotUpdateOptions,
+  ) {
+    const realEnvironment = this.environment;
+    // Proxy `this.environment.hot.send` so nitro's hook body (which reads
+    // `this.environment` and calls `env.hot.send(...)`) is otherwise
+    // untouched — only full-reload payloads get intercepted below.
+    const proxiedThis = new Proxy(this, {
+      get(target, prop, receiver) {
+        if (prop !== "environment") {
+          return Reflect.get(target, prop, receiver);
+        }
+        return new Proxy(realEnvironment, {
+          get(envTarget, envProp, envReceiver) {
+            if (envProp !== "hot") {
+              return Reflect.get(envTarget, envProp, envReceiver);
+            }
+            const realHot = envTarget.hot;
+            return new Proxy(realHot, {
+              get(hotTarget, hotProp, hotReceiver) {
+                if (hotProp !== "send") {
+                  return Reflect.get(hotTarget, hotProp, hotReceiver);
+                }
+                return (payload: unknown) => {
+                  if (
+                    !payload ||
+                    typeof payload !== "object" ||
+                    (payload as { type?: string }).type !== "full-reload"
+                  ) {
+                    // Not a full-reload — pass through immediately.
+                    return (hotTarget.send as (p: unknown) => void)(payload);
+                  }
+                  const key = realEnvironment.name || "default";
+                  const pending = pendingReloadTimers.get(key);
+                  if (pending) clearTimeout(pending);
+                  const timer = setTimeout(() => {
+                    pendingReloadTimers.delete(key);
+                    (hotTarget.send as (p: unknown) => void)(payload);
+                  }, NITRO_FULL_RELOAD_DEBOUNCE_MS);
+                  // Never hold the process open just for a pending reload.
+                  timer.unref?.();
+                  pendingReloadTimers.set(key, timer);
+                };
+              },
+            });
+          },
+        });
+      },
+    });
+    return originalHandler.call(proxiedThis, options);
+  }
+
+  if (isHandlerForm) {
+    return {
+      ...plugin,
+      hotUpdate: {
+        ...(originalHook as object),
+        handler: wrappedHotUpdate,
+      },
+    } as Plugin;
+  }
+  return { ...plugin, hotUpdate: wrappedHotUpdate } as Plugin;
 }
 
 /**
@@ -2797,4 +2920,5 @@ export {
   getDefaultOptimizeDeps as _getDefaultOptimizeDeps,
   findCorePackageRoot as _findCorePackageRoot,
   getReactRouterAliases as _getReactRouterAliases,
+  debounceNitroFullReloadHotUpdate as _debounceNitroFullReloadHotUpdate,
 };

package/corpus/core/tsconfig.cli.json

@@ -8,7 +8,7 @@
     "incremental": true,
     "tsBuildInfoFile": "node_modules/.cache/tsbuildinfo/core-cli.tsbuildinfo"
   },
-  "include": ["src/cli/**/*.ts"],
+  "include": ["src/cli/**/*.ts", "src/testing.ts"],
   "exclude": [
     "node_modules",
     "dist",

package/corpus/core/tsconfig.json

@@ -33,6 +33,10 @@
     // TODO: fenced concurrent-agent work — flip strict after in-flight PRs land
     // recap.ts, skills.ts, workspace-dev.ts have strict errors but are fenced.
     // Excluding all of src/cli prevents dynamic imports from re-pulling them in.
-    "src/cli/**"
+    "src/cli/**",
+    // testing.ts re-exports src/cli/** symbols (design-connect, plan-local) for
+    // the "./testing" export subpath; it compiles via tsconfig.cli.json instead
+    // so those fenced strict errors don't leak back into the main build.
+    "src/testing.ts"
   ]
 }

package/corpus/templates/analytics/.agents/skills/bigquery/SKILL.md

@@ -20,7 +20,7 @@ description: >-
 
 **Before writing any SQL, verify the metric definition and exact table/column names.**
 
-1. Check the injected `<data-dictionary>` block and call `list-data-dictionary` first.
+1. Call `list-data-dictionary` with a focused search first; dictionary definitions are loaded on demand rather than injected into every chat request.
 2. Use `search-bigquery-schema` to confirm exact dataset, table, and column names.
 3. Only write SQL after you know the correct table and columns. Do not guess.
 
@@ -33,7 +33,7 @@ writing the query is always faster than debugging a wrong result.
 
 Before writing SQL, use the highest-confidence source available:
 
-1. The injected `<data-dictionary>` block and `list-data-dictionary`.
+1. `list-data-dictionary` with a focused search or department filter.
 2. Existing dashboard SQL or saved analyses that already answer the same metric.
 3. `search-bigquery-schema` metadata for exact datasets, tables, and columns.
 4. A concise user clarification when the business meaning cannot be inferred.

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

@@ -48,7 +48,7 @@ Default to Apple/Linear-level restraint: make the primary workflow obvious, then
 
 - **Typography**: Use the product's existing type system first. For net-new public pages, choose characterful but readable type and keep sizing appropriate to the surface.
 - **Color and theme**: Use semantic tokens and CSS variables. Avoid one-note palettes and default purple/blue gradients unless the brand demands them.
-- **Motion**: Prefer purposeful transitions and small state changes. Use CSS transitions/keyframes unless the app already uses a motion library.
+- **Motion**: Prefer purposeful transitions and small state changes. Use CSS transitions/keyframes unless the app already uses a motion library. Never `transition-all` — list the properties that actually change (e.g. `transition-[opacity,transform]`). Use the shared easing tokens defined in `packages/core/src/styles/agent-native.css` instead of hand-typing curves: `var(--ease-drawer)` (260ms, drawers/app chrome), `var(--ease-collapse)` (200ms, expand/collapse), `var(--ease-out-strong)` (snappy entrances) — in Tailwind, `ease-[var(--ease-collapse)]`. Enter/exit with ease-out, never `ease-in`. Overlays that zoom in must set the Radix origin var (e.g. `origin-[--radix-popover-content-transform-origin]`). Animate `transform`/`opacity`, not width/height/padding/box-shadow. Gate looping or large-movement animations with `motion-reduce:`. Command palettes and keyboard-triggered actions get no animation.
 - **Composition**: Match the workflow. Operational apps should be dense and scannable; marketing or portfolio pages can be more immersive.
 - **Visual assets**: Websites, games, and object-focused pages need real or generated media when images help users understand the subject.
 - **Responsive fit**: Text must not overflow buttons, cards, tabs, sidebars, or fixed-format tools. Use stable dimensions for boards, grids, toolbars, and counters.

package/corpus/templates/analytics/AGENTS.md

@@ -17,9 +17,9 @@ details live in `.agents/skills/`.
 - Data integrity comes first. Do not invent numbers, dimensions, filters, or
   source semantics. State uncertainty and inspect the source when needed.
 - Catalog-first: before querying, consult known data sources (data-source
-  status) and the injected `<data-dictionary>` to learn what exists and which
-  table/columns/join paths to use. Don't fan out blind queries when the catalog
-  already answers where a fact lives.
+  status) and call `list-data-dictionary` with a focused search to learn what
+  exists and which table/columns/join paths to use. Don't fan out blind queries
+  when the catalog already answers where a fact lives.
 - Simple time-bounded metric fast path: when the data dictionary or a known
   canonical source already identifies the metric, run one bounded aggregate.
   Once that query returns a valid result, answer immediately with the source,
@@ -83,6 +83,9 @@ details live in `.agents/skills/`.
 - For shipped dashboard templates, call `list-dashboard-templates` first, then
   `install-dashboard-template` with the selected `templateId`. Do not recreate a
   catalog template by hand unless the user asks for a custom variant.
+- Agent Native observability is the exception: its panels belong in the
+  canonical Agent Native dashboard (`agent-native-templates-first-party`). Do
+  not create, publish, or install a separate observability dashboard template.
 - Agent LLM observability is collected through the same first-party tracking
   API as product analytics. Core emits PostHog-compatible `$ai_generation`
   events when emitting apps are configured with `AGENT_NATIVE_ANALYTICS_PUBLIC_KEY`
@@ -295,9 +298,19 @@ details live in `.agents/skills/`.
 - `install-dashboard-template` installs a catalog template into normal
   SQL-backed dashboards. Required: `templateId`. Optional: `dashboardId`,
   `name`, `overwrite`, `forceNew`, and `mergePanels`.
-- The LLM observability dashboard template is `agent-observability-llm`. Install
-  it when the user wants model cost, token volume, latency, error rate, or top
-  expensive agent-run visibility from first-party `$ai_generation` events.
+- Keep model cost, token volume, latency, error rate, explicit thumbs feedback,
+  optional inferred message sentiment, sentiment by main model, and expensive
+  agent-run panels in the canonical Agent Native dashboard
+  (`agent-native-templates-first-party`). Generation metrics use first-party
+  `$ai_generation` events; feedback panels use content-free `$ai_feedback`
+  events with `sentiment` (`positive` or `negative`) and model in `$ai_model` or
+  `model`. Treat these as explicit user ratings, never as inferred message
+  sentiment. Inferred panels separately use `$ai_sentiment` events with
+  `method = 'llm'`, `sentiment` (`positive`, `neutral`, or `negative`), the
+  attributed main model in `$ai_model` or `model`, and the classifier in
+  `classifier_model`. Never group the by-main-model panel on
+  `classifier_model`, and never split these panels into a separately installable
+  observability template.
 - To add a template's panels to an existing dashboard, call
   `install-dashboard-template` with `mergePanels: true` and the existing
   `dashboardId`. It appends only the template panels whose id is not already

package/corpus/templates/analytics/actions/compose-dashboard.ts

@@ -11,7 +11,11 @@ import {
 } from "@agent-native/core/server";
 import { z } from "zod";
 
-import { getDashboard, upsertDashboard } from "../server/lib/dashboards-store";
+import {
+  getDashboard,
+  upsertDashboard,
+  upsertDashboardWithRetry,
+} from "../server/lib/dashboards-store";
 import { validateFirstPartyAnalyticsSql } from "../server/lib/first-party-analytics.js";
 import {
   buildFirstPartyDashboardFilters,
@@ -235,61 +239,85 @@ export default defineAction({
         ? (existing.config.name as string)
         : args.dashboardId);
 
+    function withFilters(
+      config: Record<string, unknown>,
+    ): Record<string, unknown> {
+      return composedPanels.some((panel) =>
+        usesFirstPartyDashboardFilters(panel.sql),
+      )
+        ? withFirstPartyDashboardFilters(config)
+        : config;
+    }
+
     let finalConfig: Record<string, unknown>;
     let appendedCount = composedPanels.length;
     let skippedExistingIds: string[] = [];
 
     if (existing && !args.overwrite) {
       // Append: preserve existing panels + order, add only new panel ids.
-      const existingConfig = existing.config as Record<string, unknown>;
-      const existingPanels = Array.isArray(existingConfig.panels)
-        ? (existingConfig.panels as Array<Record<string, unknown>>)
-        : [];
-      const existingIds = new Set(
-        existingPanels
-          .map((p) => (typeof p?.id === "string" ? p.id : null))
-          .filter((id): id is string => !!id),
+      // Recomputed on every retry attempt from the freshest existing config —
+      // via upsertDashboardWithRetry — so a panel a concurrent writer just
+      // added is never silently dropped by this merge.
+      const saved = await upsertDashboardWithRetry(
+        args.dashboardId,
+        ctx,
+        (freshExisting) => {
+          const existingConfig = freshExisting.config as Record<
+            string,
+            unknown
+          >;
+          const existingPanels = Array.isArray(existingConfig.panels)
+            ? (existingConfig.panels as Array<Record<string, unknown>>)
+            : [];
+          const existingIds = new Set(
+            existingPanels
+              .map((p) => (typeof p?.id === "string" ? p.id : null))
+              .filter((id): id is string => !!id),
+          );
+          const toAppend: ComposedPanel[] = [];
+          const skipped: string[] = [];
+          for (const panel of composedPanels) {
+            if (existingIds.has(panel.id)) {
+              skipped.push(panel.id);
+              continue;
+            }
+            toAppend.push(panel);
+            existingIds.add(panel.id);
+          }
+          appendedCount = toAppend.length;
+          skippedExistingIds = skipped;
+          const merged = withFilters({
+            ...existingConfig,
+            name:
+              typeof existingConfig.name === "string" &&
+              existingConfig.name.trim()
+                ? existingConfig.name
+                : dashboardName,
+            panels: [...existingPanels, ...toAppend],
+          });
+          return { kind: "sql" as const, body: merged };
+        },
       );
-      const toAppend: ComposedPanel[] = [];
-      for (const panel of composedPanels) {
-        if (existingIds.has(panel.id)) {
-          skippedExistingIds.push(panel.id);
-          continue;
-        }
-        toAppend.push(panel);
-        existingIds.add(panel.id);
-      }
-      appendedCount = toAppend.length;
-      finalConfig = {
-        ...existingConfig,
-        name:
-          typeof existingConfig.name === "string" && existingConfig.name.trim()
-            ? existingConfig.name
-            : dashboardName,
-        panels: [...existingPanels, ...toAppend],
-      };
+      finalConfig = saved.config as Record<string, unknown>;
     } else {
       // Create or overwrite: a fresh config with exactly the composed panels.
-      finalConfig = {
+      // No prior state can be lost here — create has none, and
+      // `overwrite: true` is an explicit full-replace request rather than a
+      // read-modify-write, so it saves unconditionally like update-dashboard's
+      // full-config replace mode.
+      finalConfig = withFilters({
         name: dashboardName,
         description:
           "First-party analytics dashboard composed from the metric catalog.",
         panels: composedPanels,
-      };
-    }
-
-    if (
-      composedPanels.some((panel) => usesFirstPartyDashboardFilters(panel.sql))
-    ) {
-      finalConfig = withFirstPartyDashboardFilters(finalConfig);
+      });
+      await upsertDashboard(args.dashboardId, "sql", finalConfig, ctx);
     }
 
     const panelCount = Array.isArray(finalConfig.panels)
       ? (finalConfig.panels as unknown[]).length
       : 0;
 
-    // Single atomic save through the same store path update-dashboard uses.
-    await upsertDashboard(args.dashboardId, "sql", finalConfig, ctx);
     await syncToCollab(args.dashboardId, finalConfig);
 
     const parts: string[] = [];

package/corpus/templates/analytics/actions/install-dashboard-template.ts

@@ -18,7 +18,12 @@ import {
   getDashboardCatalogEntry,
   listDashboardCatalog,
 } from "../server/lib/dashboard-catalog";
-import { getDashboard, upsertDashboard } from "../server/lib/dashboards-store";
+import {
+  getDashboard,
+  upsertDashboard,
+  upsertDashboardWithRetry,
+  type DashboardRecord,
+} from "../server/lib/dashboards-store";
 
 async function syncToCollab(
   dashboardId: string,
@@ -145,6 +150,17 @@ export default defineAction({
     // in ONE atomic save instead of looping update-dashboard (which times out
     // on the ~40s hosted run budget). Non-destructive: existing panels and
     // their order are preserved; only template panels with a new id are added.
+    //
+    // This is a genuine read-modify-write of an EXISTING dashboard (an agent
+    // merging a template while a human drags a panel, or two merge calls
+    // racing), so the save is fenced through `upsertDashboardWithRetry`.
+    // `computeMerge` is invoked with the freshest `DashboardRecord` on every
+    // attempt and recomputes `existingIds`/`appended`/`mergedConfig` from
+    // THAT record's config — never from a closure over the earlier `target`
+    // read — so a lost race re-merges against whatever the concurrent writer
+    // actually saved instead of clobbering it. `seedConfig`/`seedPanels` are
+    // the template's own panels and don't depend on dashboard state, so they
+    // are computed once outside the retry loop.
     if (args.mergePanels) {
       const targetId = args.dashboardId?.trim();
       if (!targetId) {
@@ -152,6 +168,7 @@ export default defineAction({
           "mergePanels=true requires dashboardId (the existing dashboard to append the template's panels to).",
         );
       }
+
       const target = await getDashboard(targetId, ctx);
       if (!target) {
         throw new Error(
@@ -159,16 +176,6 @@ export default defineAction({
         );
       }
 
-      const targetConfig = target.config as Record<string, unknown>;
-      const existingPanels = Array.isArray(targetConfig.panels)
-        ? (targetConfig.panels as Array<Record<string, unknown>>)
-        : [];
-      const existingIds = new Set(
-        existingPanels
-          .map((panel) => (typeof panel?.id === "string" ? panel.id : null))
-          .filter((id): id is string => !!id),
-      );
-
       const seedConfig = cloneDashboardConfig(entry) as unknown as Record<
         string,
         unknown
@@ -177,49 +184,78 @@ export default defineAction({
         ? (seedConfig.panels as unknown as Array<Record<string, unknown>>)
         : [];
 
-      const addedPanelIds: string[] = [];
-      const skippedExistingIds: string[] = [];
-      const appended: Array<Record<string, unknown>> = [];
-      for (const panel of seedPanels) {
-        const id = typeof panel?.id === "string" ? panel.id : null;
-        if (id && existingIds.has(id)) {
-          skippedExistingIds.push(id);
-          continue;
-        }
-        appended.push(panel);
-        if (id) {
-          addedPanelIds.push(id);
-          existingIds.add(id);
+      function computeMerge(existing: Pick<DashboardRecord, "config">) {
+        const targetConfig = existing.config as Record<string, unknown>;
+        const existingPanels = Array.isArray(targetConfig.panels)
+          ? (targetConfig.panels as Array<Record<string, unknown>>)
+          : [];
+        const existingIds = new Set(
+          existingPanels
+            .map((panel) => (typeof panel?.id === "string" ? panel.id : null))
+            .filter((id): id is string => !!id),
+        );
+
+        const addedPanelIds: string[] = [];
+        const skippedExistingIds: string[] = [];
+        const appended: Array<Record<string, unknown>> = [];
+        for (const panel of seedPanels) {
+          const id = typeof panel?.id === "string" ? panel.id : null;
+          if (id && existingIds.has(id)) {
+            skippedExistingIds.push(id);
+            continue;
+          }
+          appended.push(panel);
+          if (id) {
+            addedPanelIds.push(id);
+            existingIds.add(id);
+          }
         }
+
+        let mergedConfig: Record<string, unknown> = {
+          ...targetConfig,
+          panels: [...existingPanels, ...appended],
+        };
+        const filterMerge = mergeMissingFilters(mergedConfig, seedConfig);
+        mergedConfig = filterMerge.config;
+
+        return {
+          mergedConfig,
+          addedPanelIds,
+          skippedExistingIds,
+          appended,
+          filterMerge,
+        };
       }
 
-      let mergedConfig: Record<string, unknown> = {
-        ...targetConfig,
-        panels: [...existingPanels, ...appended],
-      };
-      const filterMerge = mergeMissingFilters(mergedConfig, seedConfig);
-      mergedConfig = filterMerge.config;
-      const panelCount = (mergedConfig.panels as unknown[]).length;
+      let computed = computeMerge(target);
+      let savedTitle = target.title;
 
-      if (appended.length > 0 || filterMerge.addedFilterIds.length > 0) {
-        const saved = await upsertDashboard(
+      if (
+        computed.appended.length > 0 ||
+        computed.filterMerge.addedFilterIds.length > 0
+      ) {
+        const saved = await upsertDashboardWithRetry(
           targetId,
-          target.kind,
-          mergedConfig,
           ctx,
+          (existing) => {
+            computed = computeMerge(existing);
+            return { kind: existing.kind, body: computed.mergedConfig };
+          },
         );
-        await syncToCollab(targetId, mergedConfig);
-        targetConfig.name = saved.title;
+        await syncToCollab(targetId, saved.config as Record<string, unknown>);
+        savedTitle = saved.title;
       }
 
+      const panelCount = (computed.mergedConfig.panels as unknown[]).length;
+
       return {
         templateId: entry.id,
         templateName: entry.name,
         dashboardId: targetId,
-        name: target.title,
+        name: savedTitle,
         merged: true,
-        addedPanelIds,
-        skippedExistingIds,
+        addedPanelIds: computed.addedPanelIds,
+        skippedExistingIds: computed.skippedExistingIds,
         panelCount,
         urlPath: `/dashboards/${targetId}`,
         deepLink: buildDeepLink({
@@ -228,9 +264,9 @@ export default defineAction({
           params: { dashboardId: targetId },
         }),
         message:
-          appended.length > 0
-            ? `Added ${addedPanelIds.length} panel(s) from "${entry.name}" to "${target.title}"; ${skippedExistingIds.length} already present. Dashboard now has ${panelCount} panel(s).`
-            : `No new panels to add from "${entry.name}" — all ${skippedExistingIds.length} template panel id(s) already present. Dashboard has ${panelCount} panel(s).`,
+          computed.appended.length > 0
+            ? `Added ${computed.addedPanelIds.length} panel(s) from "${entry.name}" to "${savedTitle}"; ${computed.skippedExistingIds.length} already present. Dashboard now has ${panelCount} panel(s).`
+            : `No new panels to add from "${entry.name}" — all ${computed.skippedExistingIds.length} template panel id(s) already present. Dashboard has ${panelCount} panel(s).`,
       };
     }
 

package/corpus/templates/analytics/actions/list-explorer-dashboards.ts

@@ -6,7 +6,7 @@ import {
 import { z } from "zod";
 
 import {
-  listDashboards,
+  listDashboardSummaries,
   type DashboardArchiveFilter,
   type DashboardHiddenFilter,
 } from "../server/lib/dashboards-store";
@@ -48,7 +48,7 @@ export default defineAction({
     const ctx = { email, orgId };
     const archived = parseArchivedFilter(args.archived);
     const hidden = parseHiddenFilter(args.hidden);
-    const rows = await listDashboards(ctx, {
+    const rows = await listDashboardSummaries(ctx, {
       kind: "explorer",
       archived,
       hidden,
@@ -56,7 +56,7 @@ export default defineAction({
     return {
       dashboards: rows.map((d) => ({
         id: d.id,
-        ...(d.config as Record<string, unknown>),
+        name: d.name,
         ownerEmail: d.ownerEmail,
         orgId: d.orgId,
         visibility: d.visibility,