@agent-native/core 0.97.0 → 0.98.0

package/corpus/templates/analytics/server/lib/dashboards-store.ts

@@ -1,3 +1,18 @@
+/**
+ * Dashboards + analyses store — SQL first, legacy settings-KV as
+ * read-only fallback. Writes always go to SQL.
+ *
+ * Lazy migration: when a record is fetched by id and exists only in the
+ * legacy settings store, it is copied into SQL on the fly using the
+ * settings key as the source of truth for `ownerEmail` / `orgId` /
+ * `visibility`, then returned. Subsequent reads hit SQL directly.
+ *
+ * - `u:<email>:dashboard-{id}`     → kind='explorer', owner=email,  visibility='private'
+ * - `u:<email>:sql-dashboard-{id}` → kind='sql',      owner=email,  visibility='private'
+ * - `o:<orgId>:sql-dashboard-{id}` → kind='sql',      owner=caller, visibility='org'
+ * - `adhoc-analysis-{id}`          → owner=caller,   legacy visibility from its source key
+ */
+import { isPostgres } from "@agent-native/core/db";
 import { recordChange } from "@agent-native/core/server";
 import {
   getAllSettings,
@@ -13,21 +28,7 @@ import {
   resolveAccess,
   type ShareRole,
 } from "@agent-native/core/sharing";
-/**
- * Dashboards + analyses store — SQL first, legacy settings-KV as
- * read-only fallback. Writes always go to SQL.
- *
- * Lazy migration: when a record is fetched by id and exists only in the
- * legacy settings store, it is copied into SQL on the fly using the
- * settings key as the source of truth for `ownerEmail` / `orgId` /
- * `visibility`, then returned. Subsequent reads hit SQL directly.
- *
- * - `u:<email>:dashboard-{id}`     → kind='explorer', owner=email,  visibility='private'
- * - `u:<email>:sql-dashboard-{id}` → kind='sql',      owner=email,  visibility='private'
- * - `o:<orgId>:sql-dashboard-{id}` → kind='sql',      owner=caller, visibility='org'
- * - `adhoc-analysis-{id}`          → owner=caller,   legacy visibility from its source key
- */
-import { and, desc, eq, isNotNull, isNull } from "drizzle-orm";
+import { and, desc, eq, isNotNull, isNull, sql } from "drizzle-orm";
 
 import { getDb, schema } from "../db/index.js";
 
@@ -56,6 +57,22 @@ export interface DashboardRecord {
   canManage?: boolean;
 }
 
+/** Metadata-only dashboard row for navigation and picker surfaces. */
+export interface DashboardSummaryRecord {
+  id: string;
+  kind: DashboardKind;
+  name: string;
+  parentId: string | null;
+  ownerEmail: string;
+  orgId: string | null;
+  visibility: "private" | "org" | "public";
+  createdAt: string;
+  updatedAt: string;
+  archivedAt: string | null;
+  hiddenAt: string | null;
+  hiddenBy: string | null;
+}
+
 export interface DashboardRevisionRecord {
   id: string;
   dashboardId: string;
@@ -168,6 +185,19 @@ export class DashboardConflictError extends Error {
   }
 }
 
+/**
+ * Thrown when a fenced `upsertAnalysis` write (an `expectedUpdatedAt` was
+ * supplied) loses its compare-and-swap because another writer changed the
+ * row first. Callers should re-read the analysis and re-apply their mutation
+ * against the fresh record — see `upsertAnalysisWithRetry`.
+ */
+export class AnalysisConflictError extends Error {
+  constructor(id: string) {
+    super(`Analysis "${id}" changed between read and write.`);
+    this.name = "AnalysisConflictError";
+  }
+}
+
 function changeScope(
   ownerEmail: string,
   orgId: string | null,
@@ -465,6 +495,125 @@ export async function listDashboards(
   return out;
 }
 
+/**
+ * List dashboard metadata without transferring or parsing each dashboard's
+ * potentially very large panel config. This is the list-path counterpart to
+ * `getDashboard`, which remains the full-config detail read.
+ *
+ * Legacy settings rows are surfaced directly instead of being migrated during
+ * the read. Opening one by id still performs the existing lazy migration, but
+ * navigation no longer turns an ordinary list into N sequential writes.
+ */
+export async function listDashboardSummaries(
+  ctx: AccessCtx,
+  filter?: {
+    kind?: DashboardKind;
+    archived?: DashboardArchiveFilter;
+    hidden?: DashboardHiddenFilter;
+  },
+): Promise<DashboardSummaryRecord[]> {
+  const db = getDb() as any;
+  const archived = filter?.archived ?? "active";
+  const hidden = filter?.hidden ?? "visible";
+  const conditions: any[] = [
+    accessFilter(schema.dashboards, schema.dashboardShares, {
+      userEmail: ctx.email,
+      orgId: ctx.orgId ?? undefined,
+    }),
+  ];
+  if (filter?.kind) conditions.push(eq(schema.dashboards.kind, filter.kind));
+  if (archived === "active")
+    conditions.push(isNull(schema.dashboards.archivedAt));
+  else if (archived === "archived")
+    conditions.push(isNotNull(schema.dashboards.archivedAt));
+  if (hidden === "visible") conditions.push(isNull(schema.dashboards.hiddenAt));
+  else if (hidden === "hidden")
+    conditions.push(isNotNull(schema.dashboards.hiddenAt));
+  const where = conditions.length === 1 ? conditions[0] : and(...conditions);
+  const parentId = isPostgres()
+    ? sql<string | null>`(${schema.dashboards.config}::jsonb ->> 'parentId')`
+    : sql<
+        string | null
+      >`json_extract(${schema.dashboards.config}, '$.parentId')`;
+  const rows = await db
+    .select({
+      id: schema.dashboards.id,
+      kind: schema.dashboards.kind,
+      name: schema.dashboards.title,
+      parentId,
+      ownerEmail: schema.dashboards.ownerEmail,
+      orgId: schema.dashboards.orgId,
+      visibility: schema.dashboards.visibility,
+      createdAt: schema.dashboards.createdAt,
+      updatedAt: schema.dashboards.updatedAt,
+      archivedAt: schema.dashboards.archivedAt,
+      hiddenAt: schema.dashboards.hiddenAt,
+      hiddenBy: schema.dashboards.hiddenBy,
+    })
+    .from(schema.dashboards)
+    .where(where);
+  const out: DashboardSummaryRecord[] = rows.map((row: any) => ({
+    ...row,
+    parentId: typeof row.parentId === "string" ? row.parentId : null,
+    orgId: row.orgId ?? null,
+    archivedAt: row.archivedAt ?? null,
+    hiddenAt: row.hiddenAt ?? null,
+    hiddenBy: row.hiddenBy ?? null,
+  }));
+  const seen = new Set(out.map((row) => row.id));
+
+  if (archived === "archived" || hidden === "hidden") return out;
+  try {
+    const all = await getAllSettings();
+    for (const [key, value] of Object.entries(all)) {
+      let id: string | null = null;
+      let kind: DashboardKind | null = null;
+      let orgId: string | null = null;
+      let visibility: DashboardSummaryRecord["visibility"] = "private";
+      if (ctx.orgId && key.startsWith(`o:${ctx.orgId}:${SQL_PREFIX}`)) {
+        id = key.slice(`o:${ctx.orgId}:${SQL_PREFIX}`.length);
+        kind = "sql";
+        orgId = ctx.orgId;
+        visibility = "org";
+      } else if (ctx.email && key.startsWith(`u:${ctx.email}:${SQL_PREFIX}`)) {
+        id = key.slice(`u:${ctx.email}:${SQL_PREFIX}`.length);
+        kind = "sql";
+      } else if (
+        ctx.email &&
+        key.startsWith(`u:${ctx.email}:${EXPLORER_PREFIX}`)
+      ) {
+        id = key.slice(`u:${ctx.email}:${EXPLORER_PREFIX}`.length);
+        kind = "explorer";
+      }
+      if (!id || !kind || seen.has(id)) continue;
+      if (filter?.kind && filter.kind !== kind) continue;
+      seen.add(id);
+      const config = value as Record<string, unknown>;
+      const { title } = configFromSettings(config);
+      const createdAt =
+        typeof config.createdAt === "string" ? config.createdAt : nowIso();
+      out.push({
+        id,
+        kind,
+        name: title,
+        parentId: typeof config.parentId === "string" ? config.parentId : null,
+        ownerEmail: ctx.email,
+        orgId,
+        visibility,
+        createdAt,
+        updatedAt:
+          typeof config.updatedAt === "string" ? config.updatedAt : createdAt,
+        archivedAt: null,
+        hiddenAt: null,
+        hiddenBy: null,
+      });
+    }
+  } catch {
+    // Legacy scan is best-effort.
+  }
+  return out;
+}
+
 async function pruneDashboardRevisions(
   db: any,
   dashboardId: string,
@@ -1247,6 +1396,21 @@ async function snapshotAnalysisRevision(
   await pruneAnalysisRevisions(db, analysis.id);
 }
 
+/**
+ * Upsert an analysis. On create, caller becomes owner and visibility defaults
+ * to `private`. On update, `assertAccess` requires `editor`.
+ *
+ * `expectedUpdatedAt` fences the update against concurrent writers: pass the
+ * `updatedAt` observed by an earlier `getAnalysis` call and the UPDATE only
+ * applies `WHERE id = ? AND updated_at = ?`. If another writer already saved
+ * in between, the fenced UPDATE affects zero rows and this throws
+ * `AnalysisConflictError` instead of silently clobbering their write. Omit it
+ * (the default) to keep the prior unconditional last-write-wins behavior,
+ * which existing callers (legacy migration, revision restore, and
+ * `save-analysis`'s create/re-run path) still rely on. See
+ * `upsertAnalysisWithRetry` for the read-modify-write pattern that recomputes
+ * the patch from fresh state on a lost race.
+ */
 export async function upsertAnalysis(
   id: string,
   body: {
@@ -1259,8 +1423,17 @@ export async function upsertAnalysis(
     resultData?: Record<string, unknown> | null;
   },
   ctx: AccessCtx,
+  expectedUpdatedAt?: string,
 ): Promise<AnalysisRecord> {
   const existing = await getAnalysis(id, ctx);
+  if (!existing && expectedUpdatedAt !== undefined) {
+    // A fence was supplied against a specific prior version, but the row is
+    // gone (deleted, or a legacy key that failed to migrate) by the time we
+    // looked. Treat this as a conflict rather than silently creating a fresh
+    // row — the caller's mutation was computed against state that no longer
+    // exists.
+    throw new AnalysisConflictError(id);
+  }
   const db = getDb() as any;
   if (existing) {
     await assertAccess("analysis", id, "editor", {
@@ -1305,11 +1478,36 @@ export async function upsertAnalysis(
         JSON.stringify(existing.dataSources) ||
       next.resultMarkdown !== existing.resultMarkdown ||
       JSON.stringify(next.resultData) !== JSON.stringify(existing.resultData);
-    if (changed) await snapshotAnalysisRevision(db, existing, ctx);
-    await db
-      .update(schema.analyses)
-      .set(patch)
-      .where(eq(schema.analyses.id, id));
+    if (expectedUpdatedAt !== undefined) {
+      // Fenced write. Snapshot the revision only after we know this exact
+      // write actually landed — otherwise a lost race would record a
+      // revision for a save that never happened.
+      const updateResult = await db
+        .update(schema.analyses)
+        .set(patch)
+        .where(
+          and(
+            eq(schema.analyses.id, id),
+            eq(schema.analyses.updatedAt, expectedUpdatedAt),
+          ),
+        );
+      const affected = affectedRowCount(updateResult);
+      if (affected === undefined) {
+        throw new Error(
+          "The database driver did not report an affected-row count for the fenced analysis update.",
+        );
+      }
+      if (affected === 0) {
+        throw new AnalysisConflictError(id);
+      }
+      if (changed) await snapshotAnalysisRevision(db, existing, ctx);
+    } else {
+      if (changed) await snapshotAnalysisRevision(db, existing, ctx);
+      await db
+        .update(schema.analyses)
+        .set(patch)
+        .where(eq(schema.analyses.id, id));
+    }
   } else {
     await db.insert(schema.analyses).values({
       id,
@@ -1337,6 +1535,77 @@ export async function upsertAnalysis(
   return rowToAnalysis(row);
 }
 
+/** Max attempts (first try + retries) for `upsertAnalysisWithRetry`. */
+export const ANALYSIS_SAVE_MAX_ATTEMPTS = 3;
+
+/**
+ * Read-modify-write helper for action call sites that fetch an analysis,
+ * mutate its fields in memory, then save it back. Fences every save with the
+ * `updatedAt` of the record `mutate` was given, so a concurrent writer (e.g.
+ * `save-analysis` re-running with fresh results while someone renames it)
+ * never gets silently clobbered.
+ *
+ * `mutate` is invoked with the freshest `AnalysisRecord` on every attempt —
+ * re-fetched from `getAnalysis` each time — and must recompute the body patch
+ * to save FROM THAT RECORD, not from a closure over an earlier read; only
+ * then does a retry actually merge both writers' changes instead of
+ * re-deriving the same stale result. `mutate` may throw a non-conflict error
+ * (e.g. validation) to abort immediately without retrying.
+ *
+ * On a lost race, this re-reads and re-invokes `mutate` up to `maxAttempts`
+ * times before failing loud with a clear error so callers never silently
+ * drop a write or loop forever.
+ */
+export async function upsertAnalysisWithRetry(
+  id: string,
+  ctx: AccessCtx,
+  mutate: (existing: AnalysisRecord) =>
+    | {
+        name?: string;
+        description?: string;
+        question?: string;
+        instructions?: string;
+        dataSources?: string[];
+        resultMarkdown?: string;
+        resultData?: Record<string, unknown> | null;
+      }
+    | Promise<{
+        name?: string;
+        description?: string;
+        question?: string;
+        instructions?: string;
+        dataSources?: string[];
+        resultMarkdown?: string;
+        resultData?: Record<string, unknown> | null;
+      }>,
+  maxAttempts: number = ANALYSIS_SAVE_MAX_ATTEMPTS,
+): Promise<AnalysisRecord> {
+  let lastConflict: unknown;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const existing = await getAnalysis(id, ctx);
+    if (!existing) {
+      throw new Error(`analysis "${id}" not found (or you don't have access).`);
+    }
+    const body = await mutate(existing);
+    try {
+      return await upsertAnalysis(id, body, ctx, existing.updatedAt);
+    } catch (err) {
+      if (err instanceof AnalysisConflictError) {
+        lastConflict = err;
+        continue;
+      }
+      throw err;
+    }
+  }
+  const finalError = new Error(
+    `Could not save analysis "${id}" after ${maxAttempts} attempt(s); it kept changing concurrently. Re-read the analysis and try again.`,
+  );
+  if (lastConflict !== undefined) {
+    (finalError as Error & { cause?: unknown }).cause = lastConflict;
+  }
+  throw finalError;
+}
+
 export async function listAnalysisRevisions(
   analysisId: string,
   ctx: AccessCtx,

package/corpus/templates/analytics/server/lib/data-dictionary-context.ts

@@ -1,6 +1,11 @@
 type DictionaryEntry = Record<string, unknown>;
 
 const MAX_INJECTED_ENTRIES = 40;
+// Per-field caps above bound a single entry to ~3-3.5K chars, so 40 entries
+// could still swell to ~130K chars riding every chat request even though the
+// entry count is capped. Bound the whole rendered block too, and truncate at
+// entry boundaries (never mid-entry) once it's hit.
+const MAX_DICTIONARY_CONTEXT_CHARS = 10_000;
 
 function compact(value: unknown, max = 240): string {
   const text = String(value ?? "")
@@ -97,6 +102,76 @@ function renderOmittedDictionaryEntries(omitted: number): string[] {
   ];
 }
 
+function renderedTextLength(lines: string[]): number {
+  // +1 per line approximates the join("\n") separators without materializing
+  // the joined string on every entry (entry counts are small, so this stays
+  // cheap even though it's O(n) per call).
+  return lines.reduce((total, line) => total + line.length + 1, 0);
+}
+
+type TrustLabel = "approved/canonical" | "unreviewed/human" | "ai-suggestion";
+
+/**
+ * Render one trust-tier group into `lines`, respecting both the per-tier
+ * count budget already applied by `takeWithinBudget` and the shared total
+ * character budget tracked in `state`. Entries are never split mid-render:
+ * once adding the next whole entry would exceed the char budget, rendering
+ * stops at that entry boundary and everything remaining (in this group and
+ * any group processed after it) is counted as omitted.
+ */
+function renderGroupWithinBudget(
+  lines: string[],
+  title: string,
+  groupEntries: DictionaryEntry[],
+  trustLabel: TrustLabel,
+  renderedCount: number,
+  state: { charBudgetExceeded: boolean; anyEntryRendered: boolean },
+): { renderedCount: number; omitted: number } {
+  if (!groupEntries.length) return { renderedCount, omitted: 0 };
+
+  const budgeted = takeWithinBudget(groupEntries, renderedCount);
+  let omitted = budgeted.omitted;
+  const bodyLines: string[] = [];
+  let includedFromGroup = 0;
+
+  for (const entry of budgeted.entries) {
+    if (state.charBudgetExceeded) {
+      omitted += 1;
+      continue;
+    }
+
+    const entryLines = renderEntry(entry, trustLabel);
+    const headerAddition = includedFromGroup === 0 ? title.length + 1 : 0;
+    const prospectiveTotal =
+      renderedTextLength(lines) +
+      headerAddition +
+      renderedTextLength(bodyLines) +
+      renderedTextLength(entryLines);
+
+    // Always keep at least one entry across the whole dictionary render so a
+    // single oversized entry can't produce an empty block; every entry after
+    // that respects the char budget at its boundary.
+    if (
+      prospectiveTotal > MAX_DICTIONARY_CONTEXT_CHARS &&
+      state.anyEntryRendered
+    ) {
+      state.charBudgetExceeded = true;
+      omitted += 1;
+      continue;
+    }
+
+    bodyLines.push(...entryLines);
+    includedFromGroup += 1;
+    state.anyEntryRendered = true;
+  }
+
+  if (includedFromGroup > 0) {
+    lines.push(title, ...bodyLines, "");
+  }
+
+  return { renderedCount: budgeted.renderedCount, omitted };
+}
+
 /**
  * Render data-dictionary entries as compact prompt context.
  *
@@ -127,6 +202,7 @@ export function renderDataDictionary(entries: DictionaryEntry[]): string {
   const includeAiSuggestions = approved.length + humanUnreviewed.length === 0;
   let renderedCount = 0;
   let omittedEntries = 0;
+  const budgetState = { charBudgetExceeded: false, anyEntryRendered: false };
 
   const lines: string[] = [
     "<data-dictionary>",
@@ -136,43 +212,39 @@ export function renderDataDictionary(entries: DictionaryEntry[]): string {
     "",
   ];
 
-  if (approved.length) {
-    const budgeted = takeWithinBudget(approved, renderedCount);
-    renderedCount = budgeted.renderedCount;
-    omittedEntries += budgeted.omitted;
-    if (budgeted.entries.length) {
-      lines.push("## Approved canonical entries");
-      for (const entry of budgeted.entries) {
-        lines.push(...renderEntry(entry, "approved/canonical"));
-      }
-      lines.push("");
-    }
-  }
+  const approvedResult = renderGroupWithinBudget(
+    lines,
+    "## Approved canonical entries",
+    approved,
+    "approved/canonical",
+    renderedCount,
+    budgetState,
+  );
+  renderedCount = approvedResult.renderedCount;
+  omittedEntries += approvedResult.omitted;
 
-  if (humanUnreviewed.length) {
-    const budgeted = takeWithinBudget(humanUnreviewed, renderedCount);
-    renderedCount = budgeted.renderedCount;
-    omittedEntries += budgeted.omitted;
-    if (budgeted.entries.length) {
-      lines.push("## Unreviewed human-authored entries");
-      for (const entry of budgeted.entries) {
-        lines.push(...renderEntry(entry, "unreviewed/human"));
-      }
-      lines.push("");
-    }
-  }
+  const humanResult = renderGroupWithinBudget(
+    lines,
+    "## Unreviewed human-authored entries",
+    humanUnreviewed,
+    "unreviewed/human",
+    renderedCount,
+    budgetState,
+  );
+  renderedCount = humanResult.renderedCount;
+  omittedEntries += humanResult.omitted;
 
   if (includeAiSuggestions && aiSuggestions.length) {
-    const budgeted = takeWithinBudget(aiSuggestions, renderedCount);
-    renderedCount = budgeted.renderedCount;
-    omittedEntries += budgeted.omitted;
-    if (budgeted.entries.length) {
-      lines.push("## AI-generated suggestions");
-      for (const entry of budgeted.entries) {
-        lines.push(...renderEntry(entry, "ai-suggestion"));
-      }
-      lines.push("");
-    }
+    const aiResult = renderGroupWithinBudget(
+      lines,
+      "## AI-generated suggestions",
+      aiSuggestions,
+      "ai-suggestion",
+      renderedCount,
+      budgetState,
+    );
+    renderedCount = aiResult.renderedCount;
+    omittedEntries += aiResult.omitted;
   } else if (aiSuggestions.length) {
     lines.push(
       `${aiSuggestions.length} AI-generated unapproved suggestion${

package/corpus/templates/analytics/server/lib/demo-dashboards.ts

@@ -265,7 +265,10 @@ export async function ensureDemoDashboardsForUser(
         throw new Error(`Demo dashboard seed not found: ${demo.seedId}`);
       const config = applyDemoMetadata(seed, demo.id);
       const row = await upsertDashboard(dashboardId, "sql", config, privateCtx);
-      await syncToCollab(dashboardId, config);
+      // SQL is the source of truth and collab state can seed lazily. Do not
+      // hold first-open installation (and the whole app shell) behind a remote
+      // collab read/write that may be slow or temporarily unavailable.
+      void syncToCollab(dashboardId, config);
       archivedAt = row.archivedAt;
       created = !existing;
     }

package/corpus/templates/analytics/server/plugins/agent-chat.ts

@@ -1,7 +1,6 @@
 import { getOrgContext } from "@agent-native/core/org";
 import {
   createAgentChatPlugin,
-  getRequestRunContext,
   loadActionsFromStaticRegistry,
   type AgentLoopFinalResponseGuardContext,
 } from "@agent-native/core/server";
@@ -11,7 +10,6 @@ import {
   applyAnalyticsPlanModePolicy,
   INITIAL_TOOL_NAMES,
 } from "../lib/agent-chat-plan-mode";
-import { renderDataDictionary } from "../lib/data-dictionary-context";
 import {
   failedDataQueryAttemptMessage,
   hasExplicitPartialDisclosure,
@@ -26,12 +24,6 @@ import {
   needsCorpusWorkflowForCoverageSensitiveRequest,
   needsSourceRecordBodyWorkflowForCoverageSensitiveRequest,
 } from "../lib/real-data-actions";
-import {
-  listScopedSettingRecords,
-  resolveSettingsScope,
-} from "../lib/scoped-settings";
-
-const DATA_DICT_PREFIX = "data-dict-";
 const ANALYTICS_BACKGROUND_RUN_SOFT_TIMEOUT_MS = 13 * 60_000;
 
 export const SIMPLE_TIME_BOUNDED_METRIC_FAST_PATH_GUIDANCE =
@@ -46,6 +38,12 @@ export function analyticsSourceGuidanceOpening(): string {
   );
 }
 
+export function analyticsDataDictionaryRoutingContext(): string {
+  return `<data-dictionary-routing>
+Data-dictionary definitions are available on demand instead of being embedded in every chat request. Before writing SQL or making a metric-definition claim, call \`list-data-dictionary\` with a focused \`search\` or \`department\` filter. If the user asks what definitions exist and no useful filter is available, call it without filters. Treat approved entries as canonical, verify unreviewed human entries when stakes are high, and treat AI-generated unapproved entries as suggestions only. If no matching definition exists, inspect the configured source schema or ask the user instead of guessing.
+</data-dictionary-routing>`;
+}
+
 export {
   applyAnalyticsPlanModePolicy,
   INITIAL_TOOL_NAMES,
@@ -231,10 +229,10 @@ export default createAgentChatPlugin({
     const ctx = await getOrgContext(event);
     return ctx.orgId;
   },
-  extraContext: async (event) => {
-    // Always inject source guidance, even if the data-dictionary lookup throws.
-    // The generic template can ship provider actions without every deployment
-    // having credentials or workspace-specific schemas configured.
+  extraContext: async () => {
+    // Always inject compact source-routing guidance. Dictionary definitions
+    // stay behind list-data-dictionary so prompt assembly does not read and
+    // render every organization metric before the model request starts.
     const sourceGuidance =
       analyticsSourceGuidanceOpening() +
       "DASHBOARD CREATION RULE — You may create dashboards, analyses, SQL panels, or other resources only when the user explicitly asks you to (e.g. 'build me a dashboard for...', 'create a new analysis', 'add a chart for...'). Never create any resource proactively during research, trend analysis, or answering questions. If you think a dashboard would be useful, suggest it and wait for explicit confirmation before creating anything. Never add new items to the sidebar or modify existing dashboards without an explicit user directive. " +
@@ -268,33 +266,7 @@ export default createAgentChatPlugin({
       "Do not also create a same-named dashboard or saved analysis unless the user explicitly asked for multiple artifacts; saved analyses appear in the sidebar and should not be used for throwaway notes or scratch summaries.\n" +
       "</analytics-artifact-guidance>";
 
-    // In the durable background-function worker, skip the data-dictionary read
-    // + render. That settings read + synchronous render is the heaviest, most
-    // hang-prone part of worker setup on a cold bg-fn instance, and it runs
-    // EAGERLY while the system prompt is built (before any pre-send timeout can
-    // arm), so a stall here is what kept the analytics worker from ever claiming
-    // its run. The agent can still pull dictionary entries on demand via
-    // `list-data-dictionary` / `search-bigquery-schema`; the static guidance is
-    // what it needs to know they exist. Foreground requests keep the full dict.
-    if (getRequestRunContext()?.isBackgroundWorker) {
-      return `${sourceGuidance}\n\n${artifactGuidance}`;
-    }
-
-    try {
-      const scope = await resolveSettingsScope(event);
-      const all = await listScopedSettingRecords(scope, DATA_DICT_PREFIX);
-      const entries = Object.values(all) as Array<Record<string, unknown>>;
-      const dict = renderDataDictionary(entries);
-      return dict
-        ? `${sourceGuidance}\n\n${artifactGuidance}\n\n${dict}`
-        : `${sourceGuidance}\n\n${artifactGuidance}`;
-    } catch (err) {
-      console.warn(
-        "[analytics] data dictionary context failed:",
-        err instanceof Error ? err.message : err,
-      );
-      return `${sourceGuidance}\n\n${artifactGuidance}`;
-    }
+    return `${sourceGuidance}\n\n${artifactGuidance}\n\n${analyticsDataDictionaryRoutingContext()}`;
   },
   mentionProviders: {
     dashboards: {

package/corpus/templates/assets/.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.