@agent-native/core 0.131.9 → 0.132.0

package/corpus/core/src/client/application-state.ts

@@ -93,19 +93,117 @@ function jsonBody(value: unknown): string {
   return body;
 }
 
+/**
+ * Result of a batched read. `values` holds only the keys the server has a row
+ * for; every other requested key is in `missing`. A key stored with a `null`
+ * value lands in `values` with `null` and NOT in `missing` — that is how
+ * "never written" stays distinguishable from "written as null/empty".
+ */
+export interface ClientAppStateBatch {
+  values: Record<string, unknown>;
+  missing: string[];
+}
+
+/** Server caps a batch at 100 keys; stay under it when splitting. */
+const MAX_BATCH_KEYS = 100;
+
+export async function readClientAppStateMany(
+  keys: readonly string[],
+  options: ClientAppStateReadOptions = {},
+): Promise<ClientAppStateBatch> {
+  const unique = [...new Set(keys)];
+  for (const key of unique) appStateUrl(key); // validates the key shape
+  if (unique.length === 0) return { values: {}, missing: [] };
+
+  const merged: ClientAppStateBatch = { values: {}, missing: [] };
+  for (let i = 0; i < unique.length; i += MAX_BATCH_KEYS) {
+    const chunk = unique.slice(i, i + MAX_BATCH_KEYS);
+    const url = `${agentNativePath("/_agent-native/application-state")}?keys=${chunk
+      .map(encodeURIComponent)
+      .join(",")}`;
+    const response = await fetch(url, {
+      method: "GET",
+      cache: "no-store",
+      signal: options.signal,
+    });
+    const batch = await parseAppStateResponse<ClientAppStateBatch | null>(
+      response,
+      `Read application state [${chunk.join(", ")}]`,
+    );
+    if (!batch || typeof batch !== "object" || !batch.values) {
+      throw new Error(
+        `Read application state [${chunk.join(", ")}] returned an unexpected payload.`,
+      );
+    }
+    Object.assign(merged.values, batch.values);
+    merged.missing.push(...(batch.missing ?? []));
+  }
+  return merged;
+}
+
+// Reads issued in the same tick are coalesced into one batched request. Every
+// mounted composer, question card and suggestion hook reads its own key on
+// mount, which used to be one HTTP request (and one full identity resolution)
+// each — ~55 on an analytics dashboard load.
+let pendingBatch:
+  | { keys: Set<string>; promise: Promise<ClientAppStateBatch> }
+  | undefined;
+
+function scheduleBatchedRead(key: string): Promise<ClientAppStateBatch> {
+  if (pendingBatch) {
+    pendingBatch.keys.add(key);
+    return pendingBatch.promise;
+  }
+  const keys = new Set([key]);
+  const promise = new Promise<ClientAppStateBatch>((resolve, reject) => {
+    setTimeout(() => {
+      pendingBatch = undefined;
+      readClientAppStateMany([...keys]).then(resolve, reject);
+    }, 0);
+  });
+  pendingBatch = { keys, promise };
+  return promise;
+}
+
+function awaitWithAbort<T>(
+  promise: Promise<T>,
+  signal?: AbortSignal,
+): Promise<T> {
+  if (!signal) return promise;
+  const abortReason = () =>
+    signal.reason ?? new Error("The operation was aborted");
+  if (signal.aborted) return Promise.reject(abortReason());
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = () => {
+      cleanup();
+      reject(abortReason());
+    };
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        cleanup();
+        if (signal.aborted) reject(abortReason());
+        else resolve(value);
+      },
+      (error) => {
+        cleanup();
+        reject(error);
+      },
+    );
+  });
+}
+
 export async function readClientAppState<T = unknown>(
   key: string,
   options: ClientAppStateReadOptions = {},
 ): Promise<T | null> {
-  const response = await fetch(appStateUrl(key), {
-    method: "GET",
-    cache: "no-store",
-    signal: options.signal,
-  });
-  return parseAppStateResponse<T | null>(
-    response,
-    `Read application state "${key}"`,
-  );
+  appStateUrl(key); // validates the key shape before it joins a batch
+  if (options.signal?.aborted) {
+    throw options.signal.reason ?? new Error("Aborted");
+  }
+  const batch = await awaitWithAbort(scheduleBatchedRead(key), options.signal);
+  return (batch.values[key] ?? null) as T | null;
 }
 
 export async function writeClientAppState<T = unknown>(
@@ -129,9 +227,14 @@ export async function deleteClientAppState(
 ): Promise<void> {
   const response = await fetch(appStateUrl(key), {
     method: "DELETE",
-    headers: options.requestSource
-      ? { "X-Request-Source": options.requestSource }
-      : undefined,
+    // DELETE carries no JSON body, so this custom header is the only
+    // same-origin marker the CSRF check can see from an embedded frame.
+    headers: {
+      "X-Agent-Native-CSRF": "1",
+      ...(options.requestSource
+        ? { "X-Request-Source": options.requestSource }
+        : {}),
+    },
     keepalive: options.keepalive,
     signal: options.signal,
   });

package/corpus/core/src/client/dynamic-suggestions.ts

@@ -1,6 +1,6 @@
 import { useEffect, useMemo, useState } from "react";
 
-import { agentNativePath } from "./api-path.js";
+import { readClientAppState } from "./application-state.js";
 import { useChangeVersions } from "./use-change-version.js";
 import type { ChatThreadScope } from "./use-chat-threads.js";
 
@@ -89,17 +89,9 @@ function appStateKeyForBrowserTab(key: string, browserTabId?: string): string {
 }
 
 async function readAppState(key: string): Promise<unknown> {
-  const res = await fetch(
-    agentNativePath(`/_agent-native/application-state/${key}`),
-  );
-  if (!res.ok || res.status === 204) return null;
-  const text = await res.text();
-  if (!text) return null;
-  try {
-    return JSON.parse(text);
-  } catch {
-    return null;
-  }
+  // Reads issued in the same tick coalesce into one batched request, so the
+  // four keys below cost one round trip rather than four.
+  return readClientAppState(key).catch(() => null);
 }
 
 async function readScopedAppState(

package/corpus/core/src/client/guided-questions.tsx

@@ -12,8 +12,11 @@ import {
 import { useCallback, useEffect, useMemo, useState } from "react";
 
 import { sendToAgentChat } from "./agent-chat.js";
-import { agentNativePath } from "./api-path.js";
-import { setClientAppState } from "./application-state.js";
+import {
+  deleteClientAppState,
+  readClientAppState,
+  setClientAppState,
+} from "./application-state.js";
 import { useChangeVersions } from "./use-change-version.js";
 import { cn } from "./utils.js";
 
@@ -998,10 +1001,6 @@ export function useGuidedQuestionFlow({
     () => normalizeBrowserTabId(browserTabId),
     [browserTabId],
   );
-  const endpointFor = useCallback(
-    (key: string) => agentNativePath(`/_agent-native/application-state/${key}`),
-    [],
-  );
   const scopedKey = normalizedBrowserTabId
     ? `${stateKey}:${normalizedBrowserTabId}`
     : stateKey;
@@ -1036,17 +1035,11 @@ export function useGuidedQuestionFlow({
     enabled,
     queryFn: async () => {
       const read = async (key: string) => {
-        const res = await fetch(endpointFor(key));
-        if (!res.ok) return null;
-        const text = await res.text();
-        if (!text) return null;
-        try {
-          const parsed = JSON.parse(text);
-          if (Array.isArray(parsed?.questions) && parsed.questions.length > 0) {
-            return parsed as GuidedQuestionPayload;
-          }
-        } catch {
-          return null;
+        const parsed = await readClientAppState<GuidedQuestionPayload>(
+          key,
+        ).catch(() => null);
+        if (Array.isArray(parsed?.questions) && parsed.questions.length > 0) {
+          return parsed;
         }
         return null;
       };
@@ -1086,16 +1079,12 @@ export function useGuidedQuestionFlow({
   const clear = useCallback(() => {
     setPayload(null);
     queryClient.setQueryData(resolvedQueryKey, null);
-    const del = (key: string) =>
-      fetch(endpointFor(key), {
-        method: "DELETE",
-        headers: { "X-Agent-Native-CSRF": "1" },
-      }).catch(() => {});
+    const del = (key: string) => deleteClientAppState(key).catch(() => {});
     // Clear whichever key actually held the payload (scoped or bare) so the
     // card doesn't reappear on the next poll.
     del(scopedKey);
     if (scopedKey !== stateKey) del(stateKey);
-  }, [endpointFor, queryClient, resolvedQueryKey, scopedKey, stateKey]);
+  }, [queryClient, resolvedQueryKey, scopedKey, stateKey]);
 
   const handleSubmit = useCallback(
     (answers: GuidedQuestionAnswers) => {

package/corpus/core/src/db/client.ts

@@ -954,19 +954,19 @@ export function isServerlessRuntime(): boolean {
 }
 
 /**
- * postgres.js pool options tuned per runtime. A serverless instance handles
- * one request at a time, so a single connection is enough. Keeping the
- * foreground pool at 1 is important because each instance can also open an
- * app and Better Auth pool; a max of 2 on each pool still exhausted Neon
- * under a burst of warm instances. idle_timeout is shortened on
+ * postgres.js pool options tuned per runtime. idle_timeout is shortened on
  * serverless so a thawed-but-idle instance releases its connections quickly.
- * Long-lived Node servers keep the normal pool for throughput.
+ * Long-lived Node servers keep the larger pool for throughput.
+ *
+ * The cap assumes {@link sharedDbPool}: one pool per URL for the whole
+ * process, not one per consumer. See {@link neonPoolMax} for why the cap must
+ * leave room for concurrency.
  */
 export function pgPoolOptions(url: string): Record<string, unknown> {
   const serverless = isServerlessRuntime();
   return {
     onnotice: () => {},
-    max: serverless ? 1 : 10,
+    max: serverless ? 4 : 20,
     idle_timeout: serverless ? 20 : 240,
     max_lifetime: 60 * 30,
     connect_timeout: 10,
@@ -977,13 +977,21 @@ export function pgPoolOptions(url: string): Record<string, unknown> {
 }
 
 /**
- * Connection cap for the @neondatabase/serverless `Pool`. Same instance
- * accumulation risk as postgres.js — one connection is enough for a
- * foreground serverless invocation and keeps the aggregate app/framework/auth
- * budget bounded.
+ * Connection cap for the @neondatabase/serverless `Pool`.
+ *
+ * TRAP: this number is the ceiling on how many statements one request can have
+ * in flight at once. It used to be 1 on serverless, which made every
+ * `Promise.all([...reads])` in a request serialize behind the single slot —
+ * against a remote endpoint that is ~83ms of pure wait per query, so ten
+ * "concurrent" reads took ~880ms instead of ~86ms. The cap was 1 only because
+ * every consumer built its OWN pool (the DbExec singleton, Better Auth, and one
+ * per `createGetDb()` schema module), so the real per-instance connection count
+ * was that number multiplied by ~6. {@link sharedDbPool} collapses those into
+ * one pool per URL, so the same aggregate budget buys in-request concurrency.
+ * Keep pools shared if you raise this.
  */
 export function neonPoolMax(): number {
-  if (!isServerlessRuntime()) return 10;
+  if (!isServerlessRuntime()) return 20;
   // The durable background-function worker is a SINGLE process per run (unlike
   // the many warm request-instances the foreground serverless has), so it can
   // safely hold a larger pool without risking Neon's connection cap. The agent's
@@ -996,7 +1004,7 @@ export function neonPoolMax(): number {
   // burst; keep the foreground serverless pool tiny to avoid "Max client
   // connections reached" across many warm instances.
   if (isBackgroundFunctionPoolContext()) return 8;
-  return 1;
+  return 4;
 }
 
 /**
@@ -1110,6 +1118,113 @@ export function attachNeonPoolErrorLogger(
   });
 }
 
+// ---------------------------------------------------------------------------
+// Shared connection pools
+// ---------------------------------------------------------------------------
+
+interface ClosablePool {
+  end(): Promise<unknown>;
+}
+
+const _sharedDbPools = new Map<string, ClosablePool>();
+const _sharedDbPoolCloseHooks = new Set<() => void>();
+const _sharedDbPoolReplacementHooks = new Map<string, Set<() => void>>();
+
+/**
+ * One connection pool per (driver, URL) for the whole process.
+ *
+ * Opening a connection to a remote database costs a full TCP + TLS + auth
+ * round-trip chain (~300-800ms measured against Neon in-region), and it used
+ * to be paid once per CONSUMER: the `getDbExec` singleton, Better Auth, and one
+ * more for every `createGetDb()` schema module (four in core alone, plus each
+ * app's). Their `max` values also multiplied against the provider's connection
+ * cap, which forced each pool down to a size too small to run a request's reads
+ * concurrently.
+ *
+ * TRAP: only consumers that live as long as the process may share. Anything
+ * handed a `close()` — `createDbExec()`, the migration exec on the direct
+ * endpoint — must keep a private pool, or closing it takes the whole process's
+ * database access down with it.
+ */
+export function sharedDbPool<T extends ClosablePool>(
+  driver: string,
+  url: string,
+  create: () => T,
+): T {
+  const key = `${driver}${url}`;
+  const existing = _sharedDbPools.get(key);
+  if (existing) return existing as T;
+  const created = create();
+  _sharedDbPools.set(key, created);
+  return created;
+}
+
+/**
+ * Swap the pool registered for a key, for the postgres.js recycle path that
+ * replaces a pool whose query timed out. Without this the registry would keep
+ * handing out the discarded pool.
+ */
+export function replaceSharedDbPool<T extends ClosablePool>(
+  driver: string,
+  url: string,
+  previous: T,
+  next: T,
+): void {
+  const key = `${driver}${url}`;
+  if (_sharedDbPools.get(key) !== previous) return;
+  _sharedDbPools.set(key, next);
+  for (const hook of _sharedDbPoolReplacementHooks.get(key) ?? []) {
+    try {
+      hook();
+    } catch {
+      // A consumer's reset must not block the replacement from being used.
+    }
+  }
+}
+
+/**
+ * Run `hook` when one shared pool is replaced, so derived consumers rebuild
+ * their handles instead of continuing to use the timed-out pool.
+ */
+export function onSharedDbPoolReplaced(
+  driver: string,
+  url: string,
+  hook: () => void,
+): void {
+  const key = `${driver}${String.fromCharCode(0)}${url}`;
+  const hooks = _sharedDbPoolReplacementHooks.get(key) ?? new Set();
+  hooks.add(hook);
+  _sharedDbPoolReplacementHooks.set(key, hooks);
+}
+
+/**
+ * Run `hook` when the shared pools are closed, so consumers holding a derived
+ * handle (a Drizzle instance bound to the pool, the Better Auth adapter) drop
+ * it instead of issuing queries on a closed pool.
+ */
+export function onSharedDbPoolsClosed(hook: () => void): void {
+  _sharedDbPoolCloseHooks.add(hook);
+}
+
+export async function closeSharedDbPools(): Promise<void> {
+  const pools = [..._sharedDbPools.values()];
+  _sharedDbPools.clear();
+  for (const hook of _sharedDbPoolCloseHooks) {
+    try {
+      hook();
+    } catch {
+      // A consumer's reset must not block the rest from being released.
+    }
+  }
+  await Promise.all(
+    pools.map((pool) =>
+      Promise.resolve(pool.end()).catch(() => {
+        // Already closed (process exiting, provider hung up) — nothing to do.
+      }),
+    ),
+  );
+}
+
 function disposePostgresPoolEventually(
   pool: { end: () => Promise<unknown> },
   label: string,
@@ -1130,8 +1245,6 @@ function disposePostgresPoolEventually(
 // ---------------------------------------------------------------------------
 
 let _exec: DbExec | undefined;
-let _pgPool: any;
-let _neonPool: any;
 let _sqlite: any;
 let _initPromise: Promise<void> | undefined;
 
@@ -1231,9 +1344,14 @@ async function createDbExecInternal(
       // connections, so its direct executions use stateless Neon HTTP instead.
       // The foreground and transaction surface keep the WebSocket pool.
       const bgHttp = isBackgroundFunctionPoolContext();
-      const pool = new Pool({ connectionString: url, max: neonPoolMax() });
+      const makePool = () =>
+        new Pool({ connectionString: url, max: neonPoolMax() });
+      // The singleton exec shares the process pool; `createDbExec()` callers own
+      // a `close()` and so must not be handed it.
+      const pool = trackSingletonResources
+        ? sharedDbPool("neon", url, makePool)
+        : makePool();
       attachNeonPoolErrorLogger(pool);
-      if (trackSingletonResources) _neonPool = pool;
       const httpSql = bgHttp ? neon(url, { fullResults: true }) : null;
       async function queryNeonClient(
         client: any,
@@ -1461,6 +1579,7 @@ async function createDbExecInternal(
           }, 1);
         },
         async close() {
+          if (trackSingletonResources) return closeSharedDbPools();
           await pool.end();
         },
       };
@@ -1566,12 +1685,17 @@ async function createDbExecInternal(
       // server-side timeout, avoiding ECONNRESET when the server hangs up.
       const createPool = () => postgres(url, pgPoolOptions(url));
       type PostgresPool = ReturnType<typeof createPool>;
-      let pool = createPool();
-      if (trackSingletonResources) _pgPool = pool;
+      // Same rule as the Neon path: the singleton exec shares the process pool,
+      // `createDbExec()` callers own a `close()` and get a private one.
+      let pool = trackSingletonResources
+        ? sharedDbPool("postgres-js", url, createPool)
+        : createPool();
       const recyclePool = (timedOutPool: PostgresPool) => {
         if (pool === timedOutPool) {
           pool = createPool();
-          if (trackSingletonResources) _pgPool = pool;
+          if (trackSingletonResources) {
+            replaceSharedDbPool("postgres-js", url, timedOutPool, pool);
+          }
         }
         disposePostgresPoolEventually(timedOutPool, "timed-out pooled query");
       };
@@ -1626,6 +1750,7 @@ async function createDbExecInternal(
           return result as T;
         },
         async close() {
+          if (trackSingletonResources) return closeSharedDbPools();
           await pool.end();
         },
       };
@@ -1884,14 +2009,9 @@ export function getDbExec(): DbExec {
 
 /** Close the database connection (for scripts that need cleanup). */
 export async function closeDbExec(): Promise<void> {
-  if (_pgPool) {
-    await _pgPool.end();
-    _pgPool = undefined;
-  }
-  if (_neonPool) {
-    await _neonPool.end();
-    _neonPool = undefined;
-  }
+  // Both Postgres pools live in the shared registry, which also notifies the
+  // Drizzle / Better Auth consumers bound to them.
+  await closeSharedDbPools();
   if (_sqlite) {
     _sqlite.close();
     _sqlite = undefined;

package/corpus/core/src/db/create-get-db.ts

@@ -21,6 +21,9 @@ import {
   withDbTimeout,
   retryOnConnectionError,
   dbOpTimeoutMs,
+  sharedDbPool,
+  onSharedDbPoolsClosed,
+  onSharedDbPoolReplaced,
 } from "./client.js";
 
 // Lazy driver loaders — cached promises so dynamic import only runs once.
@@ -444,6 +447,27 @@ export function createGetDb<T extends Record<string, unknown>>(schema: T) {
   let _db: any;
   let _dbReady: Promise<any> | undefined;
 
+  // The Drizzle instance is bound to a shared pool, so a `closeDbExec()` (test
+  // teardown, script cleanup) must invalidate it rather than leave this store
+  // issuing queries on a closed pool. Registered lazily from the pooled
+  // branches only — `createGetDb` is called at module scope by every store, and
+  // core's specs widely mock `db/client.js`.
+  let _closeHookRegistered = false;
+  function resetOnPoolClose(driver?: string, url?: string): void {
+    if (_closeHookRegistered) return;
+    _closeHookRegistered = true;
+    onSharedDbPoolsClosed(() => {
+      _db = undefined;
+      _dbReady = undefined;
+    });
+    if (driver && url) {
+      onSharedDbPoolReplaced(driver, url, () => {
+        _db = undefined;
+        _dbReady = undefined;
+      });
+    }
+  }
+
   function startInit(): Promise<any> {
     if (_dbReady) return _dbReady;
 
@@ -473,10 +497,15 @@ export function createGetDb<T extends Record<string, unknown>>(schema: T) {
     if (dialect === "postgres") {
       if (isNeonUrl(url)) {
         _dbReady = getNeonServerlessDrizzle().then(({ drizzle, Pool }) => {
-          const rawPool = new Pool({
-            connectionString: url,
-            max: neonPoolMax(),
-          });
+          // Shared with the DbExec singleton, Better Auth, and every other
+          // `createGetDb` store: one connect per process instead of one per
+          // schema module. See `sharedDbPool` in client.ts.
+          resetOnPoolClose("neon", url);
+          const rawPool = sharedDbPool(
+            "neon",
+            url,
+            () => new Pool({ connectionString: url, max: neonPoolMax() }),
+          );
           attachNeonPoolErrorLogger(rawPool);
           // Wrap the pool with the resilience layer so Drizzle queries get the
           // same withDbTimeout + retryOnConnectionError protection as the raw
@@ -489,8 +518,12 @@ export function createGetDb<T extends Record<string, unknown>>(schema: T) {
         _dbReady = getPgDrizzle().then(({ drizzle, postgres }) => {
           // pgPoolOptions caps the pool to a small size on serverless so
           // concurrent frozen instances don't exhaust Neon/Postgres'
-          // connection limit ("Max client connections reached").
-          const client = postgres(url, pgPoolOptions(url));
+          // connection limit ("Max client connections reached"). Shared across
+          // consumers — see `sharedDbPool` in client.ts.
+          resetOnPoolClose("postgres-js", url);
+          const client = sharedDbPool("postgres-js", url, () =>
+            postgres(url, pgPoolOptions(url)),
+          );
           _db = drizzle(buildResilientPostgresJsClient(client), { schema });
         });
       }

package/corpus/core/src/db/runtime-diagnostics.ts

@@ -51,7 +51,7 @@ export interface DatabaseSchemaHealthResult {
   error?: string;
 }
 
-const DEFAULT_REQUIRED_SCHEMA: RequiredSchemaTable[] = [
+export const DEFAULT_REQUIRED_SCHEMA: RequiredSchemaTable[] = [
   {
     table: "agent_runs",
     columns: [
@@ -253,6 +253,24 @@ async function tableColumns(
     : sqliteTableColumns(exec, table);
 }
 
+/**
+ * Memo for the default probe, which several client surfaces re-run on every
+ * page load at one `information_schema` round trip per required table.
+ *
+ * Only a clean, completed result is memoized: a probe reporting a missing table
+ * or an unreadable database must never be served from cache, or the repair that
+ * follows stays invisible for the whole window. Schema changes are additive and
+ * applied by migrations, so a clean answer cannot silently go bad — but the
+ * window is still kept to seconds, short enough that anything a deploy changes
+ * shows up on the next page load rather than being pinned. Callers that
+ * override `exec`, `dialect`, or `required` bypass it entirely.
+ */
+const SCHEMA_HEALTH_MEMO_MS = 5_000;
+let schemaHealthMemo: {
+  at: number;
+  result: DatabaseSchemaHealthResult;
+} | null = null;
+
 export async function runDatabaseSchemaHealthCheck(
   options: {
     exec?: DbExec;
@@ -260,6 +278,15 @@ export async function runDatabaseSchemaHealthCheck(
     required?: RequiredSchemaTable[];
   } = {},
 ): Promise<DatabaseSchemaHealthResult> {
+  const memoizable = !options.exec && !options.dialect && !options.required;
+  if (
+    memoizable &&
+    schemaHealthMemo &&
+    Date.now() - schemaHealthMemo.at < SCHEMA_HEALTH_MEMO_MS
+  ) {
+    return schemaHealthMemo.result;
+  }
+
   const dialect = options.dialect ?? getDialect();
   const exec = options.exec ?? getDbExec();
   const required = options.required ?? DEFAULT_REQUIRED_SCHEMA;
@@ -267,18 +294,24 @@ export async function runDatabaseSchemaHealthCheck(
   const missingColumns: Array<{ table: string; column: string }> = [];
 
   try {
-    for (const requirement of required) {
-      const columns = await tableColumns(exec, dialect, requirement.table);
+    // Independent probes: serially they cost one network round trip each.
+    const found = await Promise.all(
+      required.map((requirement) =>
+        tableColumns(exec, dialect, requirement.table),
+      ),
+    );
+    required.forEach((requirement, index) => {
+      const columns = found[index];
       if (!columns) {
         missingTables.push(requirement.table);
-        continue;
+        return;
       }
       for (const column of requirement.columns) {
         if (!columns.has(column)) {
           missingColumns.push({ table: requirement.table, column });
         }
       }
-    }
+    });
   } catch (err) {
     return {
       ok: false,
@@ -290,13 +323,15 @@ export async function runDatabaseSchemaHealthCheck(
     };
   }
 
-  return {
+  const result: DatabaseSchemaHealthResult = {
     ok: missingTables.length === 0 && missingColumns.length === 0,
     checked: true,
     dialect,
     missingTables,
     missingColumns,
   };
+  if (memoizable && result.ok) schemaHealthMemo = { at: Date.now(), result };
+  return result;
 }
 
 export function formatRuntimeDebugFingerprint(