@agent-native/core 0.169.0 → 0.170.0

package/corpus/templates/analytics/app/pages/DashboardOverview.tsx

@@ -56,6 +56,10 @@ import {
   SelectValue,
 } from "@/components/ui/select";
 import { Skeleton } from "@/components/ui/skeleton";
+import {
+  isDashboardMine,
+  type DashboardVisibility,
+} from "@/lib/dashboard-visibility";
 import { dashboardCacheScope } from "@/lib/prefetch-keys";
 
 import { NewDashboardDialog } from "../components/layout/NewDashboardDialog";
@@ -65,7 +69,8 @@ type Dashboard = {
   id: string;
   name?: string;
   title?: string;
-  visibility?: string;
+  visibility?: DashboardVisibility;
+  ownerEmail?: string | null;
   folderId?: string | null;
 };
 type Folder = {
@@ -125,10 +130,15 @@ export default function DashboardOverview() {
         ) {
           continue;
         }
+        const ownerEmail =
+          typeof dashboard.ownerEmail === "string"
+            ? dashboard.ownerEmail
+            : undefined;
         validDashboards.push({
           id: dashboard.id,
           name: dashboard.name,
           visibility: dashboard.visibility,
+          ...(ownerEmail ? { ownerEmail } : {}),
           folderId: dashboard.folderId ?? null,
         });
       }
@@ -394,6 +404,7 @@ export default function DashboardOverview() {
               folders={folders}
               grouped={grouped}
               onMove={moveDashboard}
+              currentUserEmail={auth?.email}
               t={t}
             />
           ))}
@@ -428,6 +439,7 @@ function DashboardScopeSection({
   folders,
   grouped,
   onMove,
+  currentUserEmail,
   t,
 }: {
   scope: Scope;
@@ -435,11 +447,12 @@ function DashboardScopeSection({
   folders: Folder[];
   grouped: Map<string, Dashboard[]>;
   onMove: (dashboard: Dashboard, folderId: string | null) => void;
+  currentUserEmail?: string | null;
   t: ReturnType<typeof useT>;
 }) {
   const scopeFolders = folders.filter((folder) => folder.scope === scope);
   const scopeDashboards = dashboards.filter((dashboard) =>
-    isDashboardInScope(dashboard, scope),
+    isDashboardInScope(dashboard, scope, currentUserEmail),
   );
   const Icon = scope === "personal" ? IconLock : IconUsers;
 
@@ -476,6 +489,7 @@ function DashboardScopeSection({
               folders={folders}
               scope={scope}
               onMove={onMove}
+              currentUserEmail={currentUserEmail}
               t={t}
             />
           ))}
@@ -485,6 +499,7 @@ function DashboardScopeSection({
             folders={folders}
             scope={scope}
             onMove={onMove}
+            currentUserEmail={currentUserEmail}
             t={t}
             hideWhenEmpty
           />
@@ -500,6 +515,7 @@ function FolderSection({
   folders,
   scope,
   onMove,
+  currentUserEmail,
   t,
   hideWhenEmpty = false,
 }: {
@@ -508,11 +524,12 @@ function FolderSection({
   folders: Folder[];
   scope: Scope;
   onMove: (dashboard: Dashboard, folderId: string | null) => void;
+  currentUserEmail?: string | null;
   t: ReturnType<typeof useT>;
   hideWhenEmpty?: boolean;
 }) {
   const scopedDashboards = dashboards.filter((dashboard) =>
-    isDashboardInScope(dashboard, scope),
+    isDashboardInScope(dashboard, scope, currentUserEmail),
   );
   if (hideWhenEmpty && scopedDashboards.length === 0) return null;
 
@@ -540,6 +557,7 @@ function FolderSection({
               folders={folders}
               currentFolderId={folder?.id ?? null}
               onMove={onMove}
+              currentUserEmail={currentUserEmail}
               t={t}
             />
           ))}
@@ -554,23 +572,26 @@ function DashboardRow({
   folders,
   currentFolderId,
   onMove,
+  currentUserEmail,
   t,
 }: {
   dashboard: Dashboard;
   folders: Folder[];
   currentFolderId: string | null;
   onMove: (dashboard: Dashboard, folderId: string | null) => void;
+  currentUserEmail?: string | null;
   t: ReturnType<typeof useT>;
 }) {
   const name =
     dashboard.name || dashboard.title || t("sidebar.untitledDashboard");
+  const mine = isDashboardMine(dashboard, currentUserEmail);
   const candidateFolders = folders.filter((folder) => {
-    if (dashboard.visibility === "private") {
+    if (mine) {
       return folder.scope === "personal";
     }
     return dashboard.visibility === "org" && folder.scope === "shared";
   });
-  const canOrganize = dashboard.visibility !== "public";
+  const canOrganize = mine || dashboard.visibility === "org";
 
   return (
     <div className="group flex items-center gap-3 px-4 py-3 transition-colors hover:bg-muted/30">
@@ -586,7 +607,7 @@ function DashboardRow({
             {name}
           </p>
           <p className="truncate text-xs text-muted-foreground">
-            {dashboard.visibility === "private"
+            {mine
               ? t("dashboardOverview.personal")
               : t("dashboardOverview.shared")}
           </p>
@@ -635,8 +656,12 @@ function DashboardRow({
   );
 }
 
-function isDashboardInScope(dashboard: Dashboard, scope: Scope): boolean {
+function isDashboardInScope(
+  dashboard: Dashboard,
+  scope: Scope,
+  currentUserEmail?: string | null,
+): boolean {
   return scope === "personal"
-    ? dashboard.visibility === "private"
-    : dashboard.visibility === "org" || dashboard.visibility === "public";
+    ? isDashboardMine(dashboard, currentUserEmail)
+    : !isDashboardMine(dashboard, currentUserEmail);
 }

package/corpus/templates/analytics/app/routes/$.tsx

@@ -1,3 +1,5 @@
+import { data } from "react-router";
+
 import { messagesByLocale } from "@/i18n-data";
 import NotFound from "@/pages/NotFound";
 
@@ -5,6 +7,14 @@ export function meta() {
   return [{ title: messagesByLocale["en-US"].routeTitles.notFound }];
 }
 
+// The splat route matches every unmatched path, so React Router's "no routes
+// matched" 404 branch never fires here and the response defaults to 200. Set
+// the status explicitly so the shell is served (and CDN-cached) as the
+// not-found page it actually is.
+export function loader() {
+  return data(null, { status: 404 });
+}
+
 export default function CatchAllRoute() {
   return <NotFound />;
 }

package/corpus/templates/analytics/app/routes.ts

@@ -1,4 +1,6 @@
 import { type RouteConfig } from "@react-router/dev/routes";
 import { flatRoutes } from "@react-router/fs-routes";
 
-export default flatRoutes() satisfies RouteConfig;
+export default flatRoutes({
+  ignoredRouteFiles: ["**/*.test.{ts,tsx}", "**/*.spec.{ts,tsx}"],
+}) satisfies RouteConfig;

package/corpus/templates/analytics/changelog/2026-08-21-dashboard-filters-keep-other-users-dashboards-out-of-mine.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-21
+---
+
+Dashboard filters keep other users' dashboards out of Mine

package/corpus/templates/analytics/changelog/2026-08-22-fixed-the-agent-native-templates-first-party-dashboard-panel.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-22
+---
+
+Fixed the Agent Native Templates (First-party) dashboard panels failing to load on a local SQLite database

package/corpus/templates/analytics/changelog/2026-08-22-org-admin-panels-no-longer-report-a-database-error-as-a-per.md

@@ -0,0 +1,9 @@
+---
+type: fixed
+date: 2026-08-22
+---
+
+Org admin panels no longer report a database error as a permission denial. A failed
+organization-role lookup now surfaces as a retryable error instead of silently reading
+as "you are not an owner or admin", which had been 403-ing the usage stats panel for
+real admins whenever the database was briefly unreachable.

package/corpus/templates/analytics/changelog/2026-08-22-slack-requests-report-invalid-inputs.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-22
+---
+
+Slack analytics requests now reject invalid workspaces and cursors with actionable errors instead of using the wrong workspace or returning a server failure.

package/corpus/templates/analytics/changelog/2026-08-22-unknown-analytics-links-now-return-a-real-not-found-status.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-22
+---
+
+Visiting a broken or mistyped Analytics link now returns a real not-found response instead of a silent success.

package/corpus/templates/analytics/docs/schemas/first-party-analytics.md

@@ -128,7 +128,8 @@ Useful query fields live in `properties`:
 | `cache_read_tokens`, `cache_write_tokens`        | Prompt-cache token counts                                                                         |
 | `$ai_total_cost_usd`, `cost_usd`                 | Estimated run cost in USD                                                                         |
 | `cost_cents_x100`                                | Estimated run cost in centicents                                                                  |
-| `$ai_latency`, `duration_ms`                     | Run duration in seconds / milliseconds                                                            |
+| `duration_ms`                                    | Run duration in milliseconds                                                                      |
+| `$ai_latency`                                    | Model time in seconds (run duration minus tool time), on `$ai_generation`                         |
 | `tool_calls`, `successful_tools`, `failed_tools` | Complete tool-call counts                                                                         |
 | `tools`, `tools_truncated`                       | First 50 tool names, offsets, durations, statuses, and error classes, including interrupted calls |
 | `delegated`, `delegation_protocol`, `caller_app` | Delegated-run attribution                                                                         |

package/corpus/templates/analytics/docs/schemas/tracked-events.md

@@ -29,6 +29,8 @@ Events tracked by application instrumentation and stored in the configured appli
   `$ai_model`, `$ai_provider`, `$ai_input_tokens`, `$ai_output_tokens`,
   `$ai_latency`, `$ai_total_cost_usd`, `run_id`, `thread_id`,
   `cost_cents_x100`, `duration_ms`, `tool_calls`, `status`, and error fields.
+  `$ai_latency` is model time in seconds; `duration_ms` is the full run in
+  milliseconds, and the two differ by the time spent in tools.
   A bounded `tools` array records only tool names, relative start times,
   durations, statuses, and coarse error classes; interrupted tools and failed
   runs remain visible, and `tools_truncated` marks runs above the 50-entry cap.

package/corpus/templates/analytics/scripts/emit-netlify-dashboard-report-cron.ts

@@ -5,7 +5,29 @@ import { existsSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
-import { cloneServerBundleForFunction } from "@agent-native/core/deploy/function-bundle";
+import {
+  cloneServerBundleForFunction,
+  pruneBrowserRuntimeFromNonAgentClone,
+  pruneSsrIslandFromRewritingClone,
+} from "@agent-native/core/deploy/function-bundle";
+
+/**
+ * Each sweep worker is a full clone of the server bundle, but its entry rewrites
+ * the pathname to one scheduled route. It can reach neither the SSR pages nor an
+ * agent turn, yet it shipped both the page island and the 79MB browser runtime —
+ * six times over, and Netlify zips every function separately.
+ */
+function writeWorkerEntry(dest: string, name: string, source: string): void {
+  writeFileSync(path.join(dest, `${name}.mjs`), source);
+  const freed =
+    pruneSsrIslandFromRewritingClone(dest, source) +
+    pruneBrowserRuntimeFromNonAgentClone(dest, source);
+  if (freed > 0) {
+    console.log(
+      `[deploy] Pruned ${(freed / 1024 / 1024).toFixed(1)}MB of unreachable modules from ${name}.`,
+    );
+  }
+}
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const FUNCTIONS_DIR = path.join(ROOT, ".netlify", "functions-internal");
@@ -164,7 +186,7 @@ export const config = {
 };
 `;
 
-  writeFileSync(path.join(dest, `${WORKER_NAME}.mjs`), source);
+  writeWorkerEntry(dest, WORKER_NAME, source);
 }
 
 function emitAlertScheduledTrigger(token: string) {
@@ -282,7 +304,7 @@ export const config = {
 };
 `;
 
-  writeFileSync(path.join(dest, `${ALERT_WORKER_NAME}.mjs`), source);
+  writeWorkerEntry(dest, ALERT_WORKER_NAME, source);
 }
 
 function emitUptimeScheduledTrigger(token: string) {
@@ -400,7 +422,7 @@ export const config = {
 };
 `;
 
-  writeFileSync(path.join(dest, `${UPTIME_WORKER_NAME}.mjs`), source);
+  writeWorkerEntry(dest, UPTIME_WORKER_NAME, source);
 }
 
 function emitRollupScheduledTrigger(token: string) {
@@ -500,7 +522,7 @@ export const config = {
 };
 `;
 
-  writeFileSync(path.join(dest, `${ROLLUP_WORKER_NAME}.mjs`), source);
+  writeWorkerEntry(dest, ROLLUP_WORKER_NAME, source);
 }
 
 function emitBigQueryScheduledTrigger(token: string) {
@@ -600,7 +622,7 @@ export const config = {
 };
 `;
 
-  writeFileSync(path.join(dest, `${BIGQUERY_WORKER_NAME}.mjs`), source);
+  writeWorkerEntry(dest, BIGQUERY_WORKER_NAME, source);
 }
 
 function emitRetentionScheduledTrigger(token: string) {
@@ -702,7 +724,7 @@ export const config = {
 };
 `;
 
-  writeFileSync(path.join(dest, `${RETENTION_WORKER_NAME}.mjs`), source);
+  writeWorkerEntry(dest, RETENTION_WORKER_NAME, source);
 }
 
 function isDirectRun(): boolean {

package/corpus/templates/analytics/server/handlers/slack.ts

@@ -19,8 +19,57 @@ import {
   type SlackMessage,
 } from "../lib/slack";
 
-function parseWorkspace(raw?: string): Workspace {
-  return raw === "secondary" ? "secondary" : "primary";
+export function parseWorkspace(raw?: unknown): Workspace | null {
+  if (raw === undefined || raw === null || raw === "" || raw === "primary") {
+    return "primary";
+  }
+  if (raw === "secondary") return "secondary";
+  return null;
+}
+
+function invalidWorkspace(event: H3Event) {
+  setResponseStatus(event, 400);
+  return { error: "workspace must be primary or secondary" };
+}
+
+export function parseCursorMap(
+  raw?: unknown,
+): { ok: true; value: Record<string, string> } | { ok: false } {
+  if (raw === undefined || raw === null || raw === "") {
+    return { ok: true, value: {} };
+  }
+
+  try {
+    const parsed: unknown = JSON.parse(String(raw));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { ok: false };
+    }
+    const entries = Object.entries(parsed);
+    if (
+      entries.some(
+        ([, value]) =>
+          typeof value !== "string" ||
+          !/^\d+(?:\.\d{1,6})?$/.test(value.trim()),
+      )
+    ) {
+      return { ok: false };
+    }
+    return {
+      ok: true,
+      value: Object.fromEntries(
+        entries.map(([channelId, value]) => [channelId, value.trim()]),
+      ),
+    };
+  } catch {
+    return { ok: false };
+  }
+}
+
+function invalidCursors(event: H3Event) {
+  setResponseStatus(event, 400);
+  return {
+    error: "cursors must be a JSON object of channel IDs to timestamps",
+  };
 }
 
 async function requireSlackCredential(event: H3Event, workspace: Workspace) {
@@ -34,6 +83,7 @@ export const handleSlackTeam = defineEventHandler((event) =>
     try {
       const { workspace: workspaceParam } = getQuery(event);
       const workspace = parseWorkspace(workspaceParam as string);
+      if (!workspace) return invalidWorkspace(event);
       const missing = await requireSlackCredential(event, workspace);
       if (missing) return missing;
       const team = await getTeamInfo(workspace);
@@ -51,6 +101,7 @@ export const handleSlackChannels = defineEventHandler((event) =>
     try {
       const { workspace: workspaceParam, cursor } = getQuery(event);
       const workspace = parseWorkspace(workspaceParam as string);
+      if (!workspace) return invalidWorkspace(event);
       const missing = await requireSlackCredential(event, workspace);
       if (missing) return missing;
       const result = await listChannelsWithCoverage(
@@ -102,6 +153,7 @@ export const handleSlackHistory = defineEventHandler((event) =>
         cursor,
       } = getQuery(event);
       const workspace = parseWorkspace(workspaceParam as string);
+      if (!workspace) return invalidWorkspace(event);
       const missing = await requireSlackCredential(event, workspace);
       if (missing) return missing;
       const limit = parseInt((limitParam as string) || "50", 10);
@@ -174,6 +226,7 @@ export const handleSlackMultiHistory = defineEventHandler((event) =>
         cursors: cursorsParam,
       } = getQuery(event);
       const workspace = parseWorkspace(workspaceParam as string);
+      if (!workspace) return invalidWorkspace(event);
       const missing = await requireSlackCredential(event, workspace);
       if (missing) return missing;
       // cursors is a JSON-encoded object: { channelId: timestamp }
@@ -188,9 +241,9 @@ export const handleSlackMultiHistory = defineEventHandler((event) =>
       const channelNamesList = namesParam
         ? (namesParam as string).split(",")
         : channelIds;
-      const cursors: Record<string, string> = cursorsParam
-        ? JSON.parse(cursorsParam as string)
-        : {};
+      const parsedCursors = parseCursorMap(cursorsParam);
+      if (!parsedCursors.ok) return invalidCursors(event);
+      const cursors = parsedCursors.value;
 
       // Fetch pageSize messages from each channel in parallel while preserving
       // partial results when the bot is not invited to one of the channels.
@@ -358,6 +411,7 @@ export const handleSlackSearch = defineEventHandler((event) =>
     try {
       const { workspace: workspaceParam, query } = getQuery(event);
       const workspace = parseWorkspace(workspaceParam as string);
+      if (!workspace) return invalidWorkspace(event);
       const missing = await requireSlackCredential(event, workspace);
       if (missing) return missing;
 

package/corpus/templates/analytics/server/lib/db-admin-connections.ts

@@ -69,15 +69,20 @@ async function resolveOrgRole(
   userEmail: string,
   orgId: string,
 ): Promise<string | null> {
-  try {
-    const { rows } = await getDbExec().execute({
+  // A failed lookup must never collapse into "no role": that reads downstream as
+  // a denial and 403s org owners whenever the database is briefly unreachable.
+  const { rows } = await getDbExec()
+    .execute({
       sql: `SELECT role FROM org_members WHERE org_id = ? AND LOWER(email) = ? LIMIT 1`,
       args: [orgId, userEmail.toLowerCase()],
+    })
+    .catch((error: unknown) => {
+      throw new DbAdminConnectionError(
+        503,
+        `Couldn't verify your organization role: ${redactDbAdminError(error)}`,
+      );
     });
-    return readString((rows[0] ?? {}) as Record<string, unknown>, "role");
-  } catch {
-    return null;
-  }
+  return readString((rows[0] ?? {}) as Record<string, unknown>, "role");
 }
 
 export async function requireAnalyticsAdminContext(input?: {

package/corpus/templates/analytics/server/lib/first-party-analytics.ts

@@ -1,4 +1,4 @@
-import { getDbExec } from "@agent-native/core/db";
+import { getDbExec, isPostgres } from "@agent-native/core/db";
 import { runWithRequestContext } from "@agent-native/core/server";
 import { and, eq, isNull, lt, or } from "drizzle-orm";
 
@@ -1072,6 +1072,130 @@ export function scopedAnalyticsSql(
   return { sql: rewritten, args };
 }
 
+/**
+ * Dashboard panel SQL (seeded and agent/user-authored) is written against
+ * PostgreSQL date/JSON syntax — `to_char`/`INTERVAL`/`::date`/`::jsonb ->>` —
+ * because that's the dialect this app runs against in production. A local
+ * SQLite dev database doesn't understand any of that and throws a syntax
+ * error before a row is ever read. Rather than hand-rewrite every seeded
+ * panel's SQL (this app also lets the agent/UI author new first-party SQL
+ * panels through this exact same execution path), translate the handful of
+ * Postgres-only shapes this query surface actually produces into SQLite
+ * equivalents right here at the execution boundary. PostgreSQL SQL is never
+ * touched: this only runs when the active database is not Postgres.
+ */
+export function toSqliteCompatibleFirstPartySql(sql: string): string {
+  let out = sql;
+
+  // properties::jsonb ->> 'key'  ->  json_extract(properties, '$."key"')
+  // (a quoted JSON path member tolerates keys like "$ai_model" that start
+  // with a character SQLite's unquoted path syntax can't lead with).
+  out = out.replace(
+    /([A-Za-z_][A-Za-z0-9_.]*)::jsonb\s*->>\s*'([^']*)'/g,
+    (_match, column: string, key: string) =>
+      `json_extract(${column}, '$."${key}"')`,
+  );
+
+  // Postgres chr(N) -> SQLite char(N).
+  out = out.replace(/\bchr\(/g, "char(");
+
+  // Any other Postgres type cast (::date, ::float, ::timestamptz, ...) is a
+  // no-op on SQLite's dynamically-typed columns.
+  out = out.replace(/::[A-Za-z_][A-Za-z0-9_]*/g, "");
+
+  // to_char(date_trunc('week', X), 'YYYY-MM-DD') -> Monday of X's week.
+  // ('weekday 0' finds the next Sunday, '-6 days' steps back to that week's
+  // Monday, matching Postgres's ISO week truncation.)
+  out = out.replace(
+    /to_char\(\s*date_trunc\(\s*'week'\s*,\s*([^()]+?)\s*\)\s*,\s*'YYYY-MM-DD'\s*\)/g,
+    (_match, expr: string) => `date(${expr}, 'weekday 0', '-6 days')`,
+  );
+
+  // <dateish-expr> (+|-) INTERVAL 'N days'  ->  the same day count applied
+  // through SQLite's julian-day arithmetic, immediately reformatted back to
+  // 'YYYY-MM-DD' text. Re-wrapping right away (instead of leaving a bare
+  // julian-day number) matters: this expression sometimes appears outside
+  // any to_char() call, compared directly against a text date column, and
+  // SQLite treats any numeric value as less than any text value — a bare
+  // number here would make that comparison silently always-true.
+  out = out.replace(
+    /([A-Za-z_][A-Za-z0-9_.]*|CURRENT_DATE)\s*(\+|-)\s*INTERVAL\s*'(\d+)\s*days?'/g,
+    (_match, base: string, op: string, days: string) => {
+      const juliandayBase = base === "CURRENT_DATE" ? "'now'" : base;
+      return `date(julianday(${juliandayBase}) ${op} ${days})`;
+    },
+  );
+
+  // <dateish-expr ending in "date"> (+|-) <identifier>  (no INTERVAL
+  // keyword) — e.g. `bounds.start_date + offsets.n` in a generated date
+  // series. Scoped to identifiers ending in "date" so unrelated integer
+  // arithmetic (e.g. building the offsets themselves) is left alone.
+  out = out.replace(
+    /([A-Za-z_][A-Za-z0-9_.]*date)\s*(\+|-)\s*([A-Za-z_][A-Za-z0-9_.]*)/g,
+    (_match, base: string, op: string, rhs: string) =>
+      `date(julianday(${base}) ${op} ${rhs})`,
+  );
+
+  // Every surviving to_char(expr, 'YYYY-MM-DD') now wraps an expr that
+  // already evaluates to 'YYYY-MM-DD' text (a bare CURRENT_DATE, or one of
+  // the date(...) forms produced above) — unwrap the call instead of
+  // re-wrapping it. A regex can't balance the arbitrarily nested parens
+  // `date(julianday(...) ...)` can produce, so walk the string instead.
+  out = unwrapPostgresToChar(out);
+
+  return out;
+}
+
+/**
+ * Finds each top-level `to_char(expr, 'YYYY-MM-DD')` call and replaces it
+ * with `expr` alone. Balances parens by hand rather than by regex so nested
+ * calls (`date(julianday(...) - 7)`) unwrap correctly regardless of depth.
+ */
+function unwrapPostgresToChar(sql: string): string {
+  const marker = "to_char(";
+  let out = "";
+  let i = 0;
+  while (i < sql.length) {
+    const idx = sql.indexOf(marker, i);
+    if (idx === -1) {
+      out += sql.slice(i);
+      break;
+    }
+    out += sql.slice(i, idx);
+    const openParen = idx + marker.length - 1;
+    let depth = 0;
+    let closeParen = openParen;
+    for (; closeParen < sql.length; closeParen++) {
+      if (sql[closeParen] === "(") depth++;
+      else if (sql[closeParen] === ")") {
+        depth--;
+        if (depth === 0) break;
+      }
+    }
+    const inner = sql.slice(openParen + 1, closeParen);
+    let innerDepth = 0;
+    let topLevelCommaIdx = -1;
+    for (let k = 0; k < inner.length; k++) {
+      if (inner[k] === "(") innerDepth++;
+      else if (inner[k] === ")") innerDepth--;
+      else if (inner[k] === "," && innerDepth === 0) topLevelCommaIdx = k;
+    }
+    const expr =
+      topLevelCommaIdx === -1 ? inner : inner.slice(0, topLevelCommaIdx);
+    const format =
+      topLevelCommaIdx === -1 ? "" : inner.slice(topLevelCommaIdx + 1).trim();
+    if (format === "'YYYY-MM-DD'") {
+      out += expr.trim();
+    } else {
+      // Not the to_char(expr, 'YYYY-MM-DD') shape this app's SQL uses;
+      // leave it untouched rather than guess at unfamiliar formats.
+      out += sql.slice(idx, closeParen + 1);
+    }
+    i = closeParen + 1;
+  }
+  return out;
+}
+
 function valueType(value: unknown): string {
   if (typeof value === "number") return "number";
   if (typeof value === "boolean") return "boolean";
@@ -1141,7 +1265,13 @@ export async function queryFirstPartyAnalytics(
     return queryFirstPartyAnalyticsInBigQuery(scoped.sql, scoped.args, table);
   }
   const scoped = scopedAnalyticsSql(sql, scope);
-  const wrappedSql = `SELECT * FROM (${scoped.sql}) AS first_party_analytics_query LIMIT ${MAX_QUERY_ROWS}`;
+  // Dashboard SQL is authored against Postgres date/JSON syntax; translate
+  // it for a non-Postgres sql-store (local SQLite dev) at the last possible
+  // moment so Postgres itself never sees a rewritten query.
+  const dialectSql = isPostgres()
+    ? scoped.sql
+    : toSqliteCompatibleFirstPartySql(scoped.sql);
+  const wrappedSql = `SELECT * FROM (${dialectSql}) AS first_party_analytics_query LIMIT ${MAX_QUERY_ROWS}`;
   const timeoutMs = Math.max(
     1,
     options.timeoutMs ?? FIRST_PARTY_ANALYTICS_QUERY_TIMEOUT_MS,

package/corpus/templates/analytics/server/lib/real-data-actions.ts

@@ -286,10 +286,13 @@ function looksLikeWorkflowOrAutomationRequest(lower: string): boolean {
 }
 
 const ANALYTICS_RESULT_TERMS =
-  /\b(conversion|conversions|funnel|revenue|payment|payments|traffic|pageviews?|signups?|events?|active users?|sessions?|retention|churn|pipeline|deals?|calls?|transcripts?|sentiment|themes?|objections?|cohorts?|segments?|accounts?|customers?|tickets?|issues?|leads?|opportunities|mrr|arr|ctr|cvr|cac|ltv)\b/;
+  /\b(conversion|conversions|funnel|revenue|payment|payments|traffic|pageviews?|signups?|events?|active users?|sessions?|retention|churn|pipeline|deals?|calls?|transcripts?|sentiment|themes?|objections?|cohorts?|segments?|accounts?|customers?|tickets?|issues?|leads?|opportunities|usage|adoption|ai credits?|credit consumption|credits? consumed|allowance|quota|mrr|arr|ctr|cvr|cac|ltv)\b/;
+
+const ANALYTICS_DOMAIN_ENTITY_TERMS =
+  /\b(?:branch(?:es)?|branch creation|created by|creator identity)\b/;
 
 const ANALYTICS_INTENT_TERMS =
-  /\b(analy[sz]e|measure|calculate|query|report|summari[sz]e|break ?down|compare|rank|segment|forecast|trend|count|total|average|median|percent(?:age)?|rate|top|bottom|highest|lowest|how many|how much|what (?:is|are|was|were)|which|why)\b/;
+  /\b(analy[sz]e|measure|calculate|query|report|summari[sz]e|break ?down|compare|rank|segment|forecast|trend|count|total|average|median|percent(?:age)?|rate|top|bottom|highest|lowest|pull|fetch|retrieve|export|show|how many|how much|what (?:is|are|was|were)|which|why)\b/;
 
 const SOURCE_SEARCH_INTENT_TERMS =
   /\b(find|surface|search|scan|grep|review|inspect|check|look through|go find)\b/;
@@ -308,7 +311,7 @@ const ARTIFACT_DATA_INTENT =
 // a live provider data call. They should be answered from the data dictionary,
 // schema introspection tools, or the agent's knowledge of configured sources.
 const METADATA_ONLY_TERMS =
-  /\b(what (?:tables?|columns?|fields?|sources?|datasets?|metrics?|schema) (?:are|is|exist|available|do (?:we|you|i) have)|which (?:sources?|tables?|providers?|integrations?) (?:are|is) (?:connected|configured|available|set up)|list (?:the )?(?:tables?|columns?|fields?|sources?|datasets?|schemas?)|show (?:me )?(?:available|the) (?:sources?|tables?|schemas?)|what does .+ (?:mean|measure|represent|track)|how is .+ (?:defined|calculated|computed|measured)|definition of|describe (?:the )?(?:\w+\s+)?(?:table|column|schema|metric|field)|list (?:the )?columns?\s+in|what (?:is|are) (?:the )?(?:data (?:dictionary|schema)|available (?:sources?|tables?))|what (?:source|provider|table) (?:has|stores|contains))\b/;
+  /\b(what (?:tables?|columns?|fields?|sources?|datasets?|metrics?|schema) (?:are|is|exist|available|do (?:we|you|i) have)|which (?:sources?|tables?|providers?|integrations?) (?:are|is) (?:connected|configured|available|set up)|list (?:the )?(?:tables?|columns?|fields?|sources?|datasets?|schemas?)|show (?:me )?(?:available|the) (?:data )?(?:sources?|tables?|schemas?)|what does .+ (?:mean|measure|represent|track)|how is .+ (?:defined|calculated|computed|measured)|definition of|describe (?:the )?(?:\w+\s+)?(?:table|column|schema|metric|field)|list (?:the )?columns?\s+in|what (?:is|are) (?:the )?(?:data (?:dictionary|schema)|available (?:data )?(?:sources?|tables?))|what (?:source|provider|table) (?:has|stores|contains))\b/;
 
 export function looksLikeAnalyticsDataRequest(text: string): boolean {
   const requestText = stripInjectedAnalyticsGuardContext(text);
@@ -350,6 +353,14 @@ export function looksLikeAnalyticsDataRequest(text: string): boolean {
   if (METADATA_ONLY_TERMS.test(lower)) return false;
 
   if (ANALYTICS_RESULT_TERMS.test(lower)) return true;
+  if (
+    ANALYTICS_DOMAIN_ENTITY_TERMS.test(lower) &&
+    (ANALYTICS_INTENT_TERMS.test(lower) ||
+      SOURCE_SEARCH_INTENT_TERMS.test(lower) ||
+      /\bdata\b/.test(lower))
+  ) {
+    return true;
+  }
   if (
     ANALYTICS_INTENT_TERMS.test(lower) &&
     /\b(data|source|table|sql)\b/.test(lower)