okengine 0.22.0 → 0.23.0

package/src/drivers/journal-postgres.ts

@@ -20,6 +20,9 @@ import {
   IDEM_RENEW_SQL,
   IDEM_SELECT_SQL,
 } from "../kernel/idempotency-store.ts";
+import type { DecisionLabelStore } from "../kernel/decision-label-store.ts";
+import type { AgentEventStore } from "../kernel/agent-event-store.ts";
+import { lazyRequire } from "../kernel/lazy-require.ts";
 import {
   JOURNAL_DEFAULT_LEASE_MS,
   type JournalEntry,
@@ -257,9 +260,47 @@ export function createPostgresJournalFake(): PostgresJournalSql & {
     created_at: number;
     expires_at: number;
   };
-  type State = { rows: JournalDbRow[]; idem: IdemDbRow[] };
+  type LabelDbRow = {
+    decision_id: string;
+    question: string;
+    value: string;
+    propensity: number;
+    reviewer: string;
+    locale: string | null;
+    model: string | null;
+    tenant: string | null;
+    score: number | null;
+    loss: number | null;
+    raw: string | null;
+    at: number;
+    input: string | null;
+    review_id?: string | null;
+  };
+  type State = {
+    rows: JournalDbRow[];
+    idem: IdemDbRow[];
+    labels: LabelDbRow[];
+    drift: { decision_id: string; suspended: number; certified_at: number }[];
+    candidates: { decision_id: string; body: string }[];
+    agentRuns: { run_id: string; header: string; sweep_claim_at: number | null }[];
+    agentEvents: {
+      run_id: string;
+      seq: number;
+      event: string;
+      event_type: string | null;
+      event_name: string | null;
+    }[];
+  };
 
-  let committed: State = { rows: [], idem: [] };
+  let committed: State = {
+    rows: [],
+    idem: [],
+    labels: [],
+    drift: [],
+    candidates: [],
+    agentRuns: [],
+    agentEvents: [],
+  };
   let active: { state: State; locked: Set<string>; done: boolean } | null = null;
   /** Run ids held by other active transactions (SKIP LOCKED). */
   const heldByTxn = new Set<string>();
@@ -274,6 +315,11 @@ export function createPostgresJournalFake(): PostgresJournalSql & {
     return {
       rows: s.rows.map((r) => ({ ...r })),
       idem: s.idem.map((r) => ({ ...r })),
+      labels: s.labels.map((r) => ({ ...r })),
+      drift: s.drift.map((r) => ({ ...r })),
+      candidates: s.candidates.map((r) => ({ ...r })),
+      agentRuns: s.agentRuns.map((r) => ({ ...r })),
+      agentEvents: s.agentEvents.map((r) => ({ ...r })),
     };
   }
 
@@ -376,6 +422,65 @@ export function createPostgresJournalFake(): PostgresJournalSql & {
           .map((row) => ({ ...row }) as Record<string, unknown>);
       }
 
+      if (/FROM\s+oke_decision_labels/i.test(text)) {
+        let labels = state.labels;
+        let arg = 0;
+        if (/decision_id\s*=\s*\?/i.test(text)) {
+          const id = String(params[arg++] ?? "");
+          labels = labels.filter((row) => row.decision_id === id);
+        }
+        if (/tenant\s+IS\s+NOT\s+DISTINCT\s+FROM\s+\?/i.test(text)) {
+          const tenant = params[arg] ?? null;
+          labels = labels.filter((row) => row.tenant === tenant);
+        }
+        return labels.map((row) => ({ ...row }));
+      }
+
+      if (/FROM\s+oke_decision_drift/i.test(text)) {
+        return state.drift.map((row) => ({ ...row }));
+      }
+
+      if (/FROM\s+oke_decision_candidates/i.test(text)) {
+        if (/decision_id\s*=\s*\?/i.test(text)) {
+          const id = String(params[0] ?? "");
+          return state.candidates
+            .filter((row) => row.decision_id === id)
+            .map((row) => ({ ...row }));
+        }
+        return state.candidates.map((row) => ({ ...row }));
+      }
+
+      if (/FROM\s+oke_agent_run\b/i.test(text)) {
+        if (!/WHERE/i.test(text)) return state.agentRuns.map((row) => ({ ...row }));
+        const id = String(params[0] ?? "");
+        return state.agentRuns.filter((row) => row.run_id === id).map((row) => ({ ...row }));
+      }
+
+      if (/FROM\s+oke_agent_event\b/i.test(text)) {
+        const id = String(params[0] ?? "");
+        if (/MAX\s*\(\s*seq\s*\)/i.test(text)) {
+          const max = state.agentEvents
+            .filter((row) => row.run_id === id)
+            .reduce((highest, row) => Math.max(highest, row.seq), 0);
+          return [{ max_seq: max }];
+        }
+        if (/event_type\s*=/i.test(text)) {
+          const eventType = String(params[1] ?? "");
+          const eventName = String(params[2] ?? "");
+          return state.agentEvents
+            .filter(
+              (row) =>
+                row.run_id === id && row.event_type === eventType && row.event_name === eventName,
+            )
+            .map((row) => ({ ...row }));
+        }
+        const after = /seq\s*>\s*\?/i.test(text) ? Number(params[1] ?? 0) : 0;
+        return state.agentEvents
+          .filter((row) => row.run_id === id && row.seq > after)
+          .sort((a, b) => a.seq - b.seq)
+          .map((row) => ({ ...row }));
+      }
+
       throw new Error(`postgres journal fake: unsupported query: ${sql}`);
     },
     async exec(sql, params = []) {
@@ -539,6 +644,112 @@ export function createPostgresJournalFake(): PostgresJournalSql & {
         row.run_id = String(params[0]);
         return { changes: 1 };
       }
+      if (/^INSERT\s+INTO\s+oke_decision_labels\b/i.test(text)) {
+        state.labels.push({
+          decision_id: String(params[0]),
+          question: String(params[1]),
+          value: String(params[2]),
+          propensity: Number(params[3]),
+          reviewer: String(params[4]),
+          locale: params[5] === null || params[5] === undefined ? null : String(params[5]),
+          model: params[6] === null || params[6] === undefined ? null : String(params[6]),
+          tenant: params[7] === null || params[7] === undefined ? null : String(params[7]),
+          score: params[8] === null || params[8] === undefined ? null : Number(params[8]),
+          loss: params[9] === null || params[9] === undefined ? null : Number(params[9]),
+          raw: params[10] === null || params[10] === undefined ? null : String(params[10]),
+          at: Number(params[11]),
+          input: params[12] === null || params[12] === undefined ? null : String(params[12]),
+          review_id: params[13] === null || params[13] === undefined ? null : String(params[13]),
+        });
+        return { changes: 1 };
+      }
+
+      if (/^INSERT\s+INTO\s+oke_decision_candidates\b/i.test(text)) {
+        const decisionId = String(params[0]);
+        const body = String(params[1]);
+        const idx = state.candidates.findIndex((row) => row.decision_id === decisionId);
+        if (idx >= 0) state.candidates[idx] = { decision_id: decisionId, body };
+        else state.candidates.push({ decision_id: decisionId, body });
+        return { changes: 1 };
+      }
+
+      if (/^UPDATE\s+oke_decision_drift\b/i.test(text)) return { changes: 0 };
+
+      if (/^DELETE\s+FROM\s+oke_decision_drift\b/i.test(text)) {
+        const id = String(params[0] ?? "");
+        const before = state.drift.length;
+        state.drift = state.drift.filter((row) => row.decision_id !== id);
+        return { changes: before - state.drift.length };
+      }
+
+      if (/^INSERT\s+INTO\s+oke_decision_drift\b/i.test(text)) {
+        const decisionId = String(params[0]);
+        const next = {
+          decision_id: decisionId,
+          suspended: Number(params[1]),
+          certified_at: Number(params[2] ?? 0),
+        };
+        const idx = state.drift.findIndex((row) => row.decision_id === decisionId);
+        if (idx >= 0) state.drift[idx] = next;
+        else state.drift.push(next);
+        return { changes: 1 };
+      }
+
+      if (/^UPDATE\s+oke_agent_run\s+SET\s+sweep_claim_at\b/i.test(text)) {
+        const until = Number(params[0]);
+        const runId = String(params[1] ?? "");
+        const now = Number(params[2]);
+        const row = state.agentRuns.find((candidate) => candidate.run_id === runId);
+        if (!row) return { changes: 0 };
+        if (row.sweep_claim_at !== null && row.sweep_claim_at > now) return { changes: 0 };
+        row.sweep_claim_at = until;
+        return { changes: 1 };
+      }
+
+      if (/^INSERT\s+INTO\s+oke_agent_run\b/i.test(text)) {
+        const runId = String(params[0]);
+        const existing = state.agentRuns.find((row) => row.run_id === runId);
+        const next = {
+          run_id: runId,
+          header: String(params[1]),
+          sweep_claim_at: existing?.sweep_claim_at ?? null,
+        };
+        const idx = state.agentRuns.findIndex((row) => row.run_id === runId);
+        if (idx >= 0) state.agentRuns[idx] = next;
+        else state.agentRuns.push(next);
+        return { changes: 1 };
+      }
+
+      if (/^INSERT\s+INTO\s+oke_agent_event\b/i.test(text)) {
+        const runId = String(params[0]);
+        const seq = Number(params[1]);
+        if (state.agentEvents.some((row) => row.run_id === runId && row.seq === seq)) {
+          throw new Error(`duplicate key value violates unique constraint "oke_agent_event_pkey"`);
+        }
+        state.agentEvents.push({
+          run_id: runId,
+          seq,
+          event: String(params[2]),
+          event_type: params[3] === undefined || params[3] === null ? null : String(params[3]),
+          event_name: params[4] === undefined || params[4] === null ? null : String(params[4]),
+        });
+        return { changes: 1 };
+      }
+
+      if (/^DELETE\s+FROM\s+oke_agent_event\b/i.test(text)) {
+        const id = String(params[0] ?? "");
+        const before = state.agentEvents.length;
+        state.agentEvents = state.agentEvents.filter((row) => row.run_id !== id);
+        return { changes: before - state.agentEvents.length };
+      }
+
+      if (/^DELETE\s+FROM\s+oke_agent_run\b/i.test(text)) {
+        const id = String(params[0] ?? "");
+        const before = state.agentRuns.length;
+        state.agentRuns = state.agentRuns.filter((row) => row.run_id !== id);
+        return { changes: before - state.agentRuns.length };
+      }
+
       if (text === IDEM_FORFEIT_SQL) {
         const row = state.idem.find(
           (candidate) =>
@@ -605,6 +816,61 @@ export type PostgresJournalStore = JournalStore &
     close(): Promise<void>;
   };
 
+/**
+ * Open decision tables on first use so a journal without decisions stays empty.
+ *
+ * @param sql - Journal SQL client
+ */
+function loadDecisionLabelModule(): typeof import("../kernel/decision-label-store.ts") {
+  return lazyRequire(`${import.meta.dir}/../kernel`, ["decision", "label", "store"].join("-"));
+}
+
+function loadAgentEventModule(): typeof import("../kernel/agent-event-store.ts") {
+  return lazyRequire(`${import.meta.dir}/../kernel`, ["agent", "event", "store"].join("-"));
+}
+
+function lazyDecisionLabels(sql: PostgresJournalSql): DecisionLabelStore {
+  let pending: Promise<DecisionLabelStore> | undefined;
+  const ready = (): Promise<DecisionLabelStore> => {
+    pending ??= loadDecisionLabelModule().createPostgresDecisionLabelStore(sql);
+    return pending;
+  };
+  return {
+    insert: (label, at) => ready().then((store) => store.insert(label, at)),
+    list: (decision, tenant) => ready().then((store) => store.list(decision, tenant)),
+    drift: () => ready().then((store) => store.drift()),
+    setDrift: (decision, record) => ready().then((store) => store.setDrift(decision, record)),
+    putCandidate: (decision, entry) => ready().then((store) => store.putCandidate(decision, entry)),
+    getCandidate: (decision) => ready().then((store) => store.getCandidate(decision)),
+    listCandidates: () => ready().then((store) => store.listCandidates()),
+  };
+}
+
+/**
+ * Open the agent event tables on first use.
+ *
+ * @param sql - Journal SQL client
+ */
+function lazyAgentEvents(sql: PostgresJournalSql): AgentEventStore {
+  let pending: Promise<AgentEventStore> | undefined;
+  const ready = (): Promise<AgentEventStore> => {
+    pending ??= loadAgentEventModule().createPostgresAgentEventStore(sql);
+    return pending;
+  };
+  return {
+    read: (runId) => ready().then((store) => store.read(runId)),
+    readAfter: (runId, afterSeq) => ready().then((store) => store.readAfter(runId, afterSeq)),
+    maxSeq: (runId) => ready().then((store) => store.maxSeq(runId)),
+    readHeader: (runId) => ready().then((store) => store.readHeader(runId)),
+    truncated: (runId) => ready().then((store) => store.truncated(runId)),
+    claim: (runId) => ready().then((store) => store.claim(runId)),
+    listHeaders: () => ready().then((store) => store.listHeaders()),
+    writeHeader: (header) => ready().then((store) => store.writeHeader(header)),
+    append: (runId, row) => ready().then((store) => store.append(runId, row)),
+    remove: (runId) => ready().then((store) => store.remove(runId)),
+  };
+}
+
 /**
  * Open a postgres-backed JournalStore (multi-host durable-run coordination).
  *
@@ -625,6 +891,8 @@ export async function createPostgresJournalStore(
   const store: PostgresJournalStore = {
     sql,
     idempotency: createPostgresIdempotencyStore(sql),
+    decisions: lazyDecisionLabels(sql),
+    agentEvents: lazyAgentEvents(sql),
     async get(runId) {
       const rows = await sql.query(`SELECT * FROM oke_journal_runs WHERE id = ?`, [runId]);
       if (!rows[0]) return undefined;
@@ -645,6 +913,25 @@ export async function createPostgresJournalStore(
         return true;
       });
     },
+    async cas(runId, instanceId, now, leaseMs, update) {
+      return sql.begin(async (tx) => {
+        const claimed = await tx.query(CLAIM_LEASE_SQL, [runId, instanceId, now]);
+        const row = claimed[0];
+        if (!row) {
+          const exists = await tx.query(`SELECT * FROM oke_journal_runs WHERE id = ?`, [runId]);
+          const held = exists[0];
+          if (!held) return "missing";
+          const current = rowToRun(held);
+          return { lease: true, leaseExpiresAt: current.leaseExpiresAt };
+        }
+        const current = rowToRun(row);
+        const next = update(current) ?? current;
+        next.lockedBy = instanceId;
+        next.leaseExpiresAt = now + leaseMs;
+        await tx.exec(UPSERT_SQL, runToParams(next));
+        return "ok";
+      });
+    },
     async releaseLease(runId, instanceId) {
       await sql.exec(RELEASE_LEASE_SQL, [runId, instanceId]);
     },

package/src/drivers/memory-ddl.test.ts

@@ -0,0 +1,18 @@
+/**
+ * Memory SQL accepts the DDL identity boot issues on the shared connection.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { ensureIdentityTables } from "../auth/identity-sql.ts";
+import { memorySqlDriver } from "./memory.ts";
+
+describe("memory sql DDL", () => {
+  test("CREATE INDEX IF NOT EXISTS does not reject identity tables", async () => {
+    const conn = await memorySqlDriver.connect({ role: "primary" });
+    await ensureIdentityTables(conn);
+    await ensureIdentityTables(conn);
+    const rows = await conn.query("SELECT id FROM oke_credentials");
+    expect(rows).toEqual([]);
+    await conn.close();
+  });
+});

package/src/drivers/memory.ts

@@ -503,7 +503,7 @@ function createMemorySqlConnection(role: "primary" | "replica"): SqlConnection {
       }
 
       const create =
-        /^CREATE\s+TABLE\s+IF\s+NOT\s+EXISTS\s+("?[a-zA-Z_][a-zA-Z0-9_]*"?)\s*\((.+)\)\s*$/i.exec(
+        /^CREATE\s+TABLE\s+IF\s+NOT\s+EXISTS\s+("?[a-zA-Z_][a-zA-Z0-9_]*"?)\s*\((.+)\)\s*$/is.exec(
           text,
         );
       if (create) {
@@ -519,6 +519,26 @@ function createMemorySqlConnection(role: "primary" | "replica"): SqlConnection {
         return { changes: 0 };
       }
 
+      const addColumn =
+        /^ALTER\s+TABLE\s+("?[a-zA-Z_][a-zA-Z0-9_]*"?)\s+ADD\s+COLUMN\s+IF\s+NOT\s+EXISTS\s+("?[a-zA-Z_][a-zA-Z0-9_]*"?)\b/is.exec(
+          text,
+        );
+      if (addColumn) {
+        const name = parseIdent(addColumn[1]!);
+        const column = parseIdent(addColumn[2]!);
+        const table = tables.get(name);
+        if (table && !table.columns.includes(column)) table.columns.push(column);
+        return { changes: 0 };
+      }
+
+      // Scan results do not depend on indexes. Identity and vault DDL still
+      // issue CREATE INDEX IF NOT EXISTS on the shared memory connection.
+      const createIndex =
+        /^CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:CONCURRENTLY\s+)?(?:IF\s+NOT\s+EXISTS\s+)?(?:"?[a-zA-Z_][a-zA-Z0-9_]*"?)\s+ON\s+/is.exec(
+          text,
+        );
+      if (createIndex) return { changes: 0 };
+
       const insert =
         /^INSERT\s+INTO\s+("?[a-zA-Z_][a-zA-Z0-9_]*"?)\s*\(([^)]+)\)\s*VALUES\s*\(([^)]+)\)\s*$/i.exec(
           text,

package/src/drivers/pg-rls.test.ts

@@ -5,6 +5,7 @@ import {
   buildRlsIdentityPreludeSql,
   emitPgPolicySource,
   formatPolicyRole,
+  OKE_PG_STAT_STATEMENTS_SQL,
   OKE_RLS_HELPER_STATEMENTS,
   OKE_RLS_ROLE,
   parseSqlPolicySpec,
@@ -149,6 +150,36 @@ describe("OKE_RLS_HELPER_STATEMENTS", () => {
     expect(hasScope).not.toMatch(/jsonb\s+\?/);
   });
 
+  test("initial oke SQL creates pg_stat_statements before helpers", async () => {
+    const ran: string[] = [];
+    const { installOkeRlsHelpers } = await import("./pg-rls.ts");
+    await installOkeRlsHelpers(async (sql) => {
+      ran.push(sql);
+      if (sql.startsWith("CREATE EXTENSION")) return;
+      if (sql.includes("pg_vault") || sql.includes("vault.")) {
+        throw new Error("stop before vault attach");
+      }
+    }).catch(() => undefined);
+    expect(ran[0]).toBe(OKE_PG_STAT_STATEMENTS_SQL);
+    expect(ran[1]).toBe(OKE_RLS_HELPER_STATEMENTS[0]);
+  });
+
+  test("a rejected pg_stat_statements create still installs helpers", async () => {
+    const ran: string[] = [];
+    const { installOkeRlsHelpers } = await import("./pg-rls.ts");
+    await installOkeRlsHelpers(async (sql) => {
+      ran.push(sql);
+      if (sql.startsWith("CREATE EXTENSION")) {
+        throw new Error('extension "pg_stat_statements" is not available');
+      }
+      if (sql.includes("CREATE OR REPLACE FUNCTION oke.gate")) {
+        throw new Error("stop");
+      }
+    }).catch(() => undefined);
+    expect(ran[0]).toBe(OKE_PG_STAT_STATEMENTS_SQL);
+    expect(ran.some((sql) => sql.includes("CREATE SCHEMA IF NOT EXISTS oke"))).toBe(true);
+  });
+
   test("pins search_path to public so schema oke is not the table home", () => {
     expect(OKE_RLS_HELPER_STATEMENTS).toContain("SET search_path TO public, oke");
     expect(

package/src/drivers/pg-rls.ts

@@ -135,12 +135,27 @@ $oke_app_search_path$`,
  */
 export const OKE_RLS_HELPER_SQL = `${OKE_RLS_HELPER_STATEMENTS.join(";\n")};`;
 
+/**
+ * Enable query telemetry on postgres. Preload is still required
+ * (`shared_preload_libraries=pg_stat_statements`). PGlite and Cockroach
+ * reject this; callers swallow that failure so the rest of the oke SQL runs.
+ */
+export const OKE_PG_STAT_STATEMENTS_SQL = "CREATE EXTENSION IF NOT EXISTS pg_stat_statements";
+
 /**
  * Install `oke.*` helpers one statement at a time.
  *
+ * `pg_stat_statements` is created first when the engine allows it, so Store
+ * performance does not depend on a later manual `CREATE EXTENSION`.
+ *
  * @param exec - Statement runner
  */
 export async function installOkeRlsHelpers(exec: (sql: string) => Promise<unknown>): Promise<void> {
+  try {
+    await exec(OKE_PG_STAT_STATEMENTS_SQL);
+  } catch {
+    // Not preloaded, or this engine has no pg_stat_statements (pglite, cockroach).
+  }
   for (const stmt of OKE_RLS_HELPER_STATEMENTS) {
     await exec(stmt);
   }

package/src/drivers/postgres.test.ts

@@ -38,6 +38,15 @@ describe("toPostgresParams", () => {
 });
 
 describe("closeSharedPostgresClients", () => {
+  test("a different max is a different pool on the same URL", () => {
+    const url = "postgres://127.0.0.1:9/oke-pool-max-shared-test";
+    const small = sharedPostgresClient(url, 8);
+    const large = sharedPostgresClient(url, 20);
+    expect(large).not.toBe(small);
+    expect(sharedPostgresClient(url, 20)).toBe(large);
+    expect(sharedPostgresClient(url)).toBe(small);
+  });
+
   test("drops cached pools so the next checkout is a new client", async () => {
     const url = "postgres://127.0.0.1:9/oke-close-shared-test";
     const first = sharedPostgresClient(url);

package/src/drivers/postgres.ts

@@ -43,7 +43,27 @@ type SharedPostgresEntry = {
   readonly guarded: PostgresClientLike;
 };
 
-const sharedClients = new Map<string, SharedPostgresEntry>();
+/**
+ * Process-wide pool registry.
+ *
+ * `bun --hot` re-evaluates this module on each save. A module-local `Map`
+ * would drop the only handle to the previous Bun.SQL pools and leave them
+ * connected. PgDog then queues every checkout — Console login included —
+ * until its server pool times out.
+ */
+const SHARED_POSTGRES_CLIENTS = Symbol.for("oke.sharedPostgresClients");
+
+function sharedClientMap(): Map<string, SharedPostgresEntry> {
+  const g = globalThis as typeof globalThis & {
+    [SHARED_POSTGRES_CLIENTS]?: Map<string, SharedPostgresEntry>;
+  };
+  let map = g[SHARED_POSTGRES_CLIENTS];
+  if (!map) {
+    map = new Map();
+    g[SHARED_POSTGRES_CLIENTS] = map;
+  }
+  return map;
+}
 
 /**
  * When true, shared pools stay closed and every query fails fast — no Bun.SQL
@@ -160,21 +180,38 @@ function guardSharedPostgresClient(raw: PostgresClientLike): PostgresClientLike
 }
 
 /**
- * One Bun.SQL pool per URL for store / journal / clock / vault / console.
+ * Bun.SQL pool size. Unset, non-finite, or below 1 keeps {@link POSTGRES_POOL_MAX}.
+ * A configured max is not capped — callers that need a larger pool ask for it.
+ *
+ * @param poolMax - Requested `max`
+ */
+function postgresPoolMax(poolMax: number | undefined): number {
+  if (poolMax === undefined || !Number.isFinite(poolMax) || poolMax < 1) return POSTGRES_POOL_MAX;
+  return Math.floor(poolMax);
+}
+
+/**
+ * One Bun.SQL pool per URL and `max` for store / journal / clock / vault / console.
  *
  * Returns a pause-aware client — holders (including fleet store wrappers)
  * fail soft after {@link pauseSharedPostgresClients} instead of reconnecting.
  *
  * @param url - Connection URL
+ * @param poolMax - Bun.SQL `max`. Omitted uses {@link POSTGRES_POOL_MAX}. A
+ * different max is a different pool — a store pin of 20 must not reuse a
+ * pool another subsystem already opened at the default.
  */
-export function sharedPostgresClient(url?: string): PostgresClientLike {
+export function sharedPostgresClient(url?: string, poolMax?: number): PostgresClientLike {
   assertSharedPostgresReady();
-  const key = resolvePostgresUrl(url);
-  const existing = sharedClients.get(key);
+  const resolved = resolvePostgresUrl(url);
+  const max = postgresPoolMax(poolMax);
+  const key = `${resolved}\0${String(max)}`;
+  const clients = sharedClientMap();
+  const existing = clients.get(key);
   if (existing) return existing.guarded;
-  const raw = new Bun.SQL(key, { max: POSTGRES_POOL_MAX }) as unknown as PostgresClientLike;
+  const raw = new Bun.SQL(resolved, { max }) as unknown as PostgresClientLike;
   const guarded = guardSharedPostgresClient(raw);
-  sharedClients.set(key, { raw, guarded });
+  clients.set(key, { raw, guarded });
   return guarded;
 }
 
@@ -185,8 +222,8 @@ export function sharedPostgresClient(url?: string): PostgresClientLike {
  * not stop Console from opening a fresh pool on the next poll.
  */
 export async function closeSharedPostgresClients(): Promise<void> {
-  const clients = [...sharedClients.values()];
-  sharedClients.clear();
+  const clients = [...sharedClientMap().values()];
+  sharedClientMap().clear();
   await Promise.all(
     clients.map(async (entry) => {
       try {
@@ -283,12 +320,13 @@ export async function connectPostgres(options: SqlConnectOptions = {}): Promise<
   // must not share a pooled client — Bun raises ERR_POSTGRES_UNSAFE_TRANSACTION
   // when raw statements interleave with open transaction state on the shared
   // pool. Opt in explicitly; default behavior is unchanged.
-  const dedicated = !injected && options.pool?.max === 1;
+  const requestedMax = options.pool?.max;
+  const dedicated = !injected && requestedMax === 1;
   const client =
     injected ??
     (dedicated
       ? dedicatedPostgresClient(resolvePostgresUrl(options.url))
-      : sharedPostgresClient(options.url));
+      : sharedPostgresClient(options.url, requestedMax));
   return wrapPostgresClient(client, role, {
     shared: injected === undefined && !dedicated,
     ...(options.url !== undefined ? { url: options.url } : {}),

package/src/elements/ai/agent-event-slot.ts

@@ -0,0 +1,27 @@
+/**
+ * Installed agent event log.
+ *
+ * The follow route and the AI runtime must share one slot. The log
+ * implementation stays in `run-events.ts` and loads on first use; this file
+ * is the only static edge so a `lazyRequire` copy cannot hide the log.
+ */
+
+import type { AgentEventLog } from "./run-events.ts";
+
+let activeLog: AgentEventLog | undefined;
+
+/**
+ * Install the log the follow route reads. Boot and tests call this.
+ *
+ * @param log - Active log
+ */
+export function setAgentEventLog(log: AgentEventLog | undefined): void {
+  activeLog = log;
+}
+
+/**
+ * Log installed by the running AI runtime.
+ */
+export function getAgentEventLog(): AgentEventLog | undefined {
+  return activeLog;
+}