@agent-native/core 0.79.6 → 0.79.9

package/corpus/core/src/server/agent-chat-plugin.ts

@@ -147,6 +147,12 @@ import {
 import { dbExecToolParameters } from "../scripts/db/tool-schemas.js";
 import { getSetting, putSetting } from "../settings/store.js";
 import { discoverAgents } from "./agent-discovery.js";
+import {
+  resolveAgentRunOwnerContext,
+  runWithAgentRunContext,
+  seedBackgroundAgentRunOwnerContext,
+  type AgentRunOwnerContext,
+} from "./agent-run-context.js";
 import {
   AGENT_TEAM_PROCESS_RUN_PATH,
   getCurrentDelegationDepth,
@@ -159,6 +165,7 @@ import {
   getBuilderBrowserConnectUrlForOwner,
   resolveBuilderBranchProjectId,
 } from "./builder-browser.js";
+import { captureError } from "./capture-error.js";
 import { captureCliOutput } from "./cli-capture.js";
 import {
   getH3App,
@@ -871,14 +878,51 @@ export function assembleA2AFinalResponse(
   toolResults: readonly A2AToolResultSummary[],
   options: A2AArtifactResponseOptions & { event?: any } = {},
 ): { responseText: string; finalText: string } {
-  const responseText = collectFinalResponseTextFromAgentEvents(events);
+  const terminalError = getA2ATerminalErrorEvent(events);
+  const responseText = collectFinalResponseTextFromAgentEvents(events, {
+    fallbackToPreToolText: !terminalError,
+  });
   const finalText = appendA2AArtifactLinks(responseText, [...toolResults], {
     baseUrl: options.baseUrl ?? resolveArtifactBaseUrl(options.event),
     includeReferencedArtifacts: true,
   });
+  if (terminalError && !finalText.trim()) {
+    throw new Error(formatA2ATerminalError(terminalError));
+  }
   return { responseText, finalText };
 }
 
+function getA2ATerminalErrorEvent(
+  events: readonly AgentChatEvent[],
+): Extract<AgentChatEvent, { type: "error" }> | null {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event.type === "clear") continue;
+    if (event.type === "done") return null;
+    if (event.type === "error") return event;
+    if (event.type === "auto_continue") {
+      return {
+        type: "error",
+        error: `Agent stopped before finishing (${event.reason}).`,
+        errorCode: event.reason,
+        recoverable: true,
+      };
+    }
+  }
+  return null;
+}
+
+function formatA2ATerminalError(
+  event: Extract<AgentChatEvent, { type: "error" }>,
+): string {
+  const parts = [
+    event.error || "Agent failed before producing a final response.",
+    event.errorCode ? `code: ${event.errorCode}` : "",
+    event.details ? `details: ${event.details}` : "",
+  ].filter(Boolean);
+  return parts.join("\n");
+}
+
 /**
  * Creates the `get-framework-context` tool. Returns detailed instructions
  * for framework capabilities that are summarized in the compact prompt.
@@ -3052,6 +3096,8 @@ In Act mode, if the user asks for generated interactive UI in chat, choose the s
 
 These are **NOT** source-code changes and do **NOT** go through \`connect-builder\`. Extensions are sandboxed mini-apps — no source files are touched, no PR is opened, no build is required. Saved extensions can be edited later via \`update-extension\`.
 
+If the app exposes native actions or instructions for dashboards, reports, analyses, charts, documents, decks, or other domain artifacts, use those app-native actions first. Choose an extension only when the user explicitly asks for an extension/custom mini-app, or when the app's native artifact format cannot faithfully express the requested interaction.
+
 Keep \`create-extension\` payloads compact enough to finish quickly. For complex extensions, create a useful working v1 first, then call \`update-extension\` with focused edits for refinements instead of trying to assemble one enormous initial tool input.
 
 Generated UI content can use appAction(), appFetch(), dbQuery(), dbExec(), extensionFetch(), extensionData, agentNative.ui.output(value, opts?), and agentNative.chat.send(...)/sendToAgentChat(...). It can receive chat inputs through slotContext/window.onSlotContext. Use agentNative.ui.output for passive current values from knobs, sliders, selections, and controls; it writes application state at \`inline-ui:<extensionId>:output\` scoped to the inline extension id returned by \`render-inline-extension\` or \`show-extension-inline\`. When the user later says "use that value", "apply the current setting", or similar, read it with \`readAppState("inline-ui:<id>:output")\` instead of asking them to send it again. Use agentNative.chat.send for visible submit/apply actions that should put a message into chat. Transient extensionData is browser-local and not agent-readable, synced, promoted, or garbage-collected; use application_state/appFetch, appAction, ui.output, or chat.send for anything the agent or app must observe. Use semantic Tailwind classes like bg-background, text-foreground, bg-primary, border-border, and text-muted-foreground so the UI inherits the parent app theme.
@@ -3079,7 +3125,7 @@ Route by what the request changes, not how it is phrased. Extensions render in t
 | Ambiguous, satisfiable either way (e.g. "give me an unread view") | \`render-inline-extension\` for chat-only, \`create-extension\` for reusable |
 </routing>
 
-Worked examples: "a widget showing unread emails grouped by sender", "a dashboard summarizing my pipeline", "a tracker for my newsletter subscriptions" → \`create-extension\`. "Add an Unread tab to the left navigation", "make the subject lines wrap", "change the inbox grouping logic", "add a field to the compose form" → \`connect-builder\`.`
+Worked examples: "a widget showing unread emails grouped by sender", "a tracker for my newsletter subscriptions", "a custom kanban board with drag-and-drop rules the app does not have" → \`create-extension\`. "Add an Unread tab to the left navigation", "make the subject lines wrap", "change the inbox grouping logic", "add a field to the compose form" → \`connect-builder\`.`
     : `### Extensions Disabled
 
 Extension creation and management tools are disabled for this app. Do not claim you can create, edit, hide, or delete Agent-Native extensions unless the template exposes its own typed action for that workflow. For requests that would otherwise be handled as an extension/widget/dashboard/calculator mini-app, explain that this app has disabled extension tools and use the app's available actions instead.`;
@@ -3088,6 +3134,8 @@ Extension creation and management tools are disabled for this app. Do not claim
 
 In Act mode, if the user asks for generated interactive UI in chat, call \`render-inline-extension\` for one-time inline controls/knobs/calculators/visualizers that do not need saving. If the user asks for an **extension**, **widget**, **dashboard**, **calculator**, or **mini-app** that should be reusable or saved, call \`create-extension\` with a self-contained Alpine.js HTML body. To load a saved extension inline, call \`show-extension-inline\`. These are NOT code changes — extensions are sandboxed mini-apps. Do not preface with "let me build…" — just call the right extension action.
 
+Use app-native artifact actions first when they exist for dashboards, reports, analyses, charts, documents, decks, or similar domain artifacts. Pick \`create-extension\` only for explicit extension/custom mini-app requests or for behavior the native artifact format cannot support.
+
 Keep the first \`create-extension\` call compact and working. If the request is complex, create the v1 first and then refine with focused \`update-extension\` edits.
 
 Generated UI can read chat inputs from slotContext/window.onSlotContext, see/update app state through appFetch/appAction, use extensionData, record passive current values through agentNative.ui.output(value, opts?), and send visible results through agentNative.chat.send(...) or sendToAgentChat(...). ui.output writes \`inline-ui:<extensionId>:output\` in application state; when the user asks to use the current slider/selection/value, read \`readAppState("inline-ui:<id>:output")\`. Transient extensionData is browser-local only, so do not rely on it for values the agent or app must observe. Use semantic Tailwind theme classes.
@@ -4994,45 +5042,13 @@ export function createAgentChatPlugin(
         });
       }
 
-      type OwnerContext = {
-        owner: string;
-        anonymous: boolean;
-        name?: string;
-      };
-      const OWNER_CONTEXT_KEY = "__agentNativeOwnerContext";
-
       // Resolve owner from the H3 event's session, with an optional
       // template-provided anonymous owner for public read-only surfaces.
-      const resolveOwnerContext = async (event: any): Promise<OwnerContext> => {
-        const eventContext = event?.context as
-          | (Record<string, unknown> & { [OWNER_CONTEXT_KEY]?: OwnerContext })
-          | undefined;
-        if (eventContext?.[OWNER_CONTEXT_KEY]) {
-          return eventContext[OWNER_CONTEXT_KEY];
-        }
-
-        const session = await getSession(event);
-        if (session?.email) {
-          const resolved = {
-            owner: session.email,
-            anonymous: false,
-            name: session.name,
-          };
-          if (eventContext) eventContext[OWNER_CONTEXT_KEY] = resolved;
-          return resolved;
-        }
-
-        const anonymousOwner = await options?.anonymousOwner?.(event);
-        if (anonymousOwner) {
-          const resolved = { owner: anonymousOwner, anonymous: true };
-          if (eventContext) eventContext[OWNER_CONTEXT_KEY] = resolved;
-          return resolved;
-        }
-
-        const { createError } = await import("h3");
-        throw createError({
-          statusCode: 401,
-          statusMessage: "Unauthenticated",
+      const resolveOwnerContext = async (
+        event: any,
+      ): Promise<AgentRunOwnerContext> => {
+        return resolveAgentRunOwnerContext(event, {
+          anonymousOwner: options?.anonymousOwner,
         });
       };
 
@@ -7749,92 +7765,17 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
       // the background worker), so both go through identical context + handler
       // selection.
       const invokeAgentChatHandler = async (event: any) => {
-        // Resolve per-request auth context
+        // Resolve per-request auth context.
         const ownerContext = await resolveOwnerContext(event);
-        const owner = ownerContext.owner;
-
-        // Resolve org ID: explicit callback > session.orgId from Better Auth
-        // > implicit org membership. Better Auth leaves session.orgId null
-        // until the user explicitly switches orgs, so a fresh signup with
-        // implicit membership (e.g. domain-matched org) would otherwise see
-        // no org-scoped credentials. getOrgContext() does the same DB lookup
-        // the /builder/status endpoint uses to decide "Connected".
-        let resolvedOrgId: string | undefined;
-        if (options?.resolveOrgId) {
-          resolvedOrgId = (await options.resolveOrgId(event)) ?? undefined;
-        } else {
-          try {
-            const session = await getSession(event);
-            resolvedOrgId = session?.orgId ?? undefined;
-          } catch {
-            // Session not available
-          }
-          if (!resolvedOrgId) {
-            try {
-              const { getOrgContext } = await import("../org/context.js");
-              const ctx = await getOrgContext(event);
-              resolvedOrgId = ctx.orgId ?? undefined;
-            } catch {
-              // org_members table may not exist yet on first boot
-            }
-          }
-        }
-        // Cookieless durable background worker: getSession()/getOrgContext()
-        // resolve from the (absent) session, so org-scoped credential resolution
-        // (the Builder engine) would miss the owner's org and resolveEngine would
-        // fall back to the anthropic default — bailing on a missing key before
-        // the worker claims its run. The owner IS known here (seeded via
-        // OWNER_CONTEXT_KEY from the run's thread), so resolve the org directly
-        // from the owner email, the same active-org logic the foreground session
-        // would yield.
-        if (!resolvedOrgId && owner) {
-          try {
-            const { resolveOrgIdForEmail } = await import("../org/context.js");
-            resolvedOrgId = (await resolveOrgIdForEmail(owner)) ?? undefined;
-          } catch {
-            // org tables unavailable — proceed without org (foreground-equivalent)
-          }
-        }
-
-        // DURABLE OWNER CONTEXT, PART 2: ORG.
-        // The cookieless `_process-run` self-dispatch (and any other background
-        // re-entry) resolves the owner from the run row, but has NO session —
-        // every org resolver above ultimately derives identity from
-        // getSession(event), so they all come back null here. That silently
-        // scopes the agent to `org_id IS NULL` rows only: it sees and writes
-        // resources outside the user's org, while the foreground UI — which
-        // carries the session cookie — resolves the real org. The result is the
-        // observed split where the agent can't list/read the same resources the
-        // UI shows and writes new rows with a null org. Resolve the org from the
-        // now-known owner email (the same active-org / membership logic
-        // getOrgContext uses, minus the session) so the agent and the UI operate
-        // over the same org-scoped data.
-        if (!resolvedOrgId && owner && !ownerContext.anonymous) {
-          try {
-            const { resolveOrgIdForEmail } = await import("../org/context.js");
-            resolvedOrgId = (await resolveOrgIdForEmail(owner)) ?? undefined;
-          } catch {
-            // org tables unavailable (first boot) — leave org unscoped
-          }
-        }
 
-        // Propagate the caller's IANA timezone from `x-user-timezone` so that
-        // tool calls made by the agent (e.g. log-meal with no explicit date)
-        // resolve "today" in the user's local timezone instead of server UTC.
-        const tzRaw = getHeader(event, "x-user-timezone");
-        const timezone =
-          typeof tzRaw === "string" &&
-          tzRaw.trim().length > 0 &&
-          tzRaw.trim().length < 64
-            ? tzRaw.trim()
-            : undefined;
-
-        return runWithRequestContext(
+        return runWithAgentRunContext(
           {
-            userEmail: owner,
-            userName: ownerContext.name,
-            orgId: resolvedOrgId,
-            timezone,
+            event,
+            ownerContext,
+            resolveOrgId: options?.resolveOrgId,
+            isBackgroundWorker: Boolean(
+              (event as any).context?.__agentChatBackgroundBody,
+            ),
           },
           () => {
             // App-rendered chat can't host direct code edits — HMR/full
@@ -7949,50 +7890,29 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
           (event as any).context = (event as any).context ?? {};
           (event as any).context.__agentChatBackgroundBody = prepared.body;
 
-          // DURABLE OWNER CONTEXT: this self-dispatch is cookieless (HMAC-only —
-          // the foreground POST carried the user's session, but this background-
-          // function invocation does not). Without a session, resolveOwnerContext()
-          // falls through to its 401 "Unauthenticated" throw and the worker dies
-          // before it can even claim the run (observed in prod as the `route_threw`
-          // diag stage — every durable run only completed via the foreground
-          // circuit-breaker's inline recovery). The run's chat thread already
-          // records the authenticated owner (written by the foreground under the
-          // signed-in user), so resolve the owner from the run row — NOT from the
-          // request body, which the HMAC does not cover and a caller could forge —
-          // and pre-seed the owner context the handler reads (resolveOwnerContext
-          // returns it before attempting any session lookup).
-          let backgroundOwner: string | null = null;
-          try {
-            const { getRunOwnerEmail } = await import("../agent/run-store.js");
-            backgroundOwner = await getRunOwnerEmail(prepared.runId);
-            if (backgroundOwner) {
-              (event as any).context[OWNER_CONTEXT_KEY] = {
-                owner: backgroundOwner,
-                anonymous: false,
-              };
-            }
-          } catch {
-            // Best-effort: if the lookup fails, resolveOwnerContext runs as before
-            // and throws its normal 401, surfaced via the route_threw diagnostic.
-          }
+          // Durable owner context: this self-dispatch is cookieless (HMAC-only).
+          // Resolve the owner from the persisted run row, never the request body,
+          // then invoke the normal handler. The shared agent-run context helper
+          // expands that owner into the same user/org AsyncLocalStorage context the
+          // foreground request uses, so credential and data scoping stay aligned.
+          await seedBackgroundAgentRunOwnerContext(event, prepared.runId);
 
           try {
-            // Run the worker INSIDE the owner's AsyncLocalStorage request context.
-            // Seeding OWNER_CONTEXT_KEY (above) only feeds getOwnerFromEvent; the
-            // engine-resolution path (detectEngineFromUserSecrets) and other
-            // owner-scoped reads use getRequestUserEmail()/getRequestOrgId(),
-            // which a cookieless background worker otherwise leaves empty. Without
-            // this, resolveEngine can't see the owner's Builder credential, falls
-            // back to the anthropic default, and — when the owner has no stored
-            // anthropic key and deploy-credential fallback is blocked — bails at
-            // the API-key check BEFORE claiming its run (the analytics durable
-            // worker's "stalls at post_model, never claims" bug).
-            const invoke = () => invokeAgentChatHandler(event);
-            return await (backgroundOwner
-              ? runWithRequestContext({ userEmail: backgroundOwner }, invoke)
-              : invoke());
+            return await invokeAgentChatHandler(event);
           } catch (err: any) {
             console.error("[agent-chat] _process-run failed:", err);
+            captureError(err, {
+              route: AGENT_CHAT_PROCESS_RUN_PATH,
+              method: getMethod(event),
+              userAgent: getHeader(event, "user-agent"),
+              tags: {
+                source: "agent-chat-bg-worker",
+                phase: "process-run",
+              },
+              extra: {
+                runId: prepared.runId,
+              },
+            });
             // DIAGNOSTIC: the worker invocation threw at the route boundary —
             // record the message so the failure cause is readable client-side.
             if (diag) {

package/corpus/core/src/server/agent-run-context.ts

@@ -0,0 +1,204 @@
+import { createError, getHeader, type H3Event } from "h3";
+
+import { resolveOrgIdForEmail, getOrgContext } from "../org/context.js";
+import { getSession } from "./auth.js";
+import {
+  runWithRequestContext,
+  type RequestContext,
+} from "./request-context.js";
+
+export type AgentRunOwnerContext = {
+  owner: string;
+  anonymous: boolean;
+  name?: string;
+};
+
+export const AGENT_RUN_OWNER_CONTEXT_KEY = "__agentNativeOwnerContext";
+
+type EventWithAgentRunContext = H3Event & {
+  context?: Record<string, unknown>;
+};
+
+type AnonymousOwnerResolver = (
+  event: H3Event,
+) => string | null | Promise<string | null>;
+
+type OrgIdResolver = (
+  event: H3Event,
+) => string | null | undefined | Promise<string | null | undefined>;
+
+function eventContext(
+  event: EventWithAgentRunContext,
+): Record<string, unknown> {
+  event.context = event.context ?? {};
+  return event.context;
+}
+
+function normalizeId(value: string | null | undefined): string | undefined {
+  return typeof value === "string" && value.trim().length > 0
+    ? value.trim()
+    : undefined;
+}
+
+function readHeaderValue(event: any, name: string): unknown {
+  try {
+    const value = getHeader(event, name);
+    if (value !== undefined && value !== null) return value;
+  } catch {
+    // Unit tests and a few framework internals pass lightweight event shims.
+  }
+
+  const headers = event?.headers;
+  if (headers && typeof headers.get === "function") {
+    return headers.get(name) ?? headers.get(name.toLowerCase()) ?? undefined;
+  }
+
+  const reqHeaders = event?.node?.req?.headers ?? event?.req?.headers;
+  if (reqHeaders && typeof reqHeaders === "object") {
+    return reqHeaders[name] ?? reqHeaders[name.toLowerCase()];
+  }
+
+  return undefined;
+}
+
+export function readAgentRunTimezone(event: H3Event): string | undefined {
+  const raw = readHeaderValue(event, "x-user-timezone");
+  const value = Array.isArray(raw) ? raw[0] : raw;
+  return typeof value === "string" &&
+    value.trim().length > 0 &&
+    value.trim().length < 64
+    ? value.trim()
+    : undefined;
+}
+
+export function seedAgentRunOwnerContext(
+  event: H3Event,
+  ownerContext: AgentRunOwnerContext,
+): AgentRunOwnerContext {
+  eventContext(event as EventWithAgentRunContext)[AGENT_RUN_OWNER_CONTEXT_KEY] =
+    ownerContext;
+  return ownerContext;
+}
+
+export async function seedBackgroundAgentRunOwnerContext(
+  event: H3Event,
+  runId: string,
+): Promise<AgentRunOwnerContext | null> {
+  try {
+    const { getRunOwnerEmail } = await import("../agent/run-store.js");
+    const owner = await getRunOwnerEmail(runId);
+    if (!owner) return null;
+    return seedAgentRunOwnerContext(event, { owner, anonymous: false });
+  } catch {
+    return null;
+  }
+}
+
+export async function resolveAgentRunOwnerContext(
+  event: H3Event,
+  options: { anonymousOwner?: AnonymousOwnerResolver } = {},
+): Promise<AgentRunOwnerContext> {
+  const ctx = eventContext(event as EventWithAgentRunContext);
+  const seeded = ctx[AGENT_RUN_OWNER_CONTEXT_KEY] as
+    | AgentRunOwnerContext
+    | undefined;
+  if (seeded) return seeded;
+
+  const session = await getSession(event);
+  if (session?.email) {
+    return seedAgentRunOwnerContext(event, {
+      owner: session.email,
+      anonymous: false,
+      name: session.name,
+    });
+  }
+
+  const anonymousOwner = await options.anonymousOwner?.(event);
+  if (anonymousOwner) {
+    return seedAgentRunOwnerContext(event, {
+      owner: anonymousOwner,
+      anonymous: true,
+    });
+  }
+
+  throw createError({
+    statusCode: 401,
+    statusMessage: "Unauthenticated",
+  });
+}
+
+export async function resolveAgentRunOrgId(options: {
+  event: H3Event;
+  ownerContext: AgentRunOwnerContext;
+  resolveOrgId?: OrgIdResolver;
+}): Promise<string | undefined> {
+  let resolvedOrgId: string | undefined;
+
+  if (options.resolveOrgId) {
+    resolvedOrgId = normalizeId(await options.resolveOrgId(options.event));
+  } else {
+    try {
+      const session = await getSession(options.event);
+      resolvedOrgId = normalizeId(session?.orgId);
+    } catch {
+      // Session not available.
+    }
+
+    if (!resolvedOrgId) {
+      try {
+        const orgContext = await getOrgContext(options.event);
+        resolvedOrgId = normalizeId(orgContext.orgId);
+      } catch {
+        // Org tables may not exist yet on first boot.
+      }
+    }
+  }
+
+  if (
+    !resolvedOrgId &&
+    options.ownerContext.owner &&
+    !options.ownerContext.anonymous
+  ) {
+    try {
+      resolvedOrgId = normalizeId(
+        await resolveOrgIdForEmail(options.ownerContext.owner),
+      );
+    } catch {
+      // Org tables may not exist yet on first boot.
+    }
+  }
+
+  return resolvedOrgId;
+}
+
+export async function resolveAgentRunRequestContext(options: {
+  event: H3Event;
+  ownerContext: AgentRunOwnerContext;
+  resolveOrgId?: OrgIdResolver;
+  isBackgroundWorker?: boolean;
+}): Promise<RequestContext> {
+  const orgId = await resolveAgentRunOrgId(options);
+  const timezone = readAgentRunTimezone(options.event);
+  return {
+    userEmail: options.ownerContext.owner,
+    userName: options.ownerContext.name,
+    orgId,
+    timezone,
+    ...(options.isBackgroundWorker
+      ? { run: { isBackgroundWorker: true } }
+      : {}),
+  };
+}
+
+export async function runWithAgentRunContext<T>(
+  options: {
+    event: H3Event;
+    ownerContext: AgentRunOwnerContext;
+    resolveOrgId?: OrgIdResolver;
+    isBackgroundWorker?: boolean;
+  },
+  fn: () => T | Promise<T>,
+): Promise<T> {
+  const requestContext = await resolveAgentRunRequestContext(options);
+  return await runWithRequestContext(requestContext, fn);
+}

package/corpus/core/src/server/credential-provider.ts

@@ -80,7 +80,7 @@ export function readDeployCredentialEnv(key: string): string | undefined {
  * key does not silently power another tenant's chat.
  */
 export function isDeployCredentialFallbackAllowed(): boolean {
-  if (process.env.NODE_ENV !== "production") return true;
+  if (!isProductionLikeRuntime()) return true;
   return isLocalDatabase();
 }
 
@@ -121,6 +121,22 @@ function isHostedWorkspaceRuntime(): boolean {
   );
 }
 
+function isProductionLikeRuntime(): boolean {
+  return (
+    process.env.NODE_ENV === "production" ||
+    /^(1|true)$/i.test(process.env.NETLIFY ?? "") ||
+    /^(1|true)$/i.test(process.env.VERCEL ?? "") ||
+    /^(1|true)$/i.test(process.env.CF_PAGES ?? "") ||
+    Boolean(
+      process.env.AWS_LAMBDA_FUNCTION_NAME ||
+      process.env.AWS_EXECUTION_ENV ||
+      process.env.FUNCTIONS_WORKER_RUNTIME ||
+      process.env.K_SERVICE ||
+      process.env.RENDER,
+    )
+  );
+}
+
 /**
  * Whether deployment-level Builder env keys may back the current request.
  *
@@ -143,18 +159,18 @@ function canUseBuilderDeployCredentialFallbackForRequest(): boolean {
   const email = getRequestUserEmail();
   if (!email) return true;
 
-  const isProduction = process.env.NODE_ENV === "production";
+  const isProductionRuntime = isProductionLikeRuntime();
   // Local dogfooding escape hatch: lets the env / root-`.env` Builder key back
   // a signed-in user so running the app locally doesn't require completing the
   // Builder connect flow first. Non-prod only.
   const localDevOptIn =
-    !isProduction &&
+    !isProductionRuntime &&
     /^(1|true)$/i.test(process.env.AGENT_NATIVE_LOCAL_BUILDER_ENV ?? "");
 
   if (isHostedWorkspaceRuntime() && !localDevOptIn) return false;
 
   // Deploy fallback is safe in non-prod or on a local/single-tenant database.
-  return !isProduction || isLocalDatabase();
+  return !isProductionRuntime || isLocalDatabase();
 }
 
 function shouldTraceCredentialResolve(): boolean {

package/corpus/templates/analytics/app/components/dashboard/SqlChart.tsx

@@ -593,8 +593,18 @@ function ChartTooltip({
     left: number;
     top: number;
   } | null>(null);
-  const items = sortTooltipPayloadItems(
-    payload?.filter((item) => item.value != null && item.value !== "") ?? [],
+  const items = useMemo(
+    () =>
+      sortTooltipPayloadItems(
+        payload?.filter((item) => item.value != null && item.value !== "") ??
+          [],
+      ),
+    [payload],
+  );
+  const portalVisible = portalPosition !== null;
+  const clearPortalPosition = useCallback(
+    () => setPortalPosition((prev) => (prev === null ? prev : null)),
+    [],
   );
 
   const labelText =
@@ -606,7 +616,7 @@ function ChartTooltip({
 
   useBrowserLayoutEffect(() => {
     if (!active || items.length === 0 || typeof window === "undefined") {
-      setPortalPosition(null);
+      clearPortalPosition();
       return;
     }
 
@@ -688,7 +698,7 @@ function ChartTooltip({
       window.removeEventListener("resize", schedule);
       window.removeEventListener("scroll", schedule, true);
     };
-  });
+  }, [active, clearPortalPosition, items.length, portalVisible]);
 
   if (!active || items.length === 0) return null;
 

package/corpus/templates/analytics/changelog/2026-06-26-session-replay-uploads-now-accept-compressed-payloads-so-lar.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-06-26
+---
+
+Session replay uploads now accept compressed payloads so larger recordings ingest more reliably.

package/corpus/templates/analytics/changelog/2026-06-26-sql-chart-tooltips-now-stay-stable-while-moving-across-dense.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-06-26
+---
+
+SQL chart tooltips now stay stable while moving across dense charts.