@agent-native/core 0.131.9 → 0.132.0

package/src/deploy/build.ts

@@ -30,7 +30,7 @@ import {
   AGENT_BACKGROUND_PROCESSOR_ROUTE,
   AGENT_BACKGROUND_PROCESSOR_ROUTE_FIELD,
   AGENT_CHAT_PROCESS_RUN_PATH,
-  isDurableBackgroundFlagEnabled,
+  isDurableBackgroundFlagExplicitlyDisabled,
 } from "../agent/durable-background.js";
 import {
   INTEGRATION_RECOVERY_RUNTIME_MARKER,
@@ -2576,29 +2576,14 @@ export function findInstalledResvgPackages(
 
 /**
  * Deploy-time gate for emitting the second `-background` Netlify function.
- * Reads the same env flag the runtime gate uses
- * (`AGENT_CHAT_DURABLE_BACKGROUND`).
- *
- * DEFAULT-OFF (opt-in). It IS the runtime gate's flag parse
- * (`isDurableBackgroundFlagEnabled`), so the two can no longer drift:
- * unset/empty/unknown means DISABLED; an app opts IN
- * only with an explicit truthy value (`true`/`1`/`yes`/`on`). A premature
- * fleet-wide default-on caused real-user incidents (2026-06-24) before the
- * async worker path was proven, so durable is opt-in until verified live. This
- * gate is what emits the 15-min `-background` function so the `_process-run`
- * dispatch lands on it (async 202 → the worker runs with the real 15-min budget
- * → its ~13-min soft-timeout fits). The deploy gate and runtime gate MUST agree:
- * if the deploy emitted no `-background` function but the runtime still routed
- * the worker into the ~13-min timeout regime, the worker would overshoot the
- * ~60s synchronous wall and re-dispatch in a loop. (The runtime now also guards
- * the ~13-min budget on the real function name via `isInBackgroundFunctionRuntime`,
- * so a missing emit does not loop.) A missing emit is NOT benign, though: the
- * app then runs every turn on the ~60s synchronous wall for the life of the
- * deploy, so an opted-in build that cannot emit the function FAILS rather than
- * warning.
+ * Netlify deploys are default-on; an explicit falsy
+ * `AGENT_CHAT_DURABLE_BACKGROUND` value opts out. This is called only from the
+ * Netlify preset, so non-Netlify builds remain unaffected. The gate and runtime
+ * default must agree: otherwise the runtime could target a worker that the
+ * deploy did not emit.
  */
 export function isDurableBackgroundDeployEnabled(): boolean {
-  return isDurableBackgroundFlagEnabled();
+  return !isDurableBackgroundFlagExplicitlyDisabled();
 }
 
 /**
@@ -2649,9 +2634,15 @@ export function emitSingleTemplateNetlifyKeepWarmFunction(
   // dispatch (18.4s observed to reach the agent loop). A POST with no runId is
   // rejected by the `_process-run` route before any DB work, so this only keeps
   // the container alive.
-  const backgroundWarmPath = isDurableBackgroundEmitRequired()
-    ? JSON.stringify(AGENT_BACKGROUND_FUNCTION_URL_PATH)
-    : "null";
+  const backgroundEntryPath = path.join(
+    internalDir,
+    AGENT_BACKGROUND_FUNCTION_NAME,
+    `${AGENT_BACKGROUND_FUNCTION_NAME}.mjs`,
+  );
+  const backgroundWarmPath =
+    isDurableBackgroundEmitRequired() && fs.existsSync(backgroundEntryPath)
+      ? JSON.stringify(AGENT_BACKGROUND_FUNCTION_URL_PATH)
+      : "null";
   const entry = `const HEALTH_PATH = "/_agent-native/health";
 const BACKGROUND_WARM_PATH = ${backgroundWarmPath};
 const REQUEST_TIMEOUT_MS = 25_000;
@@ -4148,14 +4139,12 @@ export default bundle;
   }
 
   if (preset === "netlify") {
-    emitSingleTemplateNetlifyKeepWarmFunction(cwd);
-
-    // Durable background agent runs (default-OFF / opt-in; enable with a truthy
-    // AGENT_CHAT_DURABLE_BACKGROUND). Additive ONLY: emits a SECOND Netlify
-    // function whose name ends in `-background` re-exporting the same handler
-    // bundle, so the chat `_process-run` POST lands on Netlify's async (15-min)
-    // function. When not opted in this is a no-op and the single-function
-    // deploy is byte-for-byte unchanged.
+    // Durable background agent runs are default-on for Netlify; a falsy
+    // AGENT_CHAT_DURABLE_BACKGROUND value opts out. Additive ONLY: emits a
+    // SECOND Netlify function whose name ends in `-background` re-exporting the
+    // same handler bundle, so the chat `_process-run` POST lands on Netlify's
+    // async (15-min) function. When opted out this is a no-op and the
+    // single-function deploy is byte-for-byte unchanged.
     // NOT wrapped in try/catch: this block only runs when the runtime depends
     // on the function, and a swallowed failure ships an app that loses the
     // background budget for the life of the deploy with nothing in the log.
@@ -4163,6 +4152,10 @@ export default bundle;
       emitSingleTemplateNetlifyBackgroundFunction(cwd);
     }
 
+    // Emit keep-warm after the background artifact so it only pings a function
+    // that this build actually produced.
+    emitSingleTemplateNetlifyKeepWarmFunction(cwd);
+
     if (isIntegrationDurableDispatchDeployEnabled()) {
       try {
         emitSingleTemplateNetlifyIntegrationRecoveryFunction(cwd);

package/src/feature-flags/store.ts

@@ -89,11 +89,16 @@ export async function getFeatureFlagRules(
   if (!getFeatureFlagDefinition(key)) return defaultFeatureFlagRules();
   // An organization-specific rule overrides the global rule. The fallback is
   // what makes global exact-org targeting meaningful for callers in an org.
-  const stored = scope.orgId?.trim()
-    ? ((await getOrgSetting(scope.orgId, settingKey(key))) ??
-      (await getSetting(settingKey(key))))
-    : await getSetting(settingKey(key));
-  return normalizeFeatureFlagRules(stored);
+  // Most flags have no org override, so `??` made the common path two serial
+  // round trips; both settings rows are independent, so read them together.
+  const orgId = scope.orgId?.trim();
+  if (!orgId)
+    return normalizeFeatureFlagRules(await getSetting(settingKey(key)));
+  const [orgStored, globalStored] = await Promise.all([
+    getOrgSetting(orgId, settingKey(key)),
+    getSetting(settingKey(key)),
+  ]);
+  return normalizeFeatureFlagRules(orgStored ?? globalStored);
 }
 
 /**

package/src/integrations/a2a-continuations-store.ts

@@ -777,6 +777,17 @@ export async function recoverDueA2AContinuationIds(
   const receiptFilter = confirmedDeliveryOnly
     ? " AND terminal_delivery_confirmed_at IS NOT NULL"
     : "";
+  // The two lease resets below and the due SELECT all only ever touch rows in
+  // these three statuses, so one probe short-circuits all three. Without it the
+  // 60s retry job pays two blind UPDATE round trips per app forever on a queue
+  // that has been empty since boot.
+  const live = await client.execute({
+    sql: `SELECT id FROM integration_a2a_continuations
+          WHERE status IN ('pending', 'processing', 'delivering')${taskFilter}${receiptFilter}
+          LIMIT 1`,
+    args: [...taskArgs],
+  });
+  if ((live.rows?.length ?? 0) === 0) return [];
   // If a processor dies after a provider receipt, retry history-only custody
   // as soon as its short follow-up deadline passes. A pre-receipt delivery
   // claim retains the longer stale cutoff before an at-least-once resend.

package/src/integrations/config-store.ts

@@ -33,6 +33,17 @@ async function ensureTable(): Promise<void> {
   return _initPromise;
 }
 
+/**
+ * Bumped on every in-process config write. Pollers that back off while their
+ * integration is disabled watch this so enabling one takes effect on the next
+ * tick instead of at the end of their backoff window.
+ */
+let _configWriteEpoch = 0;
+
+export function integrationConfigWriteEpoch(): number {
+  return _configWriteEpoch;
+}
+
 export interface IntegrationConfig {
   platform: string;
   configKey: string;
@@ -88,6 +99,7 @@ export async function saveIntegrationConfig(
       Date.now(),
     ],
   });
+  _configWriteEpoch += 1;
 }
 
 /**
@@ -103,6 +115,7 @@ export async function deleteIntegrationConfig(
     sql: `DELETE FROM integration_configs WHERE platform = ? AND config_key = ?`,
     args: [platform, configKey],
   });
+  _configWriteEpoch += 1;
 }
 
 /**

package/src/integrations/google-docs-poller.ts

@@ -27,7 +27,11 @@ import {
   listChanges,
   listDocComments,
 } from "./adapters/google-docs.js";
-import { getIntegrationConfig, saveIntegrationConfig } from "./config-store.js";
+import {
+  getIntegrationConfig,
+  integrationConfigWriteEpoch,
+  saveIntegrationConfig,
+} from "./config-store.js";
 import { getThreadMapping, saveThreadMapping } from "./thread-mapping-store.js";
 import type { IncomingMessage } from "./types.js";
 
@@ -634,14 +638,34 @@ export async function startGoogleDocsPoller(
   }
 }
 
+/** Backoff for the config probe while google-docs is disabled. */
+const DISABLED_CONFIG_RECHECK_MS = 5 * 60 * 1000;
+
 function startPollLoop(
   options: GoogleDocsPollerOptions,
   intervalMs: number,
 ): void {
+  let disabledUntil = 0;
+  let disabledAtConfigWriteEpoch = -1;
+
   async function poll() {
     try {
+      // The loop starts even when google-docs was never configured (so it picks
+      // up a later enable), which used to mean one `integration_configs` read
+      // every 30s per app forever. While disabled, re-read only every
+      // DISABLED_CONFIG_RECHECK_MS — or immediately after any in-process config
+      // write, so enabling the integration still takes effect on the next tick.
+      const epoch = integrationConfigWriteEpoch();
+      if (Date.now() < disabledUntil && epoch === disabledAtConfigWriteEpoch) {
+        return;
+      }
       const config = await getIntegrationConfig(PLATFORM);
-      if (!config?.configData?.enabled) return;
+      if (!config?.configData?.enabled) {
+        disabledUntil = Date.now() + DISABLED_CONFIG_RECHECK_MS;
+        disabledAtConfigWriteEpoch = epoch;
+        return;
+      }
+      disabledUntil = 0;
       await processChanges(options);
     } catch (err) {
       // Unwrap ErrorEvent (Neon WS driver emits these on network failure) so logs show the real cause

package/src/mcp-client/routes.ts

@@ -32,7 +32,7 @@ import { getSession } from "../server/auth.js";
 import { getH3App } from "../server/framework-request-handler.js";
 import { readBody } from "../server/h3-helpers.js";
 import { runWithRequestContext } from "../server/request-context.js";
-import { getAllSettings } from "../settings/store.js";
+import { getAllSettings, getSettingsEmitter } from "../settings/store.js";
 import {
   areBuiltinMcpCapabilitiesSupported,
   BUILTIN_MCP_CAPABILITIES,
@@ -291,6 +291,13 @@ function sortedConfigSignature(config: McpConfig | null): string {
   return JSON.stringify(entries);
 }
 
+/**
+ * How long the refresh may skip the settings read on the strength of "no
+ * in-process settings write since the last one". Bounds how stale a remote MCP
+ * server list added by ANOTHER process can be.
+ */
+const MCP_CONFIG_REFRESH_BACKSTOP_MS = 5 * 60 * 1000;
+
 function mcpConfigRefreshIntervalMs(): number {
   const raw = process.env.AGENT_NATIVE_MCP_CONFIG_REFRESH_MS;
   if (raw?.trim() === "0") return 0;
@@ -307,8 +314,24 @@ export function startMcpConfigRefresh(
 
   let currentSignature = sortedConfigSignature(manager.getConfig());
   let refreshing = false;
+  // `buildMergedConfig` reads the entire settings table just to diff a
+  // signature, which on an idle app is a full-table round trip every minute
+  // forever. Only pay it when an in-process settings write says something might
+  // have changed, plus a periodic backstop for writes from another process.
+  let settingsDirty = true;
+  let lastFullRefresh = 0;
+  const markDirty = () => {
+    settingsDirty = true;
+  };
+  getSettingsEmitter().on("settings", markDirty);
   const refresh = async () => {
     if (refreshing) return;
+    if (
+      !settingsDirty &&
+      Date.now() - lastFullRefresh < MCP_CONFIG_REFRESH_BACKSTOP_MS
+    ) {
+      return;
+    }
     refreshing = true;
     try {
       const next = await buildMergedConfig();
@@ -317,7 +340,12 @@ export function startMcpConfigRefresh(
         await manager.reconfigure(next);
         currentSignature = nextSignature;
       }
+      settingsDirty = false;
+      lastFullRefresh = Date.now();
     } catch (err: any) {
+      // Keep this dirty so a transient database or manager failure is retried
+      // on the next interval instead of being hidden by the backstop window.
+      settingsDirty = true;
       console.warn(
         `[mcp-client] config refresh failed: ${err?.message ?? err}`,
       );
@@ -328,7 +356,10 @@ export function startMcpConfigRefresh(
 
   const timer = setInterval(refresh, intervalMs);
   (timer as { unref?: () => void }).unref?.();
-  return () => clearInterval(timer);
+  return () => {
+    clearInterval(timer);
+    getSettingsEmitter().off("settings", markDirty);
+  };
 }
 
 async function resolveContextForRequest(event: H3Event): Promise<{

package/src/onboarding/plugin.ts

@@ -81,30 +81,34 @@ async function serializeSteps(
   options: { preview?: boolean } = {},
 ): Promise<OnboardingStepStatus[]> {
   const steps = listOnboardingSteps();
-  const out: OnboardingStepStatus[] = [];
-  for (const step of steps) {
-    let complete = false;
-    if (!options.preview) {
-      try {
-        complete = (await step.isComplete(context)) === true;
-      } catch {
-        complete = false;
-      }
-      if (!complete) {
-        complete = await hasOverride(context.sessionId, step.id);
+  // Steps are independent of each other, and each `isComplete()` is itself a
+  // chain of credential/settings reads — walking them one at a time made this
+  // route cost the SUM of every step's round trips against a remote database
+  // instead of the slowest one. `Promise.all` preserves `steps` order.
+  return Promise.all(
+    steps.map(async (step) => {
+      let complete = false;
+      if (!options.preview) {
+        try {
+          complete = (await step.isComplete(context)) === true;
+        } catch {
+          complete = false;
+        }
+        if (!complete) {
+          complete = await hasOverride(context.sessionId, step.id);
+        }
       }
-    }
-    out.push({
-      id: step.id,
-      title: step.title,
-      description: step.description,
-      order: step.order,
-      required: step.required ?? false,
-      complete,
-      methods: step.methods,
-    });
-  }
-  return out;
+      return {
+        id: step.id,
+        title: step.title,
+        description: step.description,
+        order: step.order,
+        required: step.required ?? false,
+        complete,
+        methods: step.methods,
+      };
+    }),
+  );
 }
 
 function withOnboardingRequestContext<T>(
@@ -240,11 +244,13 @@ export function createOnboardingPlugin(
         // doesn't surface as a 500 to the client.
         try {
           return await withOnboardingRequestContext(context, async () => {
-            const value = await appStateGet(context.sessionId, DISMISSED_KEY);
+            const [value, statuses] = await Promise.all([
+              appStateGet(context.sessionId, DISMISSED_KEY),
+              serializeSteps(context),
+            ]);
             const dismissed = !!(
               value && (value as { dismissed?: boolean }).dismissed
             );
-            const statuses = await serializeSteps(context);
             return {
               dismissed,
               allComplete: allRequiredComplete(statuses),

package/src/org/accept-pending.ts

@@ -1,5 +1,6 @@
 import { getDbExec } from "../db/client.js";
 import { setActiveOrgId } from "./active-org.js";
+import { invalidateRequestMemberOrgIds } from "./request-org-cache.js";
 
 const nanoid = (): string =>
   globalThis.crypto?.randomUUID?.().replace(/-/g, "") ??
@@ -75,6 +76,7 @@ export async function acceptPendingInvitationsForEmail(
               ON CONFLICT (org_id, LOWER(email)) DO NOTHING`,
         args: [nanoid(), inv.orgId, email, role, Date.now()],
       });
+      invalidateRequestMemberOrgIds();
     }
     await db.execute({
       sql: `UPDATE org_invitations SET status = 'accepted' WHERE id = ?`,

package/src/org/auto-join-domain.ts

@@ -1,6 +1,7 @@
 import { getDbExec } from "../db/client.js";
 import { getUserSetting } from "../settings/user-settings.js";
 import { setActiveOrgId } from "./active-org.js";
+import { invalidateRequestMemberOrgIds } from "./request-org-cache.js";
 
 const nanoid = (): string =>
   globalThis.crypto?.randomUUID?.().replace(/-/g, "") ??
@@ -87,6 +88,7 @@ export async function autoJoinDomainMatchingOrgs(
         args: [nanoid(), m.orgId, email, Date.now()],
       });
       joined.push({ orgId: m.orgId });
+      invalidateRequestMemberOrgIds();
     } catch {
       // Race with a parallel join (e.g. user accepted an invite to the
       // same org milliseconds earlier). The unique constraint keeps the

package/src/org/context.ts

@@ -7,6 +7,10 @@ import { getSetting } from "../settings/store.js";
 import { getUserSetting } from "../settings/user-settings.js";
 import { setActiveOrgId } from "./active-org.js";
 import { autoJoinDomainMatchingOrgs } from "./auto-join-domain.js";
+import {
+  invalidateRequestMemberOrgIds,
+  requestMemberOrgIds,
+} from "./request-org-cache.js";
 import type { OrgContext, OrgRole } from "./types.js";
 
 const EMPTY_CONTEXT: OrgContext = {
@@ -210,6 +214,12 @@ async function resolveOrgContextUncached(event: H3Event): Promise<OrgContext> {
 
   const exec = getDbExec();
 
+  // Started before the memberships await so the two round trips overlap; the
+  // `catch` only covers the early returns below, the later `await` still
+  // propagates a real failure.
+  const activeOrgSettingPromise = loadActiveOrgSettingForEvent(event, email);
+  activeOrgSettingPromise.catch(() => {});
+
   let memberships: MembershipRow[] | null;
   try {
     memberships = await loadMembershipsForEvent(event, email);
@@ -238,7 +248,7 @@ async function resolveOrgContextUncached(event: H3Event): Promise<OrgContext> {
     return { email, orgId: null, orgName: null, role: null };
   }
 
-  const activeOrgSetting = await loadActiveOrgSettingForEvent(event, email);
+  const activeOrgSetting = await activeOrgSettingPromise;
   const explicitPersonal = activeOrgSetting?.orgId === null;
 
   const emailDomain = emailDomainOf(email);
@@ -410,17 +420,26 @@ async function loadMemberships(email: string): Promise<MembershipRow[] | null> {
 export async function resolveOrgIdForEmail(
   email: string,
 ): Promise<string | null> {
-  const rows = await queryOrgMembers({
-    sql: `SELECT org_id FROM org_members WHERE LOWER(email) = ?
-          ${MEMBERSHIP_FALLBACK_ORDER_BY}`,
-    args: [email.toLowerCase()],
+  const idsPromise = requestMemberOrgIds(email, async () => {
+    const rows = await queryOrgMembers({
+      sql: `SELECT org_id FROM org_members WHERE LOWER(email) = ?
+            ${MEMBERSHIP_FALLBACK_ORDER_BY}`,
+      args: [email.toLowerCase()],
+    });
+    return rows?.map((r: any) => String(r.org_id)) ?? null;
   });
-  if (!rows?.length) return null;
-  const ids = rows.map((r: any) => String(r.org_id));
-  const activeOrgSetting = (await getUserSetting(
+  // Both reads depend only on the email, so they overlap instead of queueing.
+  // The `catch` only keeps the early return below from surfacing an unhandled
+  // rejection; the `await` further down still propagates the failure.
+  const settingPromise = getUserSetting(
     email,
     "active-org-id",
-  )) as ActiveOrgSetting;
+  ) as Promise<ActiveOrgSetting>;
+  settingPromise.catch(() => {});
+
+  const ids = await idsPromise;
+  if (!ids?.length) return null;
+  const activeOrgSetting = await settingPromise;
   if (activeOrgSetting?.orgId === null) return null;
   if (activeOrgSetting?.orgId && ids.includes(activeOrgSetting.orgId)) {
     return activeOrgSetting.orgId;
@@ -438,9 +457,13 @@ export async function resolveOrgIdForEmailViaEvent(
   event: H3Event,
   email: string,
 ): Promise<string | null> {
+  // Overlapped, not queued: each is a separate round trip and this pair runs
+  // on the session-backfill path of every authenticated request.
+  const settingPromise = loadActiveOrgSettingForEvent(event, email);
+  settingPromise.catch(() => {});
   const memberships = await loadMembershipsForEvent(event, email);
   if (!memberships || memberships.length === 0) return null;
-  const activeOrgSetting = await loadActiveOrgSettingForEvent(event, email);
+  const activeOrgSetting = await settingPromise;
   if (activeOrgSetting?.orgId === null) return null;
   if (
     activeOrgSetting?.orgId &&
@@ -485,6 +508,7 @@ export async function createOrganization(
     sql: `INSERT INTO org_members (id, org_id, email, role, joined_at) VALUES (?, ?, ?, ?, ?)`,
     args: [nanoid(), id, email, role, createdAt],
   });
+  invalidateRequestMemberOrgIds();
 
   await warnOnAdditionalOrganization(exec, email, id, trimmedName);
 
@@ -669,6 +693,7 @@ async function tryCreateDefaultOrg(
       sql: `INSERT INTO org_members (id, org_id, email, role, joined_at) VALUES (?, ?, ?, ?, ?)`,
       args: [nanoid(), orgId, email, "owner", now],
     });
+    invalidateRequestMemberOrgIds();
 
     await setActiveOrgId(email, orgId, "auto-created default organization");
 

package/src/org/handlers.ts

@@ -46,6 +46,7 @@ import { readBody } from "../server/h3-helpers.js";
 import { setActiveOrgId } from "./active-org.js";
 import { getOrgContext, createOrganization } from "./context.js";
 import { isFreeEmailProvider } from "./free-email-providers.js";
+import { invalidateRequestMemberOrgIds } from "./request-org-cache.js";
 import type { OrgRole } from "./types.js";
 import { parseWorkspaceUrl } from "./workspace-url.js";
 
@@ -505,6 +506,7 @@ export const acceptInvitationHandler = defineEventHandler(
       sql: `INSERT INTO org_members (id, org_id, email, role, joined_at) VALUES (?, ?, ?, ?, ?)`,
       args: [nanoid(), invOrgId, email, inviteRole, Date.now()],
     });
+    invalidateRequestMemberOrgIds();
 
     await e.execute({
       sql: `UPDATE org_invitations SET status = 'accepted' WHERE id = ?`,
@@ -574,6 +576,7 @@ export const removeMemberHandler = defineEventHandler(
       sql: `DELETE FROM org_members WHERE org_id = ? AND LOWER(email) = ?`,
       args: [ctx.orgId, memberEmailLower],
     });
+    invalidateRequestMemberOrgIds();
 
     return { success: true };
   },
@@ -772,6 +775,8 @@ export const deleteOrgHandler = defineEventHandler(async (event: H3Event) => {
     });
   }
 
+  invalidateRequestMemberOrgIds();
+
   const nextRes = await e.execute({
     sql: `SELECT org_id AS "orgId" FROM org_members WHERE LOWER(email) = ? LIMIT 1`,
     args: [ctx.email.toLowerCase()],
@@ -875,6 +880,7 @@ export const joinByDomainHandler = defineEventHandler(
       sql: `INSERT INTO org_members (id, org_id, email, role, joined_at) VALUES (?, ?, ?, 'member', ?)`,
       args: [nanoid(), orgId, email, Date.now()],
     });
+    invalidateRequestMemberOrgIds();
 
     await setActiveOrgId(email, orgId, "joined domain-matched organization");
 

package/src/org/request-org-cache.ts

@@ -0,0 +1,71 @@
+import { getRequestContext } from "../server/request-context.js";
+
+/**
+ * Per-request memo of the `org_members` read behind `resolveOrgIdForEmail`,
+ * keyed on the active AsyncLocalStorage `RequestContext` (WeakMap → freed with
+ * the request) and then on the lowercased email. Mirrors the settings cache in
+ * `settings/store.ts`.
+ *
+ * The `event.context` caches in `context.ts` only cover call chains that carry
+ * an h3 event. Identity resolution for credential lookups, agent runs, A2A,
+ * MCP, and adapter-authenticated action calls has no event, so every one of
+ * those callers used to pay its own round trip for the same answer — on a
+ * remote Postgres that is ~83ms each.
+ *
+ * TRAP: the key is the email, never "the current request's user". A single
+ * request legitimately resolves several addresses (the signed-in caller plus a
+ * run owner or credential subject), so a context-only key would answer one
+ * identity with another's memberships.
+ */
+const requestOrgIds = new WeakMap<
+  object,
+  Map<string, Promise<string[] | null>>
+>();
+
+function cacheForRequest(
+  create: boolean,
+): Map<string, Promise<string[] | null>> | null {
+  const ctx = getRequestContext();
+  if (!ctx || typeof ctx !== "object") return null;
+  let cache = requestOrgIds.get(ctx);
+  if (!cache && create) {
+    cache = new Map();
+    requestOrgIds.set(ctx, cache);
+  }
+  return cache ?? null;
+}
+
+/**
+ * Resolve the org ids `email` belongs to, once per request. `null` means the
+ * membership rows were unreadable and is cached like any other answer; a
+ * rejection is evicted so one transient failure cannot answer every later
+ * lookup in the same request.
+ */
+export function requestMemberOrgIds(
+  email: string,
+  load: () => Promise<string[] | null>,
+): Promise<string[] | null> {
+  const cache = cacheForRequest(true);
+  if (!cache) return load();
+  const key = email.trim().toLowerCase();
+  let pending = cache.get(key);
+  if (!pending) {
+    pending = load().catch((err) => {
+      cache.delete(key);
+      throw err;
+    });
+    cache.set(key, pending);
+  }
+  return pending;
+}
+
+/**
+ * Drop this request's memoized memberships after a write to `org_members`.
+ * Clears every email rather than one: deleting an organization or removing a
+ * member changes the answer for accounts other than the one being written.
+ * Requests already in flight elsewhere keep their own snapshot for the rest of
+ * their (short) lifetime, the same tradeoff the settings cache documents.
+ */
+export function invalidateRequestMemberOrgIds(): void {
+  cacheForRequest(false)?.clear();
+}

package/src/resources/store.ts

@@ -1494,18 +1494,19 @@ export async function resourceEffectiveContext(
 ): Promise<EffectiveResourceContext> {
   await ensureTable();
 
-  const workspace = await resourceGetByPath(WORKSPACE_OWNER, path, {
-    ...options,
-    userEmail,
-  });
+  // Four independent reads of the same path under different owners; the
+  // precedence below is pure JS, so serialising them only bought four round
+  // trips of latency. Mirrors `resourceListAccessible`, which already fans out.
   const organizationOwner = sharedResourceOwner(options?.orgId);
-  const organization =
+  const [workspace, organization, legacyShared, personal] = await Promise.all([
+    resourceGetByPath(WORKSPACE_OWNER, path, { ...options, userEmail }),
     organizationOwner === SHARED_OWNER
-      ? null
-      : await resourceGetByPath(organizationOwner, path);
-  const legacyShared = await resourceGetByPath(SHARED_OWNER, path);
+      ? Promise.resolve(null)
+      : resourceGetByPath(organizationOwner, path),
+    resourceGetByPath(SHARED_OWNER, path),
+    resourceGetByPath(userEmail, path),
+  ]);
   const shared = organization ?? legacyShared;
-  const personal = await resourceGetByPath(userEmail, path);
   const effective = personal ?? shared ?? workspace ?? null;
   const effectiveScope: ResourceInheritanceScope | null = personal
     ? "personal"