@agent-native/core 0.97.0 → 0.98.0

package/corpus/core/src/templates/workspace-core/.agents/skills/observability/SKILL.md

@@ -34,9 +34,41 @@ await putSetting("observability-config", {
   captureToolArgs: true,    // capture action input args
   captureToolResults: false,
   evalSampleRate: 0.05,     // 5% of runs get LLM-as-judge eval
+  inferredSentimentEnabled: false,
+  inferredSentimentSampleRate: 0,
+  inferredSentimentModel: "gpt-5-6-luna",
 });
 ```
 
+#### Optional inferred sentiment
+
+Self-hosted apps default to no inferred sentiment. First-party apps hosted on
+`agent-native.com` automatically classify 100% of eligible user replies with
+`gpt-5-6-luna`; an explicit stored `inferredSentimentEnabled: false` remains an
+opt-out. Deployment overrides are `AGENT_NATIVE_INFERRED_SENTIMENT=on|off`,
+`AGENT_NATIVE_INFERRED_SENTIMENT_SAMPLE_RATE=0..1`, and
+`AGENT_NATIVE_INFERRED_SENTIMENT_MODEL=<model>`; `off` is always the emergency
+kill switch.
+
+Classification uses only the original visible user text, capped at 2,000
+characters, with no tools, temperature 0, an eight-token output, and a five
+second timeout. It skips attachment-only turns, internal continuations, chained
+background chunks, and first turns that have no preceding response to
+attribute. The managed Builder engine runs the classifier after the main
+response has streamed, so it does not contend with the user's response.
+
+Successful classifications emit a content-free `$ai_sentiment` tracking event:
+
+- `sentiment`: `positive`, `negative`, or `neutral`
+- `method`: `llm`
+- `model` / `$ai_model`: model that generated the preceding assistant response
+- `run_id` / `$ai_trace_id`: preceding response run
+- `thread_id` / `$ai_session_id`: conversation
+- `classification_trigger_run_id`: run started by the classified user reply
+- `classifier_model` and `classifier_engine`: classifier attribution
+
+No raw message, prompt, or response text is persisted or tracked.
+
 ### 2. Feedback
 
 **Explicit** — `ThumbsFeedback` component renders inline thumbs up/down on every agent message in the chat UI. Thumbs down opens a category popover (Inaccurate, Not helpful, Wrong tool, Too slow). Already wired into `AssistantChat.tsx` via `React.lazy`.

package/corpus/core/src/templates/workspace-core/.agents/skills/writing-agent-instructions/SKILL.md

@@ -96,6 +96,31 @@ contract:
 - Do not create pass-through routes whose main job is to call, repackage, or
   re-export an action.
 
+## Budget the first model request
+
+Treat the initial prompt and tool catalog as a latency budget. The agent should
+start with a compact map of the app, then retrieve depth only when the task
+needs it.
+
+- Set `initialToolNames` to the small set of actions used in the app's primary
+  workflows. Keep `tool-search` available so every other registered action and
+  connected MCP tool remains discoverable on demand.
+- Keep essential, always-applicable rules in `AGENTS.md`. Put workflow detail
+  in skills and long reference material in `references/` or workspace
+  resources that the agent can read when relevant.
+- Do not inject full documents, transcripts, data dictionaries, source trees,
+  or provider catalogs through `systemPrompt` or `extraContext`. Inject a
+  bounded summary, stable ids/paths, and the exact action or resource lookup
+  that retrieves the full content.
+- Avoid duplicating action descriptions in prose. The starter tools already
+  carry schemas; uncommon actions are available through `tool-search`.
+- Keep `view-screen` concise. Return navigation, selection, visible summary,
+  and ids needed for a follow-up read rather than full record bodies.
+
+The goal is progressive disclosure, not reduced capability: a compact first
+request, precise discovery, and full fidelity once the agent knows which depth
+is relevant.
+
 When documenting version history, restore, or audit trails, use actions for
 full restorable snapshots (`list-<resource>-versions`,
 `get-<resource>-version`, `restore-<resource>-version`). Do not copy legacy

package/corpus/core/src/templates/workspace-core/src/server/index.ts

@@ -5,13 +5,15 @@ import {
   createAgentChatPlugin,
   defaultAuthPlugin,
   type AgentChatPluginOptions,
+  type NitroPluginDef,
 } from "@agent-native/core/server";
 
 export function createWorkspaceAgentChatPlugin(
   options?: AgentChatPluginOptions,
-) {
+): NitroPluginDef {
   return createAgentChatPlugin(options);
 }
 
-export const defaultAgentChatPlugin = createWorkspaceAgentChatPlugin();
+export const defaultAgentChatPlugin: NitroPluginDef =
+  createWorkspaceAgentChatPlugin();
 export { defaultAuthPlugin };

package/corpus/core/src/testing.ts

@@ -0,0 +1,26 @@
+/**
+ * `@agent-native/core/testing` — a small barrel of internal symbols that
+ * template test suites need direct access to (an in-memory db factory, the
+ * local Design/Plan dev bridges, and the shared rich-markdown-editor drag
+ * handle). Published so template specs can import these through the package
+ * boundary instead of reaching into `packages/core/src/**` with deep
+ * relative paths.
+ *
+ * Keep this list minimal — only add a re-export when a template spec
+ * actually needs it.
+ */
+
+export {
+  createGetDb,
+  patchBetterSqliteTransactions,
+} from "./db/create-get-db.js";
+
+export { startLocalPlanBridge } from "./cli/plan-local.js";
+
+export {
+  prepareDesignConnectManifest,
+  startDesignConnectBridge,
+  type DesignConnectBridge,
+} from "./cli/design-connect.js";
+
+export { DragHandle } from "./client/rich-markdown-editor/DragHandle.js";

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/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/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,

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

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