okengine 0.12.0 → 0.14.1

package/src/elements/store/kv-sql.ts

@@ -0,0 +1,178 @@
+/**
+ * SQL-backed durable KV — `oke_kv` JSONB on the shared store.sql connection.
+ *
+ * Not a catalog `drivers.store.kv` id. Cache namespaces stay redis/memory.
+ */
+
+import type { KvNamespace, SqlConnection } from "../../drivers/types.ts";
+import { parseTtlMs } from "./cache.ts";
+
+/** Engine-owned durable KV table — boot DDL, excluded from `oke db push`. */
+export const OKE_KV_TABLE = "oke_kv";
+
+/** Options for {@link openSqlKvNamespace}. */
+export interface OpenSqlKvOptions {
+  /** Shared SQL connection (`sharedSqlConn`). */
+  readonly conn: SqlConnection;
+  /** `store.kv` namespace name. */
+  readonly namespace: string;
+  /** Injectable clock (epoch ms). */
+  readonly now: () => number;
+}
+
+/** SQL KV handle — {@link KvNamespace} plus {@link SqlKvNamespace.purgeExpired}. */
+export interface SqlKvNamespace extends KvNamespace {
+  readonly driverId: "postgres" | "pglite" | "memory";
+  /**
+   * Delete rows whose `expires_at` has passed.
+   *
+   * @returns Rows removed
+   */
+  purgeExpired(): Promise<number>;
+}
+
+const ensured = new WeakSet<SqlConnection>();
+
+/**
+ * Create `oke_kv` + the expires partial index (idempotent).
+ *
+ * @param conn - Shared SQL connection
+ */
+export async function ensureOkeKvSchema(conn: SqlConnection): Promise<void> {
+  if (ensured.has(conn)) return;
+  await conn.exec(`CREATE TABLE IF NOT EXISTS ${OKE_KV_TABLE} (
+    namespace TEXT NOT NULL,
+    key TEXT NOT NULL,
+    value JSONB NOT NULL,
+    expires_at BIGINT,
+    updated_at BIGINT NOT NULL,
+    PRIMARY KEY (namespace, key)
+  )`);
+  await conn.exec(
+    `CREATE INDEX IF NOT EXISTS oke_kv_expires ON ${OKE_KV_TABLE} (expires_at) WHERE expires_at IS NOT NULL`,
+  );
+  ensured.add(conn);
+}
+
+/**
+ * Open a durable KV namespace on an already-open SQL connection.
+ *
+ * @param options - Connection / namespace / clock
+ */
+export async function openSqlKvNamespace(options: OpenSqlKvOptions): Promise<SqlKvNamespace> {
+  const { conn, namespace, now } = options;
+  await ensureOkeKvSchema(conn);
+  await purgeExpiredOn(conn, now());
+
+  return {
+    driverId: conn.driverId,
+    async get(key) {
+      const rows = await conn.query(
+        `SELECT value FROM ${OKE_KV_TABLE}
+         WHERE namespace = ? AND key = ?
+           AND (expires_at IS NULL OR expires_at > ?)`,
+        [namespace, key, now()],
+      );
+      const raw = rows[0]?.value;
+      if (raw === undefined) return undefined;
+      return decodeJsonb(raw);
+    },
+    async set(key, value, ttl) {
+      await purgeExpiredOn(conn, now());
+      const t = now();
+      const expiresAt = ttlExpiresAt(ttl, t);
+      await conn.exec(
+        `INSERT INTO ${OKE_KV_TABLE} (namespace, key, value, expires_at, updated_at)
+         VALUES (?, ?, CAST(? AS JSONB), ?, ?)
+         ON CONFLICT (namespace, key) DO UPDATE SET
+           value = EXCLUDED.value,
+           expires_at = EXCLUDED.expires_at,
+           updated_at = EXCLUDED.updated_at`,
+        [namespace, key, JSON.stringify(value), expiresAt, t],
+      );
+    },
+    async delete(key) {
+      const result = await conn.exec(
+        `DELETE FROM ${OKE_KV_TABLE} WHERE namespace = ? AND key = ?`,
+        [namespace, key],
+      );
+      return result.changes > 0;
+    },
+    async list(prefix = "") {
+      const rows = await conn.query(
+        `SELECT key FROM ${OKE_KV_TABLE}
+         WHERE namespace = ?
+           AND (expires_at IS NULL OR expires_at > ?)
+           AND key LIKE ?
+         ORDER BY key`,
+        [namespace, now(), `${prefix}%`],
+      );
+      return rows.map((row) => String(row.key ?? ""));
+    },
+    async ttlMs(key) {
+      const rows = await conn.query(
+        `SELECT expires_at FROM ${OKE_KV_TABLE}
+         WHERE namespace = ? AND key = ?
+           AND (expires_at IS NULL OR expires_at > ?)`,
+        [namespace, key, now()],
+      );
+      const raw = rows[0]?.expires_at;
+      if (raw === undefined || raw === null) return null;
+      const at = Number(raw);
+      if (!Number.isFinite(at)) return null;
+      return Math.max(0, at - now());
+    },
+    async eval() {
+      throw new Error("oke store: durable store.kv does not support eval");
+    },
+    async close() {
+      /* Shared connection — StoreRuntime.close owns it. */
+    },
+    async purgeExpired() {
+      return purgeExpiredOn(conn, now());
+    },
+  };
+}
+
+/**
+ * Decode a JSONB cell — PGlite/Postgres may return an object or a string.
+ *
+ * @param raw - Driver cell
+ */
+function decodeJsonb(raw: unknown): unknown {
+  if (typeof raw === "string") {
+    try {
+      return JSON.parse(raw) as unknown;
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}
+
+/**
+ * Absolute expiry from a TTL string, or `null` when omitted / unparsed.
+ *
+ * @param ttl - Duration like `"7d"`
+ * @param t - Now (epoch ms)
+ */
+function ttlExpiresAt(ttl: string | undefined, t: number): number | null {
+  if (ttl === undefined) return null;
+  const ms = parseTtlMs(ttl);
+  if (ms <= 0) return null;
+  return t + ms;
+}
+
+/**
+ * Delete expired rows across every namespace on this connection.
+ *
+ * @param conn - Shared SQL connection
+ * @param t - Now (epoch ms)
+ */
+async function purgeExpiredOn(conn: SqlConnection, t: number): Promise<number> {
+  const result = await conn.exec(
+    `DELETE FROM ${OKE_KV_TABLE} WHERE expires_at IS NOT NULL AND expires_at <= ?`,
+    [t],
+  );
+  return result.changes;
+}

package/src/elements/store/runtime.ts

@@ -42,6 +42,7 @@ import type {
   SqlStoreDecl,
   StoreDecl,
 } from "./declare.ts";
+import { openSqlKvNamespace } from "./kv-sql.ts";
 import { createGatedFilesStoreHandle, type GatedFilesFxBridge } from "./files-fx.ts";
 import {
   createFilesImagePipeline,
@@ -98,6 +99,11 @@ export interface CreateStoreRuntimeOptions {
    * Boot sets `off` for docker/prod and local+autoPush.
    */
   readonly domainDdl?: DomainDdlMode;
+  /**
+   * Shared SQL URL for durable KV (and apps with no `store.sql()` decl).
+   * Durable namespaces open via `sharedSqlConn`, never a second Redis.
+   */
+  readonly sqlUrl?: string;
 }
 
 /** Per-invocation context when opening a handle through the runtime. */
@@ -118,7 +124,7 @@ export type StoreHandle =
 /** KV handle on `fx.store`. */
 export interface KvStoreFxHandle {
   readonly ref: `kv:${string}`;
-  readonly driverId: "memory" | "redis";
+  readonly driverId: "memory" | "redis" | "postgres" | "pglite";
   get(key: string): Promise<unknown>;
   set(key: string, value: unknown, ttl?: string): Promise<void>;
   delete(key: string): Promise<boolean>;
@@ -383,17 +389,37 @@ export function createStoreRuntime(options: CreateStoreRuntimeOptions): StoreRun
     return sharedSqlConn(sqlDriver, "primary", { url });
   }
 
+  /**
+   * Durable KV — JSONB table on the shared SQL connection.
+   *
+   * @param name - Namespace
+   */
+  async function openDurableKv(name: string): Promise<KvNamespace> {
+    const sqlDriver = options.drivers.sql;
+    if (!sqlDriver) {
+      throw new Error("oke store: durable store.kv needs a configured sql driver");
+    }
+    const firstSql = Object.values(options.sql ?? [])[0];
+    const url = options.sqlUrl ?? firstSql?.primary.url;
+    const conn = await sharedSqlConn(sqlDriver, "primary", { url });
+    return openSqlKvNamespace({ conn, namespace: name, now });
+  }
+
   async function openKv(decl: KvStoreDecl): Promise<KvStoreFxHandle> {
-    const driver = options.drivers.kv;
-    if (!driver) throw new Error("No kv driver configured");
     let ns = kvNs.get(decl.name);
     if (!ns) {
-      const binding = options.kv?.[decl.name] ?? {};
-      ns = await driver.open({
-        name: decl.name,
-        url: binding.url,
-        client: binding.client as never,
-      });
+      if (decl.durable === true) {
+        ns = await openDurableKv(decl.name);
+      } else {
+        const driver = options.drivers.kv;
+        if (!driver) throw new Error("No kv driver configured");
+        const binding = options.kv?.[decl.name] ?? {};
+        ns = await driver.open({
+          name: decl.name,
+          url: binding.url,
+          client: binding.client as never,
+        });
+      }
       kvNs.set(decl.name, ns);
     }
     const driverId = ns.driverId;

package/src/elements/store.test.ts

@@ -63,6 +63,8 @@ describe("store facets", () => {
   test("declares sql · kv · files · index with resource refs", () => {
     expect(store.sql("notes").ref).toBe("sql:notes");
     expect(store.kv("sessions").ref).toBe("kv:sessions");
+    expect(store.kv("ledger", { durable: true }).durable).toBe(true);
+    expect(store.kv("sessions").durable).toBeUndefined();
     expect(store.files("uploads").ref).toBe("files:uploads");
     expect(store.index("kb", { dims: 8 }).ref).toBe("index:kb");
   });

package/src/elements/vault/builtin-adapter.ts

@@ -450,6 +450,23 @@ export function createBuiltinVaultAdapter(opts: CreateBuiltinVaultOptions): Buil
    * @param keyRow - That version's live wrapped DEK
    */
   async function decryptRow(row: SecretRow, keyRow: KeyRow): Promise<string> {
+    try {
+      return await decryptRowOnce(row, keyRow);
+    } catch (err) {
+      // Stale key snapshot: rotation committed and dropped `pending` after
+      // this read. Reload the wrap and retry once — never return torn bytes.
+      if (!(err instanceof VaultError) || err.code !== "INVALID_KEY") throw err;
+      return await decryptRowOnce(row, await readKeyRow(row.id));
+    }
+  }
+
+  /**
+   * Unwrap the DEK and decrypt the value ciphertext.
+   *
+   * @param row - Stored secret version
+   * @param keyRow - That version's wrapped DEK
+   */
+  async function decryptRowOnce(row: SecretRow, keyRow: KeyRow): Promise<string> {
     const path = row.path;
     const version = toInt(row.version);
     const algorithm = row.algorithm as VaultAlgorithm;

package/src/full.ts

@@ -88,6 +88,8 @@ export {
   type SignalDecl,
   type SignalOptions,
   type SignalRuntime,
+  type DeadLetter,
+  type SignalFailureReason,
 } from "./elements/signal.ts";
 
 export {

package/src/index.ts

@@ -71,6 +71,8 @@ export {
   type SignalDecl,
   type SignalOptions,
   type SignalRuntime,
+  type DeadLetter,
+  type SignalFailureReason,
 } from "./elements/signal.ts";
 
 export {
@@ -143,6 +145,8 @@ export {
   type AiModelDecl,
   type AiPromptDecl,
   type AiAgentDecl,
+  type AiMcpServerDecl,
+  type AiMcpServerOptions,
   type AiRuntime,
 } from "./elements/ai.ts";
 

package/src/kernel/app.ts

@@ -37,10 +37,12 @@ import { runWithLocale } from "../i18n/locale-context.ts";
 import { runDurable } from "../elements/clock/durable.ts";
 import { isFlow, type AnyFlowDef } from "./flow.ts";
 import { failureFromUnknown, runCompensationPhase } from "./compensate.ts";
+import { withAbortSignal } from "./abort-scope.ts";
 import { fxRetry } from "./concurrency.ts";
 import {
   createFxContext,
   freezePrincipal,
+  isJsonStreamResult,
   resolveName,
   type CreateFxOptions,
   type Fx,
@@ -85,6 +87,7 @@ import { listBindings, resetBindings, type Binding } from "./on.ts";
 import {
   aiAgentRegistry,
   aiEmbedRegistry,
+  aiMcpServerRegistry,
   aiModelRegistry,
   aiPromptRegistry,
   channelTemplateRegistry,
@@ -531,18 +534,21 @@ function mergeAiOptions(
     readonly prompts: NonNullable<BootOptions["ai"]>["prompts"];
     readonly embeds: NonNullable<BootOptions["ai"]>["embeds"];
     readonly agents: NonNullable<BootOptions["ai"]>["agents"];
+    readonly mcpServers: NonNullable<BootOptions["ai"]>["mcpServers"];
   },
 ): BootOptions["ai"] | undefined {
   const models = mergeUnique(explicit?.models, fromRegistry.models ?? []);
   const prompts = mergeUnique(explicit?.prompts, fromRegistry.prompts ?? []);
   const embeds = mergeUnique(explicit?.embeds, fromRegistry.embeds ?? []);
   const agents = mergeUnique(explicit?.agents, fromRegistry.agents ?? []);
+  const mcpServers = mergeUnique(explicit?.mcpServers, fromRegistry.mcpServers ?? []);
   if (
     explicit === undefined &&
     models.length === 0 &&
     prompts.length === 0 &&
     embeds.length === 0 &&
-    agents.length === 0
+    agents.length === 0 &&
+    mcpServers.length === 0
   ) {
     return undefined;
   }
@@ -552,6 +558,7 @@ function mergeAiOptions(
     ...(prompts.length > 0 ? { prompts } : {}),
     ...(embeds.length > 0 ? { embeds } : {}),
     ...(agents.length > 0 ? { agents } : {}),
+    ...(mcpServers.length > 0 ? { mcpServers } : {}),
   };
 }
 
@@ -570,7 +577,7 @@ export function oke(options: OkeOptions): OkeApp {
   if (registry === "consume") resetBindings();
 
   // Same registry mode drains store.sql/store.files, vault.secret, signal(),
-  // channel.<medium>().template(), and ai.model/prompt/embed/agent —
+  // channel.<medium>().template(), and ai.model/prompt/embed/agent/mcpServer —
   // module-evaluation registries that mirror `on`'s trigger drain
   // (`listBindings`/`resetBindings` above). Explicit `options.stores` /
   // `secrets` / `signals` / `channel.templates` / `ai` are additive, never
@@ -588,6 +595,7 @@ export function oke(options: OkeOptions): OkeApp {
           aiPrompts: [],
           aiEmbeds: [],
           aiAgents: [],
+          aiMcpServers: [],
         }
       : {
           stores: storeRegistry.slice(),
@@ -599,6 +607,7 @@ export function oke(options: OkeOptions): OkeApp {
           aiPrompts: aiPromptRegistry.slice(),
           aiEmbeds: aiEmbedRegistry.slice(),
           aiAgents: aiAgentRegistry.slice(),
+          aiMcpServers: aiMcpServerRegistry.slice(),
         };
   if (registry === "consume") {
     storeRegistry.length = 0;
@@ -610,6 +619,7 @@ export function oke(options: OkeOptions): OkeApp {
     aiPromptRegistry.length = 0;
     aiEmbedRegistry.length = 0;
     aiAgentRegistry.length = 0;
+    aiMcpServerRegistry.length = 0;
   }
   const effectiveStores = mergeUnique(options.stores, registrySnapshot.stores);
   const effectiveSecrets = mergeUnique(options.secrets, registrySnapshot.secrets);
@@ -643,6 +653,7 @@ export function oke(options: OkeOptions): OkeApp {
     prompts: registrySnapshot.aiPrompts,
     embeds: registrySnapshot.aiEmbeds,
     agents: registrySnapshot.aiAgents,
+    mcpServers: registrySnapshot.aiMcpServers,
   });
 
   // Resolve Gate bag early so auth HTTP Bindings join `adopted` + the router
@@ -1149,16 +1160,19 @@ export function oke(options: OkeOptions): OkeApp {
       defaultLocale,
     );
 
-    return runWithLocale({ locale: resolvedLocale, defaultLocale }, () =>
-      executeInLocale({
-        flowDef,
-        input,
-        trigger,
-        extras,
-        resolvedLocale,
-        defaultLocale,
-      }),
-    );
+    return runWithLocale({ locale: resolvedLocale, defaultLocale }, () => {
+      const run = () =>
+        executeInLocale({
+          flowDef,
+          input,
+          trigger,
+          extras,
+          resolvedLocale,
+          defaultLocale,
+        });
+      const signal = extras?.request?.signal;
+      return signal ? withAbortSignal(signal, run) : run();
+    });
   }
 
   async function executeInLocale(args: {
@@ -1451,7 +1465,7 @@ export function oke(options: OkeOptions): OkeApp {
                   durable: flowDef.durable,
                   effects: putEffects,
                 });
-              if (storeAfter && output !== undefined) {
+              if (storeAfter && output !== undefined && !isJsonStreamResult(output)) {
                 const ttlMs =
                   typeof flowDef.cache === "string" ? cache.parseTtlMs(flowDef.cache) : undefined;
                 storeRt.putTier1(
@@ -1499,60 +1513,79 @@ export function oke(options: OkeOptions): OkeApp {
 
     const endedAt = now();
     const durationMs = resolveDurationMs(endedAt - startedAt, performance.now() - startedHr);
+    const streamOut = isJsonStreamResult(result.output) ? result.output : undefined;
+
+    const finalizeRun = async (): Promise<void> => {
+      // Stream rows land in Traces only after close. Measure wall time then
+      // so duration / waterfall cover the open stream, not just TTFB.
+      const recordEndedAt = streamOut ? now() : endedAt;
+      const recordDurationMs = streamOut
+        ? resolveDurationMs(recordEndedAt - startedAt, performance.now() - startedHr)
+        : durationMs;
+      if (journalSession) {
+        inflightRuns.delete(journalSession.runId);
+        const sleeping = ctx.state.sleeping as
+          | { readonly wakeAt: number; readonly label: string; readonly runId: string }
+          | undefined;
+        // Lease-capable stores make the shared row the wake schedule; the
+        // in-process map is only for custom stores without the lease surface.
+        if (sleeping && !hasJournalLease(activeJournal().store)) {
+          sleepingRuns.set(sleeping.runId, {
+            flow: flowDef,
+            input: ctx.input,
+            wakeAt: sleeping.wakeAt,
+          });
+        } else if (!sleeping && isTerminalFailure(result)) {
+          const terminalErr = result.failure ?? result.ctx.error;
+          await runCompensationPhase({
+            flow: flowDef,
+            input: ctx.input,
+            session: journalSession,
+            fx,
+            error: terminalErr,
+          });
+        } else if (!sleeping) {
+          await journalSession.commit("completed", {
+            output: streamOut ? { streamed: true } : result.output,
+          });
+        }
+      }
 
-    if (journalSession) {
-      inflightRuns.delete(journalSession.runId);
-      const sleeping = ctx.state.sleeping as
-        | { readonly wakeAt: number; readonly label: string; readonly runId: string }
-        | undefined;
-      // Lease-capable stores make the shared row the wake schedule; the
-      // in-process map is only for custom stores without the lease surface.
-      if (sleeping && !hasJournalLease(activeJournal().store)) {
-        sleepingRuns.set(sleeping.runId, {
-          flow: flowDef,
-          input: ctx.input,
-          wakeAt: sleeping.wakeAt,
-        });
-      } else if (!sleeping && isTerminalFailure(result)) {
-        const terminalErr = result.failure ?? result.ctx.error;
-        await runCompensationPhase({
-          flow: flowDef,
-          input: ctx.input,
-          session: journalSession,
-          fx,
-          error: terminalErr,
-        });
-      } else if (!sleeping) {
-        await journalSession.commit("completed", { output: result.output });
+      const runsRuntime =
+        booted?.runs ?? (isRunsRuntimeLike(options.runs) ? options.runs : undefined);
+      if (runsRuntime) {
+        const archiveCleartext = archiveFromInput(ctx.input, options.archiveInputFields);
+        const replayInput = redactArchivedFields(ctx.input, options.archiveInputFields);
+        const recordFailure =
+          result.failure ??
+          (isTerminalFailure(result) ? failureFromUnknown(result.ctx.error) : undefined);
+        await runsRuntime.record(
+          {
+            flow: flowDef,
+            trigger,
+            fx,
+            ledger,
+            telemetry,
+            startedAt,
+            endedAt: recordEndedAt,
+            durationMs: recordDurationMs,
+            failure: recordFailure,
+            id: runId,
+            input: replayInput,
+            ...(result.output !== undefined && !recordFailure
+              ? { output: streamOut ? { streamed: true } : result.output }
+              : {}),
+            ...(parentId !== undefined ? { parentId } : {}),
+          },
+          archiveCleartext,
+        );
       }
-    }
+    };
 
-    const runsRuntime =
-      booted?.runs ?? (isRunsRuntimeLike(options.runs) ? options.runs : undefined);
-    if (runsRuntime) {
-      const archiveCleartext = archiveFromInput(ctx.input, options.archiveInputFields);
-      const replayInput = redactArchivedFields(ctx.input, options.archiveInputFields);
-      const recordFailure =
-        result.failure ??
-        (isTerminalFailure(result) ? failureFromUnknown(result.ctx.error) : undefined);
-      await runsRuntime.record(
-        {
-          flow: flowDef,
-          trigger,
-          fx,
-          ledger,
-          telemetry,
-          startedAt,
-          endedAt,
-          durationMs,
-          failure: recordFailure,
-          id: runId,
-          input: replayInput,
-          ...(result.output !== undefined && !recordFailure ? { output: result.output } : {}),
-          ...(parentId !== undefined ? { parentId } : {}),
-        },
-        archiveCleartext,
-      );
+    if (streamOut && !isTerminalFailure(result)) {
+      streamOut.finalize = finalizeRun;
+    } else {
+      await finalizeRun();
     }
 
     return {

package/src/kernel/auto-registry.test.ts

@@ -205,6 +205,10 @@ describe("oke() auto-registry — stores/secrets/signals/channel.templates/ai",
     const summarizeNote = smart.prompt("summarize-note", {
       version: 1,
     });
+    ai.mcpServer("github", {
+      url: "https://mcp.example/github",
+      tools: ["create_issue"],
+    });
 
     const ping = flow("ai.ping", {
       effects: { asks: ["summarize-note"] },
@@ -221,6 +225,7 @@ describe("oke() auto-registry — stores/secrets/signals/channel.templates/ai",
 
     expect(app.$options.ai?.models?.some((m) => m.name === "smart")).toBe(true);
     expect(app.$options.ai?.prompts?.some((p) => p.name === "summarize-note")).toBe(true);
+    expect(app.$options.ai?.mcpServers?.some((s) => s.name === "github")).toBe(true);
 
     const runtime = createAiRuntime({
       models: [smart],

package/src/kernel/boot-bind/ai.ts

@@ -18,6 +18,7 @@ import { openaiCompatibleAiDriver } from "../../drivers/ai-openai-compatible.ts"
 import type { AiDriver, AiOpenOptions } from "../../drivers/ai-types.ts";
 import { createAiRuntime, type AiRuntime } from "../../elements/ai.ts";
 import type { GateRuntime } from "../../elements/gate.ts";
+import type { VaultRuntime } from "../../elements/vault.ts";
 import type { BootOptions } from "../boot.ts";
 
 /**
@@ -28,6 +29,7 @@ import type { BootOptions } from "../boot.ts";
  * @param now - Clock
  * @param env - Active environment
  * @param docker - Prefer compose AI URL when active
+ * @param vault - Optional vault for MCP bearer secrets
  */
 export function bindAi(
   options: BootOptions,
@@ -35,13 +37,21 @@ export function bindAi(
   now: () => number,
   env: ConfigEnv = "test",
   docker = false,
+  vault?: VaultRuntime,
 ): AiRuntime {
   const id = resolveAiDriverId(options, env, docker);
   const driver =
     options.ai?.defaultDriver ?? withOpenDefaults(aiDriverFor(id), openDefaultsFor(id, docker));
   return createAiRuntime({
     ...(options.ai ?? {}),
+    ...(vault ? { resolveSecret: (name: string) => vault.read(name) } : undefined),
     defaultDriver: driver,
+    drivers: {
+      mock: lazyDriver("mock", docker),
+      anthropic: lazyDriver("anthropic", docker),
+      "openai-compatible": lazyDriver("openai-compatible", docker),
+      ollama: lazyDriver("ollama", docker),
+    },
     gates: options.ai?.gates ?? gate,
     now,
   });
@@ -156,6 +166,20 @@ export function aiUrlFor(docker = false): string {
  * @param driver - Base driver
  * @param defaults - Env-derived open options
  */
+/**
+ * Open a protocol driver with env defaults only when a model actually uses it.
+ *
+ * @param id - Driver id
+ * @param docker - Docker mode
+ */
+function lazyDriver(id: string, docker: boolean): AiDriver {
+  const base = aiDriverFor(id);
+  return {
+    id: base.id,
+    open: (opts = {}) => base.open({ ...openDefaultsFor(id, docker), ...opts }),
+  };
+}
+
 function withOpenDefaults(driver: AiDriver, defaults: AiOpenOptions): AiDriver {
   if (Object.keys(defaults).length === 0) return driver;
   return {

package/src/kernel/boot-bind/clock.ts

@@ -124,5 +124,7 @@ export async function bindClock(
     }
   }
 
+  clock.startWakes();
+
   return { clock, clockDecls };
 }