@schlessera/brain-ui-server 0.13.0 → 0.14.0

package/src/voice/keyterm-builder.ts

@@ -1,24 +1,34 @@
-import { Database } from "bun:sqlite";
+import type { Database } from "bun:sqlite";
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { join, dirname } from "path";
 import type { Keyterm, PronunciationOverride } from "@schlessera/brain-ui-sdk/protocol";
-
-const BRAIN_PATH =
-  process.env.BRAIN_PATH || join(process.env.HOME || "/root", "brain");
-
-const DEFAULT_LIMIT = Number(process.env.VOICE_KEYTERM_LIMIT || 500);
-
-const CACHE_PATH = join(
-  process.env.VOICE_CACHE_DIR || join(BRAIN_PATH, ".brain-ui"),
-  "keyterms.json"
-);
+import { BrainDbUnavailableError, withBrainDb } from "../db/brain-db.js";
+
+/**
+ * Everything the keyterm builder needs to know about its surroundings —
+ * derived from the resolved ServerConfig by the caller (createApp / the
+ * deployment shell). No ambient environment.
+ */
+export interface KeytermSettings {
+  brainPath: string;
+  /** Directory holding keyterms.json (VOICE_CACHE_DIR). */
+  cacheDir: string;
+  /** Maximum vocabulary size (VOICE_KEYTERM_LIMIT). */
+  limit: number;
+}
 
 // Bump whenever the extractor logic, scoring, or stoplists change so that
 // post-deploy the first request rebuilds the cache instead of serving a
 // stale snapshot baked under the old algorithm.
 const CACHE_VERSION = 2;
 
-const OVERRIDES_PATH = join(BRAIN_PATH, ".voice-overrides.md");
+function cachePath(settings: KeytermSettings): string {
+  return join(settings.cacheDir, "keyterms.json");
+}
+
+function overridesPath(brainPath: string): string {
+  return join(brainPath, ".voice-overrides.md");
+}
 
 // Common English words to exclude from extracted vocab.
 // Kept short and aggressive — anything ambiguous, drop it.
@@ -107,17 +117,19 @@ interface LinkRow {
   target: string;
 }
 
-export interface BuildOptions {
-  limit?: number;
-  brainPath?: string;
-}
-
 export interface KeytermsCache {
   version: number;
   keyterms: string[];
   generatedAt: number;
   count: number;
   overrides: PronunciationOverride[];
+  /**
+   * Set when the brain database's schema is older than this package's SQL —
+   * the vocabulary degrades to empty (voice keeps working, just without
+   * domain bias) instead of erroring. Degraded results are never persisted,
+   * so the first request after `brain index` upgrades the schema rebuilds.
+   */
+  degraded?: true;
 }
 
 function normalize(s: string): string {
@@ -347,10 +359,11 @@ function dedupeAndRank(terms: Keyterm[], limit: number): string[] {
   return sorted.slice(0, limit).map((k) => k.term);
 }
 
-export function loadOverrides(): PronunciationOverride[] {
-  if (!existsSync(OVERRIDES_PATH)) return [];
+export function loadOverrides(brainPath: string): PronunciationOverride[] {
+  const path = overridesPath(brainPath);
+  if (!existsSync(path)) return [];
   try {
-    const md = readFileSync(OVERRIDES_PATH, "utf-8");
+    const md = readFileSync(path, "utf-8");
     const out: PronunciationOverride[] = [];
     for (const line of md.split("\n")) {
       // Format:  - Doe → DOH   (also accepts "->")
@@ -367,47 +380,66 @@ export function loadOverrides(): PronunciationOverride[] {
   }
 }
 
-export function buildKeyterms(opts: BuildOptions = {}): KeytermsCache {
-  const limit = opts.limit ?? DEFAULT_LIMIT;
-  const brainPath = opts.brainPath ?? BRAIN_PATH;
-  const dbPath = join(brainPath, "brain.db");
-
-  if (!existsSync(dbPath)) {
-    throw new Error(`brain.db not found at ${dbPath}`);
-  }
+export function buildKeyterms(settings: KeytermSettings): KeytermsCache {
+  const { brainPath, limit } = settings;
 
-  const db = new Database(dbPath, { readonly: true });
   try {
-    const all: Keyterm[] = [
-      ...extractTags(db),
-      ...extractTitles(db),
-      ...extractPaths(db),
-      ...extractLinks(db),
-      ...extractFromContent(db),
-    ];
-    const keyterms = dedupeAndRank(all, limit);
-    return {
-      version: CACHE_VERSION,
-      keyterms,
-      generatedAt: Date.now(),
-      count: keyterms.length,
-      overrides: loadOverrides(),
-    };
-  } finally {
-    db.close();
+    return withBrainDb(brainPath, {}, (db) => {
+      const all: Keyterm[] = [
+        ...extractTags(db),
+        ...extractTitles(db),
+        ...extractPaths(db),
+        ...extractLinks(db),
+        ...extractFromContent(db),
+      ];
+      const keyterms = dedupeAndRank(all, limit);
+      return {
+        version: CACHE_VERSION,
+        keyterms,
+        generatedAt: Date.now(),
+        count: keyterms.length,
+        overrides: loadOverrides(brainPath),
+      };
+    });
+  } catch (err) {
+    if (err instanceof BrainDbUnavailableError) {
+      if (err.reason === "missing") {
+        // Preserved behavior: no brain.db is a hard error the caller reports.
+        throw new Error(`brain.db not found at ${join(brainPath, "brain.db")}`);
+      }
+      // Schema too old for this package's SQL: degrade to no custom
+      // vocabulary rather than breaking voice entirely. Pronunciation
+      // overrides live in markdown, so they survive.
+      console.warn(
+        `[voice] brain.db schema_version=${err.schemaVersion} is older than this ` +
+          "server's keyterm SQL; serving an empty custom vocabulary until the " +
+          "repo is re-indexed."
+      );
+      return {
+        version: CACHE_VERSION,
+        keyterms: [],
+        generatedAt: Date.now(),
+        count: 0,
+        overrides: loadOverrides(brainPath),
+        degraded: true,
+      };
+    }
+    throw err;
   }
 }
 
-export function writeCache(cache: KeytermsCache): void {
-  const dir = dirname(CACHE_PATH);
+export function writeCache(settings: KeytermSettings, cache: KeytermsCache): void {
+  const path = cachePath(settings);
+  const dir = dirname(path);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(CACHE_PATH, JSON.stringify(cache, null, 2), "utf-8");
+  writeFileSync(path, JSON.stringify(cache, null, 2), "utf-8");
 }
 
-export function readCache(): KeytermsCache | null {
-  if (!existsSync(CACHE_PATH)) return null;
+export function readCache(settings: KeytermSettings): KeytermsCache | null {
+  const path = cachePath(settings);
+  if (!existsSync(path)) return null;
   try {
-    const cache = JSON.parse(readFileSync(CACHE_PATH, "utf-8")) as KeytermsCache;
+    const cache = JSON.parse(readFileSync(path, "utf-8")) as KeytermsCache;
     if (cache.version !== CACHE_VERSION) return null;
     return cache;
   } catch {
@@ -415,12 +447,14 @@ export function readCache(): KeytermsCache | null {
   }
 }
 
-export function getKeyterms(forceRebuild = false): KeytermsCache {
+export function getKeyterms(settings: KeytermSettings, forceRebuild = false): KeytermsCache {
   if (!forceRebuild) {
-    const cached = readCache();
+    const cached = readCache(settings);
     if (cached) return cached;
   }
-  const fresh = buildKeyterms();
-  writeCache(fresh);
+  const fresh = buildKeyterms(settings);
+  // A degraded (schema-too-old) result is served but never persisted — the
+  // cache must not outlive the condition that produced it.
+  if (!fresh.degraded) writeCache(settings, fresh);
   return fresh;
 }

package/src/voice/speech-providers.ts

@@ -8,11 +8,13 @@
  *                 work, so it returns empty url/token.
  *
  * VOICE_PROVIDER selects the provider; default is deepgram when
- * DEEPGRAM_API_KEY is set, else webspeech.
+ * DEEPGRAM_API_KEY is set, else webspeech. Both arrive here as the resolved
+ * {@link VoiceConfig} — this module reads no environment.
  */
 
 import type { SpeechProvider } from "@schlessera/brain-ui-sdk/server";
 import { defineSpeechProvider } from "@schlessera/brain-ui-sdk/server";
+import type { VoiceConfig } from "../config/env.js";
 import { mintDeepgramToken } from "./deepgram-token.js";
 
 const DEEPGRAM_WS_URL = "wss://api.deepgram.com/v1/listen";
@@ -47,23 +49,25 @@ function buildDeepgramUrl(keyterms: string[]): string {
   return url;
 }
 
-export const deepgramSpeechProvider: SpeechProvider = defineSpeechProvider({
-  id: "deepgram",
-  capabilities: {
-    streaming: true,
-    interimResults: true,
-    keyterms: true,
-    endpointing: true,
-  },
-  async createSession({ keyterms }) {
-    const { token, expiresAt } = await mintDeepgramToken(TOKEN_TTL_SECONDS);
-    return {
-      url: buildDeepgramUrl(keyterms),
-      token,
-      expiresAt,
-    };
-  },
-});
+export function createDeepgramSpeechProvider(apiKey: string | null): SpeechProvider {
+  return defineSpeechProvider({
+    id: "deepgram",
+    capabilities: {
+      streaming: true,
+      interimResults: true,
+      keyterms: true,
+      endpointing: true,
+    },
+    async createSession({ keyterms }) {
+      const { token, expiresAt } = await mintDeepgramToken(apiKey, TOKEN_TTL_SECONDS);
+      return {
+        url: buildDeepgramUrl(keyterms),
+        token,
+        expiresAt,
+      };
+    },
+  });
+}
 
 export const webspeechSpeechProvider: SpeechProvider = defineSpeechProvider({
   id: "webspeech",
@@ -80,21 +84,21 @@ export const webspeechSpeechProvider: SpeechProvider = defineSpeechProvider({
 });
 
 /**
- * Select the active speech provider from env.
+ * Select the active speech provider from the resolved voice config.
  *
  * webspeech is OPT-IN ONLY (`VOICE_PROVIDER=webspeech`): on Chromium it streams
  * microphone audio to Google, so it must never be a silent fallback when the
  * Deepgram key goes missing. Every other unresolved case throws so the caller
  * 500s loudly instead of quietly degrading to third-party egress.
  */
-export function pickSpeechProvider(): SpeechProvider {
-  const configured = process.env.VOICE_PROVIDER?.trim().toLowerCase();
+export function pickSpeechProvider(voice: VoiceConfig): SpeechProvider {
+  const configured = voice.provider;
   if (configured === "webspeech") return webspeechSpeechProvider;
   if (configured === "deepgram") {
-    if (!process.env.DEEPGRAM_API_KEY) {
+    if (!voice.deepgramApiKey) {
       throw new Error("VOICE_PROVIDER=deepgram but DEEPGRAM_API_KEY is not set.");
     }
-    return deepgramSpeechProvider;
+    return createDeepgramSpeechProvider(voice.deepgramApiKey);
   }
   if (configured) {
     throw new Error(
@@ -102,7 +106,7 @@ export function pickSpeechProvider(): SpeechProvider {
     );
   }
   // Auto-detect: Deepgram when its key is present; otherwise fail loudly.
-  if (process.env.DEEPGRAM_API_KEY) return deepgramSpeechProvider;
+  if (voice.deepgramApiKey) return createDeepgramSpeechProvider(voice.deepgramApiKey);
   throw new Error(
     'No speech provider configured. Set DEEPGRAM_API_KEY, or set ' +
       'VOICE_PROVIDER=webspeech to explicitly opt into the browser speech API ' +

package/src/ws/bridge.ts

@@ -5,7 +5,6 @@ import type {
   LocationFix,
 } from "@schlessera/brain-ui-sdk/server";
 import { BackendBusyError, BackendRequestError } from "@schlessera/brain-ui-sdk/server";
-import { hasClients } from "./clients.js";
 import { withTurnScope } from "./frames.js";
 import type { RunningTurn } from "./turns.js";
 import type { WsHost } from "./host.js";
@@ -87,7 +86,7 @@ export function makeBridge(
       });
     },
     getLocation: (options) => {
-      if (!hasClients()) {
+      if (!host.clients.hasClients()) {
         return Promise.reject(
           new Error(`No ${host.appName} client is connected to read the location from.`)
         );
@@ -112,7 +111,7 @@ export function makeBridge(
       });
     },
     requestMask: (imagePath, instruction) => {
-      if (!hasClients()) {
+      if (!host.clients.hasClients()) {
         return Promise.reject(
           new Error(`No ${host.appName} client is connected to paint a mask in.`)
         );

package/src/ws/clients.ts

@@ -4,54 +4,51 @@ import { shrinkForReplication } from "./shrink.js";
 /** Minimal structural view of a live socket — all we need to write to it. */
 export type WSContext = { send: (data: string) => void };
 
-/**
- * Every currently-attached client socket. The active agent turn is a
- * process-global singleton (server/src/ws/handler.ts), so all sockets observe
- * the same conversation; streamed output fans out to all of them.
- * Previously the server held a single `activeWs`, so a second connection
- * silently orphaned the first (it stayed open but never received output).
- */
-const clients = new Set<WSContext>();
-
-export function addClient(ws: WSContext): void {
-  clients.add(ws);
-}
-
-export function removeClient(ws: WSContext): void {
-  clients.delete(ws);
-}
-
-export function clientCount(): number {
-  return clients.size;
-}
-
-export function hasClients(): boolean {
-  return clients.size > 0;
-}
-
-/** Test-only: drop all registered sockets. */
-export function resetClientsForTests(): void {
-  clients.clear();
-}
-
 /** Serialize + size-bound a frame, then send it to one specific socket. */
 export function sendTo(ws: WSContext, msg: ServerMessage): void {
   ws.send(JSON.stringify(shrinkForReplication(msg)));
 }
 
 /**
- * Broadcast a frame to every attached client. Serializes once. A failing
- * socket is skipped (its `onClose` will prune it) so one dead peer can't
- * block delivery to the others.
+ * The set of currently-attached client sockets belonging to ONE WsHost. All
+ * sockets of a host observe the same conversations; streamed output fans out
+ * to all of them. (Previously the server held a single `activeWs`, so a second
+ * connection silently orphaned the first — and later a module-global set,
+ * which would have cross-wired two coexisting app instances.)
  */
-export function broadcast(msg: ServerMessage): void {
-  if (clients.size === 0) return;
-  const payload = JSON.stringify(shrinkForReplication(msg));
-  for (const ws of clients) {
-    try {
-      ws.send(payload);
-    } catch {
-      // Drop; the socket's onClose handler removes it from the set.
+export class ClientSet {
+  private readonly clients = new Set<WSContext>();
+
+  add(ws: WSContext): void {
+    this.clients.add(ws);
+  }
+
+  remove(ws: WSContext): void {
+    this.clients.delete(ws);
+  }
+
+  count(): number {
+    return this.clients.size;
+  }
+
+  hasClients(): boolean {
+    return this.clients.size > 0;
+  }
+
+  /**
+   * Broadcast a frame to every attached client. Serializes once. A failing
+   * socket is skipped (its `onClose` will prune it) so one dead peer can't
+   * block delivery to the others.
+   */
+  broadcast(msg: ServerMessage): void {
+    if (this.clients.size === 0) return;
+    const payload = JSON.stringify(shrinkForReplication(msg));
+    for (const ws of this.clients) {
+      try {
+        ws.send(payload);
+      } catch {
+        // Drop; the socket's onClose handler removes it from the set.
+      }
     }
   }
 }

package/src/ws/connection.ts

@@ -1,8 +1,6 @@
 import { upgradeWebSocket, websocket } from "hono/bun";
 import { PROTOCOL_REV } from "@schlessera/brain-ui-sdk/protocol";
 import { parseClientMessage } from "@schlessera/brain-ui-sdk/schemas";
-import { getBackendForSession } from "../agent/backend.js";
-import { addClient, removeClient, hasClients } from "./clients.js";
 import { withTurnScope } from "./frames.js";
 import { sendSessionHistory } from "./history.js";
 import { handleClientMessage } from "./dispatch.js";
@@ -49,7 +47,7 @@ export function createWsUpgrade(host: WsHost) {
           )
         );
         try {
-          const backend = await getBackendForSession(
+          const backend = await host.registry.getBackendForSession(
             catalog.getStoredBackendId(sid) ?? turn.backend.id
           );
           const history = await backend.getHistory(sid);
@@ -57,7 +55,7 @@ export function createWsUpgrade(host: WsHost) {
         } catch (err) {
           console.error("[ws] snapshot-on-connect failed:", err);
         } finally {
-          addClient(ws);
+          host.clients.add(ws);
           host.sendMessage(
             ws,
             withTurnScope(
@@ -74,7 +72,7 @@ export function createWsUpgrade(host: WsHost) {
         return;
       }
 
-      addClient(ws);
+      host.clients.add(ws);
       host.sendMessage(ws, {
         type: "status",
         status: "idle",
@@ -119,11 +117,11 @@ export function createWsUpgrade(host: WsHost) {
 
     onClose(_evt, ws) {
       console.log("[ws] Client disconnected");
-      removeClient(ws);
+      host.clients.remove(ws);
       // Turns keep running in the background. Only reject pending interactive
       // requests once the LAST client leaves — while another client remains it
       // can still answer them.
-      if (hasClients()) return;
+      if (host.clients.hasClients()) return;
       for (const turn of host.coordinator.running) {
         host.coordinator.drainPendingForTurn(turn, "Client disconnected");
       }

package/src/ws/dispatch.ts

@@ -1,5 +1,4 @@
 import type { ClientMessage } from "@schlessera/brain-ui-sdk/protocol";
-import { getBackendForSession } from "../agent/backend.js";
 import type { WSContext } from "./clients.js";
 import { locationErrorText } from "./frames.js";
 import { sendSessionHistory } from "./history.js";
@@ -158,7 +157,7 @@ export async function handleClientMessage(
       });
 
       try {
-        const backend = await getBackendForSession(catalog.getStoredBackendId(msg.sessionId));
+        const backend = await host.registry.getBackendForSession(catalog.getStoredBackendId(msg.sessionId));
         const messages = await backend.getHistory(msg.sessionId);
         sendSessionHistory(ws, msg.sessionId, messages);
         // A resume of a RUNNING session (reattach) must not report idle: idle

package/src/ws/host.ts

@@ -1,11 +1,15 @@
 import type { ServerMessage } from "@schlessera/brain-ui-sdk/protocol";
-import { broadcast, sendTo, type WSContext } from "./clients.js";
+import { ClientSet, sendTo, type WSContext } from "./clients.js";
 import { TurnCoordinator } from "./turns.js";
-import { createSessionCatalog, type SessionCatalog } from "./session-catalog.js";
+import type { SessionCatalog } from "./session-catalog.js";
+import type { BackendRegistry } from "../agent/backend.js";
 
 /** Host-side turn timeout. The backend no longer times out — the host owns it. */
 const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
 
+/** Default cap on concurrently RUNNING sessions (MAX_CONCURRENT_SESSIONS). */
+const DEFAULT_MAX_CONCURRENT_SESSIONS = 3;
+
 /**
  * Budget for the host-side follow-up queue of ONE session (backends without a
  * native `followUp`; with one, messages go into the running turn and none of
@@ -32,56 +36,49 @@ export const QUEUE_MAX_BYTES = 50 * 1024 * 1024;
 export const MAX_SESSION_QUEUE = 50;
 
 export interface WsHostOptions {
-  /** Session persistence seam; defaults to the package's SQLite catalog. */
-  catalog?: SessionCatalog;
+  /** Backend registry resolving profiles/sessions to agent backends. */
+  registry: BackendRegistry;
+  /** Session persistence seam (SQLite catalog in production). */
+  catalog: SessionCatalog;
   /** Display name used in connection/status copy. */
   appName?: string;
   /** Per-turn timeout in ms (default 10 minutes). */
   turnTimeoutMs?: number;
   /**
-   * Deployment-time cap on concurrent RUNNING sessions. Each running turn is
-   * roughly one CLI subprocess, so this bounds memory/CPU. Read per request so
-   * the deploy-time env is honored without a restart.
+   * Cap on concurrent RUNNING sessions. Each running turn is roughly one CLI
+   * subprocess, so this bounds memory/CPU. A function so an embedder can make
+   * it dynamic; createApp passes the resolved config value.
    */
   maxConcurrentSessions?: () => number;
 }
 
-function envMaxConcurrentSessions(): number {
-  return Math.max(1, Number(process.env.MAX_CONCURRENT_SESSIONS) || 3);
-}
-
 /**
  * Everything one WebSocket coordinator instance owns: turn state, the session
- * catalog, branding copy, and the frame senders. Handlers receive this host
- * explicitly instead of reaching for module globals.
+ * catalog, the backend registry, the attached client sockets, branding copy,
+ * and the frame senders. Handlers receive this host explicitly — there is no
+ * module-level default host, so two apps coexist without sharing state.
  */
 export class WsHost {
   readonly coordinator = new TurnCoordinator();
+  readonly clients = new ClientSet();
+  readonly registry: BackendRegistry;
   catalog: SessionCatalog;
   appName: string;
   turnTimeoutMs: number;
   maxConcurrentSessions: () => number;
 
-  constructor(options: WsHostOptions = {}) {
-    this.catalog = options.catalog ?? createSessionCatalog();
+  constructor(options: WsHostOptions) {
+    this.registry = options.registry;
+    this.catalog = options.catalog;
     this.appName = options.appName ?? "Brain UI";
     this.turnTimeoutMs = options.turnTimeoutMs ?? DEFAULT_TIMEOUT_MS;
-    this.maxConcurrentSessions = options.maxConcurrentSessions ?? envMaxConcurrentSessions;
-  }
-
-  /** Re-apply embedder options (createApp configures the default host). */
-  configure(options: WsHostOptions): void {
-    if (options.catalog) this.catalog = options.catalog;
-    if (options.appName) this.appName = options.appName;
-    if (options.turnTimeoutMs) this.turnTimeoutMs = options.turnTimeoutMs;
-    if (options.maxConcurrentSessions) {
-      this.maxConcurrentSessions = options.maxConcurrentSessions;
-    }
+    this.maxConcurrentSessions =
+      options.maxConcurrentSessions ?? (() => DEFAULT_MAX_CONCURRENT_SESSIONS);
   }
 
   /** Fan a frame out to every attached client (size-bounded per frame). */
   sendToClients(msg: ServerMessage): void {
-    broadcast(msg);
+    this.clients.broadcast(msg);
   }
 
   /** Send a frame to one specific socket (size-bounded). */

package/src/ws/routing.ts

@@ -1,10 +1,5 @@
 import type { AgentBackend } from "@schlessera/brain-ui-sdk/server";
-import {
-  getBackendForProfile,
-  getBackendForSession,
-  getDefaultBackend,
-  listAllProviders,
-} from "../agent/backend.js";
+import type { BackendRegistry } from "../agent/backend.js";
 import type { SessionCatalog } from "./session-catalog.js";
 
 /**
@@ -12,12 +7,13 @@ import type { SessionCatalog } from "./session-catalog.js";
  * their stored backend id; new sessions route by the requested profile owner.
  */
 export async function resolveTurnTarget(
+  registry: BackendRegistry,
   catalog: SessionCatalog,
   sessionId: string | undefined,
   requested: string | undefined
 ): Promise<{ profileId?: string; backend: AgentBackend; droppedPin?: string }> {
   if (sessionId) {
-    const backend = await getBackendForSession(catalog.getStoredBackendId(sessionId));
+    const backend = await registry.getBackendForSession(catalog.getStoredBackendId(sessionId));
     const stored = catalog.getStoredProviderId(sessionId);
     const available = await backend.listProfiles();
     if (stored && available.some((profile) => profile.id === stored)) {
@@ -30,14 +26,14 @@ export async function resolveTurnTarget(
   }
 
   if (requested) {
-    const available = await listAllProviders();
+    const available = await registry.listAllProviders();
     if (available.some((profile) => profile.id === requested)) {
-      const backend = await getBackendForProfile(requested);
+      const backend = await registry.getBackendForProfile(requested);
       if (backend) return { backend, profileId: requested };
     }
   }
 
-  const backend = await getDefaultBackend();
+  const backend = await registry.getDefaultBackend();
   const profileId = (await backend.listProfiles())[0]?.id;
   return { backend, ...(profileId ? { profileId } : {}) };
 }

package/src/ws/run-session.ts

@@ -26,7 +26,7 @@ export async function runSession(
   coordinator.startingSessions += 1;
   let target: Awaited<ReturnType<typeof resolveTurnTarget>>;
   try {
-    target = await resolveTurnTarget(host.catalog, initial.sessionId, initial.providerId);
+    target = await resolveTurnTarget(host.registry, host.catalog, initial.sessionId, initial.providerId);
   } catch (err) {
     host.sendToClients({
       type: "error",

package/src/ws/session-catalog.ts

@@ -1,6 +1,5 @@
 import type { Database } from "bun:sqlite";
 import type { ServerResultMessage } from "@schlessera/brain-ui-sdk/protocol";
-import { getDb } from "../db/client.js";
 
 /**
  * Persistence seam for session ownership + accounting. The ws coordinator only
@@ -42,8 +41,8 @@ const UPSERT_SESSION_SQL = `INSERT INTO sessions (id, title, created_at, last_ac
      provider_id = COALESCE(excluded.provider_id, provider_id),
      backend_id = COALESCE(excluded.backend_id, backend_id)`;
 
-/** SQLite-backed catalog over the package's session database. */
-export function createSessionCatalog(db: () => Database = getDb): SessionCatalog {
+/** SQLite-backed catalog over the app's own database (injected by createApp). */
+export function createSessionCatalog(db: () => Database): SessionCatalog {
   return {
     getStoredProviderId(sessionId) {
       const row = db()