@agent-native/core 0.96.0 → 0.97.0

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/mutate-dashboard.ts

@@ -11,13 +11,18 @@ import {
 } from "@agent-native/core/server";
 import { z } from "zod";
 
-import { getDashboard, upsertDashboard } from "../server/lib/dashboards-store";
+import {
+  getDashboard,
+  upsertDashboardWithRetry,
+  type DashboardRecord,
+} from "../server/lib/dashboards-store";
 import {
   applyDashboardMutationOperations,
   DASHBOARD_MUTATION_API_TYPES,
   DASHBOARD_MUTATION_EXAMPLES,
   parseDashboardMutationScript,
   type DashboardMutationOperation,
+  type DashboardMutationResult,
 } from "./dashboard-mutation-api";
 import { compactDashboardResult } from "./dashboard-panel-order";
 import { validateDashboardConfig, validatePanelSql } from "./update-dashboard";
@@ -260,33 +265,77 @@ export default defineAction({
 
     const scope = resolveScope();
     const ctx = { email: scope.email, orgId: scope.orgId };
-    const existing = await getDashboard(dashboardId, ctx);
-    if (!existing) {
-      throw new Error(
-        `dashboard "${dashboardId}" not found (or you don't have access).`,
-      );
-    }
-    if (existing.kind !== "sql") {
-      throw new Error(
-        `mutate-dashboard only supports SQL dashboards; "${dashboardId}" is ${existing.kind}.`,
+
+    // Recomputes the mutation from whatever dashboard state is passed in.
+    // `operations` sourced from `args.operations` are already concrete panel
+    // ids, safe to replay verbatim; `args.code` is re-parsed against `existing`
+    // every time because selectors like `panelsMatching(...)` resolve against
+    // the config at parse time, so a retry must re-resolve them against the
+    // fresh state, not reuse ids resolved from a now-stale config.
+    function computeMutation(
+      existing: Pick<DashboardRecord, "kind" | "config">,
+    ) {
+      if (existing.kind !== "sql") {
+        throw new Error(
+          `mutate-dashboard only supports SQL dashboards; "${dashboardId}" is ${existing.kind}.`,
+        );
+      }
+      const nextRoot = cloneConfig(existing.config as Record<string, unknown>);
+      const nextOperations = args.operations
+        ? (args.operations as DashboardMutationOperation[])
+        : parseDashboardMutationScript(nextRoot, args.code!);
+      const nextMutation = applyDashboardMutationOperations(
+        nextRoot,
+        nextOperations,
       );
+      const validation = validateDashboardConfig(nextRoot);
+      if (validation) throw new Error(validation);
+      return { nextRoot, nextOperations, nextMutation };
     }
 
-    const root = cloneConfig(existing.config as Record<string, unknown>);
-    const operations = args.operations
-      ? (args.operations as DashboardMutationOperation[])
-      : parseDashboardMutationScript(root, args.code!);
-    const mutation = applyDashboardMutationOperations(root, operations);
+    // Assigned inside `computeMutation`'s caller (directly for dry-run, inside
+    // the retry callback for a real save); always assigned at least once
+    // before use below, since `upsertDashboardWithRetry` only resolves after
+    // its callback has run.
+    let root: Record<string, unknown>;
+    let operations!: DashboardMutationOperation[];
+    let mutation!: DashboardMutationResult;
 
-    const validation = validateDashboardConfig(root);
-    if (validation) throw new Error(validation);
-    if (operations.some(mutationCanChangePanelSql)) {
-      const sqlError = await validatePanelSql(root);
-      if (sqlError) throw new Error(sqlError);
-    }
-
-    if (args.dryRun !== true) {
-      await upsertDashboard(dashboardId, existing.kind, root, ctx);
+    if (args.dryRun === true) {
+      const existing = await getDashboard(dashboardId, ctx);
+      if (!existing) {
+        throw new Error(
+          `dashboard "${dashboardId}" not found (or you don't have access).`,
+        );
+      }
+      const computed = computeMutation(existing);
+      root = computed.nextRoot;
+      operations = computed.nextOperations;
+      mutation = computed.nextMutation;
+      if (operations.some(mutationCanChangePanelSql)) {
+        const sqlError = await validatePanelSql(root);
+        if (sqlError) throw new Error(sqlError);
+      }
+    } else {
+      const saved = await upsertDashboardWithRetry(
+        dashboardId,
+        ctx,
+        async (existing) => {
+          const computed = computeMutation(existing);
+          if (computed.nextOperations.some(mutationCanChangePanelSql)) {
+            const sqlError = await validatePanelSql(computed.nextRoot);
+            if (sqlError) throw new Error(sqlError);
+          }
+          root = computed.nextRoot;
+          operations = computed.nextOperations;
+          mutation = computed.nextMutation;
+          return { kind: "sql" as const, body: computed.nextRoot };
+        },
+      );
+      // Use the persisted config as the source of truth for the response —
+      // structurally identical to the winning attempt's `root`, but reflects
+      // exactly what was saved.
+      root = saved.config as Record<string, unknown>;
       await syncToCollab(dashboardId, root);
     }
 

package/corpus/templates/analytics/actions/reorder-dashboard-panels.ts

@@ -11,10 +11,11 @@ import {
 } from "@agent-native/core/server";
 import { z } from "zod";
 
-import { getDashboard, upsertDashboard } from "../server/lib/dashboards-store";
+import { upsertDashboardWithRetry } from "../server/lib/dashboards-store";
 import {
   compactDashboardResult,
   movePanelsById,
+  type PanelOrderResult,
   type PanelOrderTarget,
 } from "./dashboard-panel-order";
 
@@ -155,20 +156,22 @@ export default defineAction({
     const dashboardId = resolveDashboardId(args);
     const scope = resolveScope();
     const ctx = { email: scope.email, orgId: scope.orgId };
-    const existing = await getDashboard(dashboardId, ctx);
-    if (!existing) {
-      throw new Error(
-        `dashboard "${dashboardId}" not found (or you don't have access).`,
-      );
-    }
 
-    const root = existing.config as Record<string, unknown>;
-    const orderResult = movePanelsById(
-      root,
-      args.panelIds,
-      resolveTarget(args),
+    // Recomputed on every attempt from whichever dashboard state
+    // `upsertDashboardWithRetry` hands us, so a retry after a concurrent
+    // writer's save re-applies this move against their fresh panel order
+    // instead of silently discarding it.
+    let orderResult!: PanelOrderResult;
+    const saved = await upsertDashboardWithRetry(
+      dashboardId,
+      ctx,
+      (existing) => {
+        const root = existing.config as Record<string, unknown>;
+        orderResult = movePanelsById(root, args.panelIds, resolveTarget(args));
+        return { kind: existing.kind, body: root };
+      },
     );
-    await upsertDashboard(dashboardId, existing.kind, root, ctx);
+    const root = saved.config as Record<string, unknown>;
     await syncToCollab(dashboardId, root);
 
     const compact = compactDashboardResult(root, orderResult.movedPanelIds);

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

@@ -13,12 +13,16 @@ import { z } from "zod";
 
 import { interpolate } from "../app/pages/adhoc/sql-dashboard/interpolate";
 import { dryRunQuery } from "../server/lib/bigquery";
-import { getDashboard, upsertDashboard } from "../server/lib/dashboards-store";
+import {
+  upsertDashboard,
+  upsertDashboardWithRetry,
+} from "../server/lib/dashboards-store";
 import { parseDemoDescriptor } from "../server/lib/demo-source";
 import { validateFirstPartyAnalyticsSql } from "../server/lib/first-party-analytics.js";
 import {
   applyPanelOrder,
   compactDashboardResult,
+  type PanelOrderResult,
 } from "./dashboard-panel-order";
 
 /**
@@ -627,29 +631,27 @@ export default defineAction({
       );
     }
 
-    const existing = await getDashboard(dashboardId, ctx);
-    if (!existing) {
-      throw new Error(
-        `dashboard "${dashboardId}" not found (or you don't have access).`,
-      );
-    }
-
-    const root = existing.config as any;
-
     if (args.panelOrder) {
-      const orderDetails = applyPanelOrder(root, args.panelOrder);
-      const validation = validateDashboardConfig(root);
-      if (validation) throw new Error(validation);
-      await upsertDashboard(
+      // Recomputed on every retry attempt from the freshest dashboard config,
+      // so a concurrent writer's edit is never silently overwritten by this
+      // move.
+      let orderDetails!: PanelOrderResult;
+      const saved = await upsertDashboardWithRetry(
         dashboardId,
-        existing.kind,
-        root as Record<string, unknown>,
         ctx,
+        (existing) => {
+          const root = existing.config as Record<string, unknown>;
+          orderDetails = applyPanelOrder(root, args.panelOrder!);
+          const validation = validateDashboardConfig(root);
+          if (validation) throw new Error(validation);
+          return { kind: existing.kind, body: root };
+        },
       );
-      await syncToCollab(dashboardId, root as Record<string, unknown>);
+      const root = saved.config as Record<string, unknown>;
+      await syncToCollab(dashboardId, root);
       return dashboardResult(
         dashboardId,
-        root as Record<string, unknown>,
+        root,
         1,
         `Moved ${orderDetails.movedPanelIds.length} panel id(s) to the front of dashboard "${dashboardId}"; it now has ${orderDetails.panelCount} panel(s).`,
         orderDetails.movedPanelIds,
@@ -657,36 +659,45 @@ export default defineAction({
       );
     }
 
-    const details: string[] = [];
-    for (const op of args.ops!) {
-      try {
-        details.push(applyJsonOp(root, op as JsonOp));
-      } catch (err: any) {
-        throw new Error(`applying op ${JSON.stringify(op)}: ${err.message}`);
-      }
-    }
-
-    const validation = validateDashboardConfig(root);
-    if (validation) throw new Error(validation);
-    if (args.ops!.some((op) => opCanChangePanelSql(op as JsonOp))) {
-      const sqlError = await validatePanelSql(root);
-      if (sqlError) throw new Error(sqlError);
-    }
-
-    await upsertDashboard(
+    // Recomputed on every retry attempt from the freshest dashboard config —
+    // JSON-pointer ops are replayed against fresh state, not the stale config
+    // that produced the first (lost) attempt.
+    let appliedDetails: string[] = [];
+    const saved = await upsertDashboardWithRetry(
       dashboardId,
-      existing.kind,
-      root as Record<string, unknown>,
       ctx,
+      async (existing) => {
+        const root = existing.config as Record<string, unknown>;
+        const details: string[] = [];
+        for (const op of args.ops!) {
+          try {
+            details.push(applyJsonOp(root, op as JsonOp));
+          } catch (err: any) {
+            throw new Error(
+              `applying op ${JSON.stringify(op)}: ${err.message}`,
+            );
+          }
+        }
+
+        const validation = validateDashboardConfig(root);
+        if (validation) throw new Error(validation);
+        if (args.ops!.some((op) => opCanChangePanelSql(op as JsonOp))) {
+          const sqlError = await validatePanelSql(root);
+          if (sqlError) throw new Error(sqlError);
+        }
+        appliedDetails = details;
+        return { kind: existing.kind, body: root };
+      },
     );
-    await syncToCollab(dashboardId, root as Record<string, unknown>);
+    const root = saved.config as Record<string, unknown>;
+    await syncToCollab(dashboardId, root);
 
-    const panelCount = countPanels(root as Record<string, unknown>);
+    const panelCount = countPanels(root);
     return dashboardResult(
       dashboardId,
-      root as Record<string, unknown>,
-      details.length,
-      `Applied ${details.length} op(s); dashboard "${dashboardId}" now has ${panelCount} panel(s).`,
+      root,
+      appliedDetails.length,
+      `Applied ${appliedDetails.length} op(s); dashboard "${dashboardId}" now has ${panelCount} panel(s).`,
       [],
       args.returnConfig === true,
     );

package/corpus/templates/analytics/changelog/2026-07-10-dashboard-edits-from-the-agent-and-the-ui-at-the-same-time-n.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Dashboard edits from the agent and the UI at the same time no longer overwrite each other

package/corpus/templates/analytics/changelog/2026-07-10-timed-out-bigquery-jobs-are-now-cancelled-so-they-stop-consu.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-10
+---
+
+Timed-out BigQuery jobs are now cancelled so they stop consuming warehouse quota.

package/corpus/templates/analytics/package.json

@@ -25,7 +25,7 @@
     "@sparticuz/chromium-min": "^149.0.0",
     "@tabler/icons-react": "catalog:",
     "drizzle-orm": "^0.45.2",
-    "h3": "^2.0.1-rc.20",
+    "h3": "catalog:",
     "isbot": "^5",
     "playwright-core": "^1.61.1",
     "postgres": "^3.4.9",
@@ -100,7 +100,6 @@
     "tailwindcss": "catalog:",
     "three": "^0.176.0",
     "tsx": "^4.20.3",
-    "typescript": "catalog:",
     "typescript-7": "catalog:",
     "vaul": "^1.1.2",
     "vite": "catalog:",

package/corpus/templates/analytics/server/lib/bigquery.ts

@@ -320,8 +320,8 @@ async function cancelQueryJob(
       },
     );
   } catch {
-    // The caller is already aborting. Cancellation is best-effort and must not
-    // hide the original abort reason if BigQuery or the network is unavailable.
+    // Cancellation is best-effort and must not hide the original abort or
+    // timeout reason if BigQuery or the network is unavailable.
   }
 }
 
@@ -502,6 +502,7 @@ export async function runQuery(
     }
 
     if (!data.jobComplete) {
+      await cancelQueryJob(projectId, jobId, token);
       throw new Error("BigQuery query timed out after 60 seconds");
     }
   }