@agent-native/core 0.98.0 → 0.98.2

package/corpus/core/src/client/settings/SettingsPanel.tsx

@@ -164,12 +164,14 @@ function SettingsSelect({
   value,
   options,
   onValueChange,
+  disabled = false,
 }: {
   label: string;
   labelAdornment?: React.ReactNode;
   value: string;
   options: SettingsSelectOption[];
   onValueChange: (value: string) => void;
+  disabled?: boolean;
 }) {
   const isPage = useSettingsSurface() === "page";
   const controlStyle = isPage ? CONTROL_STYLE_PAGE : CONTROL_STYLE;
@@ -181,10 +183,14 @@ function SettingsSelect({
         <p className={fieldLabelClass(isPage)}>{label}</p>
         {labelAdornment}
       </div>
-      <SelectPrimitive.Root value={value} onValueChange={onValueChange}>
+      <SelectPrimitive.Root
+        value={value}
+        onValueChange={onValueChange}
+        disabled={disabled}
+      >
         <SelectPrimitive.Trigger
           className={cn(
-            "flex w-full items-center justify-between rounded-md border border-border bg-background px-3 text-start text-foreground outline-none transition-colors hover:bg-accent/40 data-[placeholder]:text-muted-foreground",
+            "flex w-full items-center justify-between rounded-md border border-border bg-background px-3 text-start text-foreground outline-none transition-colors hover:bg-accent/40 data-[placeholder]:text-muted-foreground disabled:cursor-not-allowed disabled:opacity-60",
             isPage ? "h-10 text-sm" : "h-9 text-[12px]",
           )}
           aria-label={label}
@@ -624,8 +630,31 @@ function friendlyModelName(model: string): string {
     const tier = claude[1][0].toUpperCase() + claude[1].slice(1);
     return `${tier} ${claude[2]}${claude[3] ? `.${claude[3]}` : ""}`;
   }
-  if (model.startsWith("gpt-")) return `GPT-${model.slice(4)}`;
+  if (model.startsWith("gpt-")) {
+    const rest = model.slice(4);
+    const gpt = rest.match(/^(\d+)[.-](\d+)(?:[.-](.+))?$/);
+    if (gpt) {
+      const suffix = gpt[3]
+        ? ` ${gpt[3]
+            .split("-")
+            .map((part) => part[0].toUpperCase() + part.slice(1))
+            .join(" ")}`
+        : "";
+      return `GPT-${gpt[1]}.${gpt[2]}${suffix}`;
+    }
+    return `GPT-${rest}`;
+  }
   if (/^o\d/.test(model)) return model;
+  const geminiVersioned = model.match(
+    /^gemini-(\d+)-(\d+)-(.+?)(?:-preview)?$/,
+  );
+  if (geminiVersioned) {
+    const variant = geminiVersioned[3]
+      .split("-")
+      .map((part) => part[0].toUpperCase() + part.slice(1))
+      .join(" ");
+    return `Gemini ${geminiVersioned[1]}.${geminiVersioned[2]} ${variant}`;
+  }
   const gemini = model.match(/^gemini-(.+?)(?:-preview)?$/);
   if (gemini) {
     const parts = gemini[1]
@@ -682,6 +711,77 @@ function latestModelsOnly(models: string[]): string[] {
   });
 }
 
+export function AppDefaultModelField({
+  engine,
+  models,
+  value,
+  defaultModel,
+  disabled,
+  onValueChange,
+  onEnter,
+}: {
+  engine: string;
+  models: string[];
+  value: string;
+  defaultModel?: string;
+  disabled?: boolean;
+  onValueChange: (value: string) => void;
+  onEnter?: () => void;
+}) {
+  const isPage = useSettingsSurface() === "page";
+  const modelOptions: SettingsSelectOption[] = latestModelsOnly(models).map(
+    (model) => ({ value: model, label: friendlyModelName(model) }),
+  );
+
+  // Builder models are a closed catalog (and are validated server-side), so a
+  // real select keeps every available model visible even when one is already
+  // selected. Native datalists filter against the current input value, which
+  // made this field appear to contain only the active model.
+  if (engine === "builder" && modelOptions.length > 0) {
+    return (
+      <SettingsSelect
+        label="Model"
+        value={value}
+        options={modelOptions}
+        onValueChange={onValueChange}
+        disabled={disabled}
+      />
+    );
+  }
+
+  return (
+    <div className="space-y-1.5">
+      <p className={fieldLabelClass(isPage)}>Model</p>
+      <input
+        type="text"
+        list={`app-model-suggestions-${engine}`}
+        value={value}
+        disabled={disabled}
+        onChange={(event) => onValueChange(event.target.value)}
+        onKeyDown={(event) => {
+          if (event.key === "Enter") onEnter?.();
+        }}
+        placeholder={defaultModel ?? "model-id"}
+        spellCheck={false}
+        autoComplete="off"
+        className={cn(textInputClass(isPage), "disabled:opacity-60")}
+        style={isPage ? CONTROL_STYLE_PAGE : CONTROL_STYLE}
+      />
+      {modelOptions.length > 0 && (
+        <datalist id={`app-model-suggestions-${engine}`}>
+          {modelOptions.map((option) => (
+            <option
+              key={option.value}
+              value={option.value}
+              label={option.label}
+            />
+          ))}
+        </datalist>
+      )}
+    </div>
+  );
+}
+
 // ─── LLM Section ────────────────────────────────────────────────────────────
 
 interface EngineInfo {
@@ -1388,9 +1488,6 @@ function AppModelDefaultsSectionInner({
           ? `Install ${engine.installPackage ?? "the provider packages"} to use this provider`
           : "Credentials not detected yet",
     }));
-  const modelOptions: SettingsSelectOption[] = latestModelsOnly(
-    selectedEngineInfo?.supportedModels ?? [],
-  ).map((model) => ({ value: model, label: friendlyModelName(model) }));
   const hasPendingChange =
     !!settings &&
     settings.canUpdate &&
@@ -1536,38 +1633,20 @@ function AppModelDefaultsSectionInner({
                 }}
               />
 
-              <div className="space-y-1.5">
-                <p className={fieldLabelClass(isPage)}>Model</p>
-                <input
-                  type="text"
-                  list={`app-model-suggestions-${selectedEngine}`}
-                  value={selectedModel}
-                  disabled={!settings.canUpdate || saving}
-                  onChange={(event) => {
-                    setSelectedModel(event.target.value);
-                    setError(null);
-                  }}
-                  onKeyDown={(event) => {
-                    if (event.key === "Enter" && hasPendingChange) void save();
-                  }}
-                  placeholder={selectedEngineInfo?.defaultModel ?? "model-id"}
-                  spellCheck={false}
-                  autoComplete="off"
-                  className={cn(textInputClass(isPage), "disabled:opacity-60")}
-                  style={isPage ? CONTROL_STYLE_PAGE : CONTROL_STYLE}
-                />
-                {modelOptions.length > 0 && (
-                  <datalist id={`app-model-suggestions-${selectedEngine}`}>
-                    {modelOptions.map((option) => (
-                      <option
-                        key={option.value}
-                        value={option.value}
-                        label={option.label}
-                      />
-                    ))}
-                  </datalist>
-                )}
-              </div>
+              <AppDefaultModelField
+                engine={selectedEngine}
+                models={selectedEngineInfo?.supportedModels ?? []}
+                value={selectedModel}
+                defaultModel={selectedEngineInfo?.defaultModel}
+                disabled={!settings.canUpdate || saving}
+                onValueChange={(value) => {
+                  setSelectedModel(value);
+                  setError(null);
+                }}
+                onEnter={() => {
+                  if (hasPendingChange) void save();
+                }}
+              />
 
               <div className="flex items-center gap-1.5">
                 <button

package/corpus/core/src/client/url-scrub.ts

@@ -12,6 +12,7 @@ const SENSITIVE_QUERY_PARAMS = new Set([
   "code",
   "share",
   "share_token",
+  "bridge",
 ]);
 
 export function scrubUrl(url: string | undefined): string | undefined {
@@ -26,6 +27,18 @@ export function scrubUrl(url: string | undefined): string | undefined {
         mutated = true;
       }
     }
+    if (u.hash.includes("=")) {
+      const hashParams = new URLSearchParams(u.hash.slice(1));
+      let hashMutated = false;
+      for (const key of Array.from(hashParams.keys())) {
+        if (SENSITIVE_QUERY_PARAMS.has(key.toLowerCase())) {
+          hashParams.set(key, "<redacted>");
+          mutated = true;
+          hashMutated = true;
+        }
+      }
+      if (hashMutated) u.hash = hashParams.toString();
+    }
     if (!mutated) return url;
     // If the original URL was relative, return only the path/query/fragment.
     if (u.origin === "http://placeholder.local") {

package/corpus/core/src/client/use-action.ts

@@ -28,6 +28,7 @@ import type {
 } from "@tanstack/react-query";
 
 import { agentNativePath } from "./api-path.js";
+import { getBrowserTabId } from "./browser-tab-id.js";
 import { ensureEmbedAuthFetchInterceptor } from "./embed-auth.js";
 
 const ACTION_PREFIX = agentNativePath("/_agent-native/actions");
@@ -216,6 +217,8 @@ export interface ActionFetchOptions {
   keepalive?: boolean;
   /** Pre-serialized mutation body used by the keepalive budget coordinator. */
   serializedBody?: string;
+  /** Omit the tab echo-suppression tag for imperative callers. */
+  includeRequestSource?: boolean;
 }
 
 /**
@@ -264,6 +267,14 @@ async function actionFetch<T>(
     // safe to expose: CORS allows it (see action-routes.ts) and it carries
     // no auth weight — it only narrows the caller tag.
     "X-Agent-Native-Frontend": "1",
+    ...(options?.includeRequestSource !== false
+      ? {
+          // The server copies this onto the emitted action sync event.
+          // useDbSync can then ignore the echo in this tab while other tabs
+          // still refresh.
+          "X-Request-Source": getBrowserTabId(),
+        }
+      : {}),
   };
   const tz = resolveUserTimezone();
   if (tz) headers["x-user-timezone"] = tz;
@@ -426,6 +437,7 @@ export function callAction<
   return actionFetch<R>(actionName, options.method ?? "POST", params, {
     signal: options.signal,
     timeoutMs: options.timeoutMs,
+    includeRequestSource: false,
   });
 }
 

package/corpus/core/src/client/use-agent-chat-home-handoff.ts

@@ -79,6 +79,10 @@ function isStaticAssetPath(pathname: string): boolean {
   return /\.[A-Za-z0-9]{1,12}$/.test(lastSegment);
 }
 
+function isSettingsPath(pathname: string): boolean {
+  return pathname === "/settings" || pathname.startsWith("/settings/");
+}
+
 function localPathFromAnchor(anchor: HTMLAnchorElement): string | null {
   if (!anchor.href) return null;
   try {
@@ -135,6 +139,8 @@ export function useAgentChatHomeHandoff({
 /**
  * Intercepts ordinary in-app links clicked from a full-page chat route so the
  * page chat can morph into the destination AgentSidebar and keep its thread.
+ * Settings is intentionally excluded: a user opening it keeps chat full-page.
+ * Agent-driven navigation can still opt into the handoff by marking it first.
  */
 export function useAgentChatHomeHandoffLinks({
   storageKey,
@@ -170,7 +176,8 @@ export function useAgentChatHomeHandoffLinks({
         !path ||
         matchesChatPath(pathname) ||
         isFrameworkOrApiPath(pathname) ||
-        isStaticAssetPath(pathname)
+        isStaticAssetPath(pathname) ||
+        isSettingsPath(pathname)
       ) {
         return;
       }

package/corpus/core/src/client/use-agent-engine-configured.ts

@@ -30,6 +30,7 @@ export interface UseAgentEngineConfiguredOptions {
 }
 
 const DEFAULT_STATUS_CHECK_TIMEOUT_MS = 2500;
+const UNKNOWN_STATUS_RETRY_MS = 2000;
 
 async function fetchStatusJson(
   path: string,
@@ -129,9 +130,15 @@ export async function fetchAgentEngineConfiguredState(
     (builderStatusKnown && builderStatus.configured) ||
     (engineStatusKnown && engineStatus.configured);
   if (anyConfigured) return "configured";
-  return envKeysKnown && builderStatusKnown && engineStatusKnown
-    ? "missing"
-    : "unknown";
+
+  // The engine status route is the canonical readiness check: it resolves
+  // Builder, scoped BYOK secrets, deployment credentials, and custom engines.
+  // Once it has answered `configured: false`, a slow legacy env/Builder status
+  // request must not leave the composer permissively stuck in `unknown`.
+  if (engineStatusKnown) return "missing";
+
+  // Compatibility fallback for older hosts without the canonical route.
+  return envKeysKnown && builderStatusKnown ? "missing" : "unknown";
 }
 
 /**
@@ -149,16 +156,22 @@ export function useAgentEngineConfigured(
 
   useEffect(() => {
     let cancelled = false;
+    let retryId: ReturnType<typeof setTimeout> | undefined;
     // Monotonic call counter: overlapping checks (mount + a
     // `agent-engine:configured-changed` fired right after a key is saved) can
     // resolve out of order; only the latest call may write state, or a slow
     // stale "missing" response would overwrite the fresh "configured" one.
     let requestSeq = 0;
     const check = async (options?: { missingFallback?: boolean }) => {
+      if (retryId !== undefined) {
+        clearTimeout(retryId);
+        retryId = undefined;
+      }
       const seq = ++requestSeq;
       const nextState = await fetchAgentEngineConfiguredState(enabled, options);
       if (cancelled || seq !== requestSeq) return;
       if (nextState === "unknown") {
+        retryId = setTimeout(() => void check(), UNKNOWN_STATUS_RETRY_MS);
         return;
       }
       setState(nextState);
@@ -185,6 +198,7 @@ export function useAgentEngineConfigured(
     window.addEventListener("agent-chat:missing-api-key", onMissing);
     return () => {
       cancelled = true;
+      if (retryId !== undefined) clearTimeout(retryId);
       window.removeEventListener(
         "agent-engine:configured-changed",
         onConfiguredChanged,

package/corpus/core/src/client/use-db-sync.ts

@@ -5,6 +5,7 @@ import {
   refreshDemoModeFetchInterceptor,
 } from "../demo/fetch-interceptor.js";
 import { agentNativePath } from "./api-path.js";
+import { getBrowserTabId } from "./browser-tab-id.js";
 import {
   ensureEmbedAuthFetchInterceptor,
   isEmbedAuthActive,
@@ -16,15 +17,25 @@ interface Query {
 }
 
 interface QueryClient {
-  invalidateQueries(opts?: {
+  invalidateQueries(
+    opts?: {
+      queryKey?: string[];
+      predicate?: (query: Query) => boolean;
+    },
+    options?: { cancelRefetch?: boolean },
+  ): unknown;
+  isFetching?(filters?: {
     queryKey?: string[];
     predicate?: (query: Query) => boolean;
-  }): void;
+  }): number;
 }
 
 const POLL_ABORT_MIN_MS = 10_000;
-const SSE_FALLBACK_INTERVAL_MS = 15_000;
-const IDLE_POLL_INTERVAL_MS = 15_000;
+// SSE delivers changes immediately in the normal path. The poll is a
+// cross-process/serverless safety net, so an idle tab should not bill the host
+// four times per minute forever. Focus and active agent work still poll now.
+const SSE_FALLBACK_INTERVAL_MS = 60_000;
+const IDLE_POLL_INTERVAL_MS = 60_000;
 const POLL_AUTH_FAILURE_COOLDOWN_MS = 60_000;
 /**
  * Max cadence for SSE/poll-driven query invalidation in `useDbSync`. Events
@@ -356,7 +367,7 @@ class SyncTransport {
     // full cadence. Resets on the first successful poll.
     const delay =
       this.consecutiveFailures > 0
-        ? Math.min(base * 2 ** Math.min(this.consecutiveFailures, 5), 30_000)
+        ? Math.min(base * 2 ** Math.min(this.consecutiveFailures, 5), 300_000)
         : base;
     this.timer = setTimeout(() => {
       this.timer = null;
@@ -675,7 +686,7 @@ export function subscribeSyncEvents(
  * @param options.onEvent - Optional callback for each change event
  * @param options.interval - Poll interval in ms. Default: 2000
  * @param options.fallbackInterval - Poll interval while SSE is connected.
- *   Default: 15000
+ *   Default: 60000
  * @param options.pauseWhenHidden - Pause polling while the tab is hidden.
  *   Default: true
  * @param options.ignoreSource - Skip events whose `requestSource` matches this
@@ -798,9 +809,15 @@ export function useDbSync(
 
     function invalidateForEvents(events: SyncEvent[]) {
       const ignore = ignoreSourceRef.current;
-      const relevant = ignore
-        ? events.filter((e) => e.requestSource !== ignore)
-        : events;
+      const ownBrowserSource = getBrowserTabId();
+      const relevant = events.filter(
+        (event) =>
+          !(
+            event.source === "action" &&
+            event.requestSource === ownBrowserSource
+          ) &&
+          (!ignore || event.requestSource !== ignore),
+      );
       const suppressedActions = new Set(
         suppressActionInvalidationForRef.current ?? [],
       );
@@ -838,18 +855,43 @@ export function useDbSync(
       const invalidating = relevant.filter((e) => e.source !== "awareness");
 
       if (invalidating.length > 0 && queryClient) {
+        // Sync events describe completed writes. If a matching read is already
+        // in flight, let it finish instead of aborting and immediately
+        // launching the same request again. Repeated action events otherwise
+        // turn a slow endpoint into a cancel/restart loop that never settles.
+        const invalidateWithoutCancel = (filters?: {
+          queryKey?: string[];
+          predicate?: (query: Query) => boolean;
+        }) => {
+          const needsTrailingRefresh =
+            (queryClient.isFetching?.(filters) ?? 0) > 0;
+          const completion = queryClient.invalidateQueries(filters, {
+            cancelRefetch: false,
+          });
+          // TanStack Query deliberately leaves an in-flight fetch alone when
+          // cancelRefetch is false. Queue one post-settlement invalidation so
+          // a write that landed after that read began cannot be cleared as
+          // fresh by the older response.
+          if (needsTrailingRefresh && completion instanceof Promise) {
+            void completion.then(
+              () => queryClient.invalidateQueries(filters),
+              () => {},
+            );
+          }
+        };
         const hasActionEvent = invalidating.some(
           (evt) => evt.source === "action" && !isSuppressedActionEvent(evt),
         );
         if (hasActionEvent) {
-          // Custom apps frequently start with raw `useQuery` calls before
-          // graduating to `useActionQuery` or source-versioned query keys.
-          // A successful mutating action is the core "agent changed app data"
-          // signal, so refresh active queries broadly as a compatibility
-          // safety net. Other event sources stay targeted to avoid request
-          // storms from noisy domain-specific writes.
+          // Action-backed reads share the ["action"] prefix. Keep the default
+          // refresh targeted to those queries; invalidating every active query
+          // makes one agent write fan out across unrelated provider reads,
+          // dashboards, and background status checks. Older apps that still
+          // need broad compatibility can opt in with a predicate.
           const predicate = actionInvalidatePredicateRef.current;
-          queryClient.invalidateQueries(predicate ? { predicate } : undefined);
+          invalidateWithoutCancel(
+            predicate ? { predicate } : { queryKey: ["action"] },
+          );
         }
 
         // Framework-level invalidate: a small, fixed list of query-key
@@ -880,32 +922,40 @@ export function useDbSync(
           const hasDataChangingEvent = invalidating.some(
             (evt) => evt.source !== "app-state",
           );
-          // The broad action invalidate above already covers every fixed
-          // framework prefix. Re-invalidating ["action"] immediately after it
-          // cancels/restarts the same active reads and creates a duplicate
-          // request wave. Keep the fixed-prefix pass for non-action sources;
-          // action batches get exactly one compatibility invalidation.
-          if (hasDataChangingEvent && !hasActionEvent) {
-            queryClient.invalidateQueries({ queryKey: ["action"] });
-            queryClient.invalidateQueries({ queryKey: ["extension"] });
-            queryClient.invalidateQueries({ queryKey: ["extensions"] });
-            queryClient.invalidateQueries({ queryKey: ["extension-slots"] });
-            queryClient.invalidateQueries({ queryKey: ["slot-installs"] });
-            queryClient.invalidateQueries({ queryKey: ["slot-available"] });
-            queryClient.invalidateQueries({ queryKey: ["tool"] });
-            queryClient.invalidateQueries({ queryKey: ["tools"] });
+          if (hasDataChangingEvent) {
+            const hasFrameworkPrefixEvent = invalidating.some((evt) =>
+              ["extensions", "extension", "tool", "tools", "slots"].includes(
+                evt.source ?? "",
+              ),
+            );
+            // The action-specific invalidation above already refreshed
+            // ["action"]. A mixed action + extension/tool batch still needs
+            // the independent framework prefixes, while pure action batches
+            // retain their narrow storm-resistant invalidation.
+            if (!hasActionEvent) {
+              invalidateWithoutCancel({ queryKey: ["action"] });
+            }
+            if (!hasActionEvent || hasFrameworkPrefixEvent) {
+              invalidateWithoutCancel({ queryKey: ["extension"] });
+              invalidateWithoutCancel({ queryKey: ["extensions"] });
+              invalidateWithoutCancel({ queryKey: ["extension-slots"] });
+              invalidateWithoutCancel({ queryKey: ["slot-installs"] });
+              invalidateWithoutCancel({ queryKey: ["slot-available"] });
+              invalidateWithoutCancel({ queryKey: ["tool"] });
+              invalidateWithoutCancel({ queryKey: ["tools"] });
+            }
           }
           if (invalidating.some((evt) => evt.source === "app-state")) {
-            queryClient.invalidateQueries({ queryKey: ["app-state"] });
+            invalidateWithoutCancel({ queryKey: ["app-state"] });
           }
           if (hasAppStateEvent(invalidating, "navigate")) {
-            queryClient.invalidateQueries({ queryKey: ["navigate-command"] });
+            invalidateWithoutCancel({ queryKey: ["navigate-command"] });
           }
           if (hasAppStateEvent(invalidating, "show-questions")) {
-            queryClient.invalidateQueries({ queryKey: ["show-questions"] });
+            invalidateWithoutCancel({ queryKey: ["show-questions"] });
           }
           if (hasAppStateEvent(invalidating, "__set_url__")) {
-            queryClient.invalidateQueries({ queryKey: ["__set_url__"] });
+            invalidateWithoutCancel({ queryKey: ["__set_url__"] });
           }
         }
       }

package/corpus/core/src/client/use-demo-mode-status.ts

@@ -0,0 +1,44 @@
+import { useQuery } from "@tanstack/react-query";
+
+import { agentNativePath } from "./api-path.js";
+import { useChangeVersion } from "./use-change-version.js";
+
+interface DemoModeStatusResponse {
+  enabled?: boolean;
+  forced?: boolean;
+}
+
+export interface DemoModeStatus {
+  enabled: boolean;
+  forced: boolean;
+  isLoading: boolean;
+}
+
+const DEMO_STATUS_URL = agentNativePath("/_agent-native/demo/status");
+
+/**
+ * Reads the effective Demo mode status for the current user. The shared
+ * change-version stream advances after Demo mode application state changes,
+ * so mounted consumers refresh without polling or duplicating the route call.
+ */
+export function useDemoModeStatus(): DemoModeStatus {
+  const demoModeVersion = useChangeVersion("app-state:demo-mode");
+
+  const { data, isLoading } = useQuery({
+    queryKey: ["agent-native", "demo-mode", demoModeVersion],
+    queryFn: async () => {
+      const res = await fetch(DEMO_STATUS_URL, {
+        credentials: "same-origin",
+      });
+      if (!res.ok) return null;
+      return (await res.json()) as DemoModeStatusResponse | null;
+    },
+    staleTime: Infinity,
+  });
+
+  return {
+    enabled: data?.enabled === true,
+    forced: data?.forced === true,
+    isLoading,
+  };
+}

package/corpus/core/src/client/use-pausing-interval.ts

@@ -17,9 +17,19 @@ export function usePausingInterval(
   useEffect(() => {
     if (pollMs <= 0) return;
     let id: ReturnType<typeof setInterval> | null = null;
+    let running = false;
     const isHidden = () => typeof document !== "undefined" && document.hidden;
+    const run = async () => {
+      if (running) return;
+      running = true;
+      try {
+        await callback();
+      } finally {
+        running = false;
+      }
+    };
     const start = () => {
-      if (id == null) id = setInterval(callback, pollMs);
+      if (id == null) id = setInterval(() => void run(), pollMs);
     };
     const stop = () => {
       if (id != null) {
@@ -29,7 +39,7 @@ export function usePausingInterval(
     };
 
     if (!pauseWhenHidden) {
-      callback();
+      void run();
       start();
       return () => stop();
     }
@@ -38,12 +48,12 @@ export function usePausingInterval(
       if (document.hidden) {
         stop();
       } else {
-        callback();
+        void run();
         start();
       }
     };
     if (!isHidden()) {
-      callback();
+      void run();
       start();
     }
     document.addEventListener("visibilitychange", onVisibility);

package/corpus/core/src/integrations/scope-store.ts

@@ -216,7 +216,7 @@ function serviceOwnerForScope(
 
 function authorizationSql(alias = ""): string {
   const prefix = alias ? `${alias}.` : "";
-  return `((${prefix}org_id = ? AND ? IS NOT NULL) OR (${prefix}org_id IS NULL AND ${prefix}owner_email = ?))`;
+  return `((${prefix}org_id = ? AND CAST(? AS TEXT) IS NOT NULL) OR (${prefix}org_id IS NULL AND ${prefix}owner_email = ?))`;
 }
 
 function authorizationArgs(

package/corpus/core/src/integrations/usage-budget-store.ts

@@ -232,7 +232,7 @@ function requirePeriod(
 
 function authorizationSql(alias = ""): string {
   const prefix = alias ? `${alias}.` : "";
-  return `((${prefix}subject_type = 'user' AND ${prefix}owner_email = ?) OR (${prefix}subject_type <> 'user' AND ((${prefix}org_id = ? AND ? IS NOT NULL) OR (${prefix}org_id IS NULL AND ${prefix}owner_email = ?))))`;
+  return `((${prefix}subject_type = 'user' AND ${prefix}owner_email = ?) OR (${prefix}subject_type <> 'user' AND ((${prefix}org_id = ? AND CAST(? AS TEXT) IS NOT NULL) OR (${prefix}org_id IS NULL AND ${prefix}owner_email = ?))))`;
 }
 
 function authorizationArgs(