@agent-native/core 0.98.17 → 0.99.1

package/corpus/templates/analytics/changelog/2026-07-13-session-replay-links-now-support-cmd-click-and-middle-click-.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-13
+---
+
+Session replay links now support Cmd-click and middle-click to open in a new tab

package/corpus/templates/analytics/changelog/2026-07-13-session-replays-keep-a-visible-mac-style-cursor-over-the-vis.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-13
+---
+
+Session replays keep a visible Mac-style cursor over the visitor's recorded actions

package/corpus/templates/analytics/server/jobs/dashboard-report.ts

@@ -3,6 +3,7 @@ import { runWithRequestContext } from "@agent-native/core/server/request-context
 import { sendDashboardReportSubscription } from "../lib/dashboard-report";
 import {
   claimDueDashboardReportSubscriptions,
+  dashboardReportRetryAt,
   markDashboardReportResult,
 } from "../lib/dashboard-report-subscriptions";
 
@@ -41,22 +42,40 @@ export async function runDashboardReportsOnce(): Promise<{
     for (const sub of batch) {
       processed++;
       try {
+        const retryAt = dashboardReportRetryAt(sub);
         const result = await runWithRequestContext(
           {
             userEmail: sub.ownerEmail,
             orgId: sub.orgId ?? undefined,
           },
-          () => sendDashboardReportSubscription(sub),
+          () =>
+            sendDashboardReportSubscription(sub, {
+              skipEmailWithoutScreenshot: retryAt !== null,
+            }),
         );
         if (!result.screenshotAttached) {
           const message = result.screenshotError
             ? `Dashboard screenshot unavailable: ${result.screenshotError}`
             : "Dashboard screenshot unavailable";
+          if (retryAt && !result.emailsSent) {
+            console.error(
+              `[dashboard-report] Subscription ${sub.id} skipped sending without a screenshot, will retry:`,
+              message,
+            );
+            await markDashboardReportResult(
+              sub,
+              "error",
+              `${message} (retry scheduled)`,
+              { nextRunAt: retryAt },
+            );
+            continue;
+          }
+          failed++;
           console.error(
             `[dashboard-report] Subscription ${sub.id} sent without a screenshot:`,
             message,
           );
-          await markDashboardReportResult(sub, "success", message);
+          await markDashboardReportResult(sub, "error", message);
           continue;
         }
         await markDashboardReportResult(sub, "success");

package/corpus/templates/analytics/server/lib/dashboard-report-subscriptions.ts

@@ -158,6 +158,19 @@ function calendarDayAfter(parts: { year: number; month: number; day: number }) {
   };
 }
 
+function calendarDayBefore(parts: {
+  year: number;
+  month: number;
+  day: number;
+}) {
+  const prev = new Date(Date.UTC(parts.year, parts.month - 1, parts.day - 1));
+  return {
+    year: prev.getUTCFullYear(),
+    month: prev.getUTCMonth() + 1,
+    day: prev.getUTCDate(),
+  };
+}
+
 function zonedTimeToUtc(
   parts: { year: number; month: number; day: number },
   hour: number,
@@ -205,6 +218,47 @@ export function nextDailyRunAt(
   return candidate.toISOString();
 }
 
+export function lastDailyRunAt(
+  timeOfDay: string,
+  timeZone: string,
+  from: Date = new Date(),
+): string {
+  const [hour, minute] = assertTimeOfDay(timeOfDay).split(":").map(Number);
+  const timezone = assertTimezone(timeZone);
+  const today = getZonedParts(from, timezone);
+  let candidate = zonedTimeToUtc(today, hour, minute, timezone);
+  if (candidate.getTime() > from.getTime()) {
+    candidate = zonedTimeToUtc(
+      calendarDayBefore(today),
+      hour,
+      minute,
+      timezone,
+    );
+  }
+  return candidate.toISOString();
+}
+
+const DASHBOARD_REPORT_RETRY_WINDOW_MS = 60 * 60 * 1000;
+const DASHBOARD_REPORT_RETRY_DELAY_MS = 10 * 60 * 1000;
+
+export function dashboardReportRetryAt(
+  sub: DashboardReportSubscription,
+  now: Date = new Date(),
+): string | null {
+  if (!sub.enabled) return null;
+  try {
+    const anchor = Date.parse(lastDailyRunAt(sub.timeOfDay, sub.timezone, now));
+    if (now.getTime() - anchor < DASHBOARD_REPORT_RETRY_WINDOW_MS) {
+      return new Date(
+        now.getTime() + DASHBOARD_REPORT_RETRY_DELAY_MS,
+      ).toISOString();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 function rowToSubscription(row: any): DashboardReportSubscription {
   return {
     id: row.id,
@@ -477,6 +531,7 @@ export async function markDashboardReportResult(
   sub: DashboardReportSubscription,
   status: "success" | "error",
   error?: string,
+  options?: { nextRunAt?: string },
 ): Promise<void> {
   const now = nowIso();
   const db = getDb() as any;
@@ -486,7 +541,8 @@ export async function markDashboardReportResult(
       lastStatus: status,
       lastError: error ? error.slice(0, 500) : null,
       nextRunAt: sub.enabled
-        ? nextDailyRunAt(sub.timeOfDay, sub.timezone, new Date())
+        ? (options?.nextRunAt ??
+          nextDailyRunAt(sub.timeOfDay, sub.timezone, new Date()))
         : null,
       updatedAt: now,
     })

package/corpus/templates/analytics/server/lib/dashboard-report.ts

@@ -1,4 +1,8 @@
+import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
+import { readdir, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 import {
   getAppProductionUrl,
@@ -44,11 +48,24 @@ const DASHBOARD_REPORT_CID = "dashboard-report-snapshot";
 const LOCAL_SCREENSHOT_TIMEOUT_MS = 90_000;
 const SERVERLESS_SCREENSHOT_TIMEOUT_MS = 90_000;
 const SERVERLESS_SECOND_READY_TIMEOUT_MS = 45_000;
+const SERVERLESS_FULL_ATTEMPT_TIMEOUT_MS = 125_000;
+const SERVERLESS_LIGHTWEIGHT_ATTEMPT_TIMEOUT_MS = 85_000;
+const BROWSER_CLEANUP_TIMEOUT_MS = 10_000;
 const SCREENSHOT_VIEWPORT_PADDING = 64;
 
 type DashboardScreenshotAttempt = {
   label: "full" | "full-lightweight";
   viewport: { width: number; height: number };
+  captureScale?: number;
+  readyTimeout?: number;
+  secondReadyTimeout?: number;
+  totalTimeout?: number;
+};
+
+type LaunchedScreenshotBrowser = {
+  browser: any;
+  cleanup: () => Promise<void>;
+  newPage: () => Promise<any>;
 };
 
 function daysAgo(n: number): string {
@@ -216,14 +233,44 @@ function localChromiumExecutablePath(): string | null {
   return candidates.find((candidate) => existsSync(candidate)) ?? null;
 }
 
-async function launchScreenshotBrowser() {
+async function sweepStaleScreenshotProfiles(): Promise<void> {
+  let entries: string[];
+  try {
+    entries = await readdir(tmpdir());
+  } catch {
+    return;
+  }
+  const stale = entries
+    .filter((entry) => entry.startsWith("dashboard-report-playwright-"))
+    .slice(0, 8);
+  for (const entry of stale) {
+    const full = join(tmpdir(), entry);
+    const info = await stat(full).catch(() => null);
+    if (info && Date.now() - info.mtimeMs > 30 * 60_000) {
+      await rm(full, { recursive: true, force: true }).catch(() => {});
+    }
+  }
+}
+
+async function launchScreenshotBrowser(
+  viewport: DashboardScreenshotAttempt["viewport"],
+): Promise<LaunchedScreenshotBrowser> {
   const { chromium: playwright } = await import("playwright-core");
   const localExecutablePath = localChromiumExecutablePath();
   if (localExecutablePath) {
-    return playwright.launch({
+    const browser = await playwright.launch({
       executablePath: localExecutablePath,
       headless: true,
     });
+    return {
+      browser,
+      cleanup: async () => {},
+      newPage: () =>
+        browser.newPage({
+          viewport,
+          deviceScaleFactor: 1,
+        }),
+    };
   }
 
   if (isServerlessBrowserRuntime()) {
@@ -232,19 +279,54 @@ async function launchScreenshotBrowser() {
     const packUrl =
       process.env.DASHBOARD_REPORT_CHROMIUM_PACK_URL?.trim() ||
       DEFAULT_SERVERLESS_CHROMIUM_PACK_URL;
-    return playwright.launch({
-      args: [
-        ...chromium.args,
-        "--disable-dev-shm-usage",
-        "--disable-gpu",
-        "--hide-scrollbars",
-      ],
-      executablePath: await chromium.executablePath(packUrl),
-      headless: true,
-    });
+    await sweepStaleScreenshotProfiles();
+    const userDataDir = join(
+      tmpdir(),
+      `dashboard-report-playwright-${randomUUID()}`,
+    );
+    const cleanup = async () => {
+      await rm(userDataDir, { recursive: true, force: true }).catch((err) => {
+        console.error(
+          "[dashboard-report] Failed to clean Chromium profile:",
+          errorMessage(err),
+        );
+      });
+    };
+
+    try {
+      const browser = await playwright.launchPersistentContext(userDataDir, {
+        args: [
+          ...chromium.args,
+          "--disable-dev-shm-usage",
+          "--disable-gpu",
+          "--hide-scrollbars",
+        ],
+        deviceScaleFactor: 1,
+        executablePath: await chromium.executablePath(packUrl),
+        headless: true,
+        viewport,
+      });
+      return {
+        browser,
+        cleanup,
+        newPage: () => browser.newPage(),
+      };
+    } catch (err) {
+      await cleanup();
+      throw err;
+    }
   }
 
-  return playwright.launch({ headless: true });
+  const browser = await playwright.launch({ headless: true });
+  return {
+    browser,
+    cleanup: async () => {},
+    newPage: () =>
+      browser.newPage({
+        viewport,
+        deviceScaleFactor: 1,
+      }),
+  };
 }
 
 function screenshotTimeoutMs(): number {
@@ -350,6 +432,40 @@ async function fitViewportWidthToDashboardCapture(
   await page.waitForTimeout(250);
 }
 
+async function scaleDashboardCapture(
+  page: any,
+  scale: number | undefined,
+): Promise<void> {
+  if (!scale || scale >= 1) return;
+  await page.evaluate(`(() => {
+    const root = document.querySelector("[data-dashboard-report-capture]");
+    if (root instanceof HTMLElement) root.style.zoom = "${scale}";
+  })()`);
+  await page.waitForTimeout(250);
+}
+
+async function runBoundedBrowserCleanup(
+  label: string,
+  operation: () => Promise<void>,
+): Promise<void> {
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    await Promise.race([
+      operation(),
+      new Promise<never>((_, reject) => {
+        timeout = setTimeout(
+          () => reject(new Error(`${label} exceeded cleanup timeout`)),
+          BROWSER_CLEANUP_TIMEOUT_MS,
+        );
+      }),
+    ]);
+  } catch (err) {
+    console.error(`[dashboard-report] ${label}:`, errorMessage(err));
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
 async function captureDashboardPng(
   sub: DashboardReportSubscription,
   snapshot: ReportSnapshot,
@@ -373,13 +489,47 @@ async function captureDashboardPng(
   screenshotUrl.searchParams.set(EMBED_MODE_QUERY_PARAM, "1");
   screenshotUrl.searchParams.set(EMBED_TOKEN_QUERY_PARAM, token);
 
-  const browser = await launchScreenshotBrowser();
+  let browser: any;
+  let cleanup = async () => {};
+  let newPage = async (): Promise<any> => {
+    throw new Error("Screenshot browser did not provide a page factory");
+  };
+  let launchPromise: Promise<LaunchedScreenshotBrowser> | undefined;
+  let launchTimeout: ReturnType<typeof setTimeout> | undefined;
+  let captureStage = "launching the screenshot browser";
+  let attemptTimedOut = false;
+  const attemptTimeout = attempt.totalTimeout
+    ? setTimeout(() => {
+        attemptTimedOut = true;
+        if (browser) void browser.close().catch(() => {});
+      }, attempt.totalTimeout)
+    : null;
   try {
+    launchPromise = launchScreenshotBrowser(attempt.viewport);
+    const launched = attempt.totalTimeout
+      ? await Promise.race([
+          launchPromise,
+          new Promise<never>((_, reject) => {
+            launchTimeout = setTimeout(() => {
+              attemptTimedOut = true;
+              reject(
+                new Error(
+                  `${attempt.label} browser launch exceeded ${attempt.totalTimeout}ms`,
+                ),
+              );
+            }, attempt.totalTimeout);
+          }),
+        ])
+      : await launchPromise;
+    browser = launched.browser;
+    cleanup = launched.cleanup;
+    newPage = launched.newPage;
+    if (attemptTimedOut) {
+      throw new Error("Screenshot browser launch exceeded attempt timeout");
+    }
+
     const timeout = screenshotTimeoutMs();
-    const page = await browser.newPage({
-      viewport: attempt.viewport,
-      deviceScaleFactor: 1,
-    });
+    const page = await newPage();
     page.setDefaultTimeout(timeout);
     await page.emulateMedia({ media: "screen", colorScheme: "light" });
     await page.addInitScript(() => {
@@ -390,14 +540,24 @@ async function captureDashboardPng(
       timeout,
     });
 
+    captureStage = "waiting for the report surface";
     const capture = page.locator("[data-dashboard-report-capture]");
     await capture.waitFor({ state: "visible", timeout });
-    await waitForDashboardReportReady(page, timeout);
+    captureStage = "waiting for dashboard queries";
+    await waitForDashboardReportReady(page, attempt.readyTimeout ?? timeout);
+    captureStage = "rendering lazy dashboard panels";
     await scrollDashboardForLazyRendering(page);
-    await waitForDashboardReportReady(page, secondReadyTimeoutMs());
+    captureStage = "waiting for lazy dashboard panels";
+    await waitForDashboardReportReady(
+      page,
+      attempt.secondReadyTimeout ?? secondReadyTimeoutMs(),
+    );
 
+    captureStage = "sizing the dashboard capture";
     await fitViewportWidthToDashboardCapture(page, capture, attempt.viewport);
+    await scaleDashboardCapture(page, attempt.captureScale);
     await capture.scrollIntoViewIfNeeded();
+    captureStage = "rasterizing the dashboard PNG";
     const image = await capture.screenshot({
       type: "png",
       animations: "disabled",
@@ -406,8 +566,39 @@ async function captureDashboardPng(
       throw new Error("Dashboard screenshot was empty");
     }
     return Buffer.from(image);
+  } catch (err) {
+    if (attemptTimedOut) {
+      throw new Error(
+        `${attempt.label} capture exceeded ${attempt.totalTimeout}ms while ${captureStage}`,
+      );
+    }
+    throw new Error(`${captureStage}: ${errorMessage(err)}`);
   } finally {
-    await browser.close();
+    if (attemptTimeout) clearTimeout(attemptTimeout);
+    if (launchTimeout) clearTimeout(launchTimeout);
+    if (!browser && launchPromise) {
+      void launchPromise.then(
+        async (lateBrowser) => {
+          await runBoundedBrowserCleanup(
+            "Failed to close late screenshot browser",
+            () => lateBrowser.browser.close(),
+          );
+          await runBoundedBrowserCleanup(
+            "Failed to clean late Chromium profile",
+            lateBrowser.cleanup,
+          );
+        },
+        () => {
+          // The launch rejection was already handled by the race above.
+        },
+      );
+    }
+    if (browser) {
+      await runBoundedBrowserCleanup("Failed to close screenshot browser", () =>
+        browser.close(),
+      );
+    }
+    await runBoundedBrowserCleanup("Failed to clean Chromium profile", cleanup);
   }
 }
 
@@ -419,6 +610,11 @@ function errorMessage(err: unknown): string {
   );
 }
 
+function storedAttemptError(message: string): string {
+  const normalized = message.replace(/\s+/g, " ").trim();
+  return normalized.length > 220 ? `${normalized.slice(0, 219)}…` : normalized;
+}
+
 async function captureDashboardPngWithFallback(
   sub: DashboardReportSubscription,
   snapshot: ReportSnapshot,
@@ -427,11 +623,33 @@ async function captureDashboardPngWithFallback(
   mode: "full" | "full-lightweight" | "none";
   error?: string;
 }> {
+  const serverless = isServerlessBrowserRuntime();
   const attempts: DashboardScreenshotAttempt[] = [
-    { label: "full", viewport: { width: 1440, height: 1800 } },
-    { label: "full-lightweight", viewport: { width: 1200, height: 1400 } },
+    {
+      label: "full",
+      viewport: { width: 1440, height: 1800 },
+      captureScale: 0.85,
+      ...(serverless
+        ? {
+            secondReadyTimeout: 25_000,
+            totalTimeout: SERVERLESS_FULL_ATTEMPT_TIMEOUT_MS,
+          }
+        : {}),
+    },
+    {
+      label: "full-lightweight",
+      viewport: { width: 1200, height: 1400 },
+      captureScale: 0.7,
+      ...(serverless
+        ? {
+            readyTimeout: 55_000,
+            secondReadyTimeout: 15_000,
+            totalTimeout: SERVERLESS_LIGHTWEIGHT_ATTEMPT_TIMEOUT_MS,
+          }
+        : {}),
+    },
   ];
-  let lastError: string | undefined;
+  const errors: string[] = [];
 
   for (const attempt of attempts) {
     try {
@@ -440,15 +658,20 @@ async function captureDashboardPngWithFallback(
         mode: attempt.label,
       };
     } catch (err) {
-      lastError = errorMessage(err);
+      const attemptError = errorMessage(err);
+      errors.push(`${attempt.label}: ${storedAttemptError(attemptError)}`);
       console.error(
         `[dashboard-report] ${attempt.label} screenshot failed for subscription ${sub.id}:`,
-        lastError,
+        attemptError,
       );
     }
   }
 
-  return { png: null, mode: "none", error: lastError };
+  return {
+    png: null,
+    mode: "none",
+    ...(errors.length ? { error: errors.join(" | ") } : {}),
+  };
 }
 
 function reportDate(snapshot: ReportSnapshot): string {
@@ -518,13 +741,17 @@ function reportFilename(title: string): string {
 
 export async function sendDashboardReportSubscription(
   sub: DashboardReportSubscription,
-  options: { requireScreenshot?: boolean } = {},
+  options: {
+    requireScreenshot?: boolean;
+    skipEmailWithoutScreenshot?: boolean;
+  } = {},
 ): Promise<{
   dashboardUrl: string;
   recipientCount: number;
   screenshotAttached: boolean;
   screenshotMode: "full" | "full-lightweight" | "none";
   screenshotError?: string;
+  emailsSent: boolean;
 }> {
   const snapshot = await collectReportSnapshot(sub);
   const capture = await captureDashboardPngWithFallback(sub, snapshot);
@@ -535,6 +762,16 @@ export async function sendDashboardReportSubscription(
         : "Dashboard screenshot unavailable",
     );
   }
+  if (!capture.png && options.skipEmailWithoutScreenshot) {
+    return {
+      dashboardUrl: snapshot.dashboardUrl,
+      recipientCount: sub.recipients.length,
+      screenshotAttached: false,
+      screenshotMode: capture.mode,
+      emailsSent: false,
+      ...(capture.error ? { screenshotError: capture.error } : {}),
+    };
+  }
   const screenshotAttached = Boolean(capture.png);
   const html = renderReportEmailHtml(snapshot, { screenshotAttached });
   const text = renderReportText(snapshot, { screenshotAttached });
@@ -565,6 +802,7 @@ export async function sendDashboardReportSubscription(
     recipientCount: sub.recipients.length,
     screenshotAttached,
     screenshotMode: capture.mode,
+    emailsSent: true,
     ...(capture.error ? { screenshotError: capture.error } : {}),
   };
 }

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

@@ -1846,12 +1846,38 @@ export async function saveDashboardView(
     orgId: ctx.orgId ?? undefined,
   });
   const db = getDb() as any;
-  const id = view.id ?? nanoidFallback();
+  let id = view.id ?? nanoidFallback();
+  let existing = false;
   if (view.id) {
+    const [existingRow] = await db
+      .select({
+        id: schema.dashboardViews.id,
+        dashboardId: schema.dashboardViews.dashboardId,
+      })
+      .from(schema.dashboardViews)
+      .where(eq(schema.dashboardViews.id, view.id))
+      .limit(1);
+    if (existingRow?.dashboardId === dashboardId) {
+      existing = true;
+    } else if (existingRow) {
+      // View ids are generated from names in the browser but remain globally
+      // primary-keyed for backwards compatibility. Avoid colliding with a
+      // same-named view on another dashboard instead of updating that row or
+      // returning a raw unique-constraint 500.
+      id = nanoidFallback();
+    }
+  }
+
+  if (existing) {
     await db
       .update(schema.dashboardViews)
       .set({ name: view.name, filters: JSON.stringify(view.filters) })
-      .where(eq(schema.dashboardViews.id, id));
+      .where(
+        and(
+          eq(schema.dashboardViews.id, id),
+          eq(schema.dashboardViews.dashboardId, dashboardId),
+        ),
+      );
   } else {
     await db.insert(schema.dashboardViews).values({
       id,
@@ -1864,7 +1890,15 @@ export async function saveDashboardView(
   const [row] = await db
     .select()
     .from(schema.dashboardViews)
-    .where(eq(schema.dashboardViews.id, id));
+    .where(
+      and(
+        eq(schema.dashboardViews.id, id),
+        eq(schema.dashboardViews.dashboardId, dashboardId),
+      ),
+    );
+  if (!row) {
+    throw new Error("Dashboard view was not persisted");
+  }
   const dash = await getDashboard(dashboardId, ctx);
   if (dash) {
     recordScopedChange(
@@ -1891,7 +1925,12 @@ export async function deleteDashboardView(
   const db = getDb() as any;
   await db
     .delete(schema.dashboardViews)
-    .where(eq(schema.dashboardViews.id, viewId));
+    .where(
+      and(
+        eq(schema.dashboardViews.id, viewId),
+        eq(schema.dashboardViews.dashboardId, dashboardId),
+      ),
+    );
   const dash = await getDashboard(dashboardId, ctx);
   if (dash) {
     recordScopedChange(

package/corpus/templates/analytics/server/lib/error-capture.ts

@@ -547,6 +547,27 @@ export interface RawExceptionInput {
   breadcrumbs: unknown[];
 }
 
+/**
+ * Browser request cancellation is expected during navigation and query
+ * invalidation. Keep the first-party issue store aligned with the client
+ * Sentry filter, while preserving other AbortError failures for triage.
+ */
+export function isBenignBrowserAbortException(
+  input: Pick<RawExceptionInput, "type" | "message">,
+): boolean {
+  const exceptionType = input.type.trim().toLowerCase();
+  const exceptionValue = input.message.trim().toLowerCase();
+  return (
+    exceptionValue === "the user aborted a request." ||
+    exceptionValue === "signal is aborted without reason" ||
+    exceptionValue === "aborterror: the user aborted a request." ||
+    exceptionValue === "aborterror: signal is aborted without reason" ||
+    (exceptionType === "aborterror" &&
+      (exceptionValue.includes("the user aborted a request") ||
+        exceptionValue.includes("signal is aborted without reason")))
+  );
+}
+
 function nowIso(): string {
   return new Date().toISOString();
 }
@@ -930,11 +951,9 @@ export async function ingestAnalyticsExceptionEvents(
   let ingested = 0;
   for (const item of events) {
     try {
-      await ingestException(
-        scope,
-        extractExceptionInput(item.properties),
-        item.derived,
-      );
+      const raw = extractExceptionInput(item.properties);
+      if (isBenignBrowserAbortException(raw)) continue;
+      await ingestException(scope, raw, item.derived);
       ingested += 1;
     } catch (error) {
       console.warn("[error-capture] Failed to ingest exception event:", error);

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

@@ -239,6 +239,11 @@ export function realDataFinalGuard(
     // actual query. One corrective turn was enough for Sonnet but caused Luna
     // to hit the fallback before it reached the query.
     maxRetries: 2,
+    // The first request may use the compact starter catalog. A corrective
+    // retry must be able to reach the real source action directly; otherwise
+    // some model families spend the retry on tool-search narration and hit
+    // the canned fallback without ever running a query.
+    expandToolSurface: true,
   };
 }