nexus-agents 7.0.1 → 8.0.0

package/dist/{chunk-Y742U2YM.js → chunk-J7SPTP2E.js}

@@ -3,10 +3,10 @@ import {
   getDecisionCostFile,
   getModelSelectionShadowFile,
   isPersistenceEnabled
-} from "./chunk-GBHJ37V3.js";
+} from "./chunk-ITCKXMOH.js";
 import {
   nexusDataPath
-} from "./chunk-OGHEKPLD.js";
+} from "./chunk-MM223CVS.js";
 import {
   __require
 } from "./chunk-ZPWHCABL.js";
@@ -222,8 +222,8 @@ var fileStream;
 function getOutputStream() {
   if (globalDestination === "file" && globalFilePath !== void 0) {
     if (fileStream === void 0) {
-      const fs2 = __require("fs");
-      fileStream = fs2.createWriteStream(globalFilePath, { flags: "a" });
+      const fs = __require("fs");
+      fileStream = fs.createWriteStream(globalFilePath, { flags: "a" });
     }
     return fileStream;
   }
@@ -665,7 +665,7 @@ function truncateSummary(s) {
 }
 
 // src/core/step-bus.ts
-import { EventEmitter } from "events";
+import { EventEmitter } from "node:events";
 var StepBus = class extends EventEmitter {
   emit(eventName, event) {
     return super.emit(eventName, event);
@@ -681,8 +681,8 @@ var stepBus = new StepBus();
 stepBus.setMaxListeners(20);
 
 // src/core/with-step.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { randomBytes } from "crypto";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomBytes } from "node:crypto";
 var als = new AsyncLocalStorage();
 function newStepId() {
   return randomBytes(8).toString("hex");
@@ -1945,7 +1945,7 @@ function blockedBySizeQuirk(identity, matched) {
 }
 
 // src/config/manifest-overlay.ts
-import { existsSync, readFileSync, statSync } from "fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { parse as parseYaml } from "yaml";
 import { z as z2 } from "zod";
 
@@ -2200,56 +2200,56 @@ function mergeOverlays(lower, higher) {
 }
 function loadUserManifestOverlay(options) {
   const logger14 = options?.logger ?? createLogger({ component: "manifest-overlay" });
-  const path2 = options?.path ?? resolveUserManifestPath(options?.env);
-  return loadManifestFile(path2, logger14);
+  const path = options?.path ?? resolveUserManifestPath(options?.env);
+  return loadManifestFile(path, logger14);
 }
-function loadManifestFile(path2, logger14) {
+function loadManifestFile(path, logger14) {
   let exists = false;
   try {
-    exists = existsSync(path2);
+    exists = existsSync(path);
   } catch {
-    return { entries: [], rejections: [], path: path2, status: "missing" };
+    return { entries: [], rejections: [], path, status: "missing" };
   }
   if (!exists) {
-    return { entries: [], rejections: [], path: path2, status: "missing" };
+    return { entries: [], rejections: [], path, status: "missing" };
   }
-  const stat = statSync(path2);
+  const stat = statSync(path);
   if (stat.size === 0) {
-    return { entries: [], rejections: [], path: path2, status: "empty" };
+    return { entries: [], rejections: [], path, status: "empty" };
   }
   if (stat.size > MANIFEST_MAX_BYTES) {
     logger14.warn("Manifest overlay too large; skipping", {
-      path: path2,
+      path,
       size: stat.size,
       max: MANIFEST_MAX_BYTES
     });
-    return { entries: [], rejections: [], path: path2, status: "too-large" };
+    return { entries: [], rejections: [], path, status: "too-large" };
   }
-  const raw = readFileSync(path2, "utf-8");
-  return parseManifest(raw, path2, logger14);
+  const raw = readFileSync(path, "utf-8");
+  return parseManifest(raw, path, logger14);
 }
-function parseManifest(raw, path2, logger14) {
+function parseManifest(raw, path, logger14) {
   let parsed;
   try {
-    if (path2.endsWith(".json")) {
+    if (path.endsWith(".json")) {
       parsed = JSON.parse(raw);
     } else {
       parsed = parseYaml(raw);
     }
   } catch (e) {
     logger14.warn("Manifest overlay parse failure; skipping", {
-      path: path2,
+      path,
       error: e instanceof Error ? e.message : String(e)
     });
-    return { entries: [], rejections: [], path: path2, status: "malformed" };
+    return { entries: [], rejections: [], path, status: "malformed" };
   }
   const shape = ManifestSchema.safeParse(parsed);
   if (!shape.success) {
     logger14.warn("Manifest overlay schema mismatch at root; skipping", {
-      path: path2,
+      path,
       issues: shape.error.issues.slice(0, 5).map((i) => i.message)
     });
-    return { entries: [], rejections: [], path: path2, status: "malformed" };
+    return { entries: [], rejections: [], path, status: "malformed" };
   }
   const entries = [];
   const rejections = [];
@@ -2267,7 +2267,7 @@ function parseManifest(raw, path2, logger14) {
     }
     entries.push(materializeEntry(result.data));
   });
-  return { entries, rejections, path: path2, status: "loaded" };
+  return { entries, rejections, path, status: "loaded" };
 }
 function materializeEntry(input) {
   return {
@@ -2312,14 +2312,14 @@ function pickOptionalFields(input) {
 }
 
 // src/config/models-dev-snapshot-loader.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
 function defaultSnapshotPath() {
   const here = dirname(fileURLToPath(import.meta.url));
   return join(here, "models-dev-snapshot.json");
 }
-function stripMalformedPricing(entries, logger14, path2) {
+function stripMalformedPricing(entries, logger14, path) {
   let strippedPricing = 0;
   const out = entries.map((entry) => {
     const pricing = entry.pricing;
@@ -2334,7 +2334,7 @@ function stripMalformedPricing(entries, logger14, path2) {
   });
   if (strippedPricing > 0) {
     logger14.warn("models.dev snapshot entries had non-numeric pricing; treated as unpriced", {
-      path: path2,
+      path,
       strippedPricing
     });
   }
@@ -2342,50 +2342,50 @@ function stripMalformedPricing(entries, logger14, path2) {
 }
 function loadModelsDevSnapshot(options) {
   const logger14 = createLogger({ component: "models-dev-snapshot" });
-  const path2 = options?.path ?? defaultSnapshotPath();
+  const path = options?.path ?? defaultSnapshotPath();
   let exists = false;
   try {
-    exists = existsSync2(path2);
+    exists = existsSync2(path);
   } catch {
-    return { entries: [], path: path2, status: "missing" };
+    return { entries: [], path, status: "missing" };
   }
   if (!exists) {
-    return { entries: [], path: path2, status: "missing" };
+    return { entries: [], path, status: "missing" };
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync2(path2, "utf-8"));
+    parsed = JSON.parse(readFileSync2(path, "utf-8"));
   } catch (e) {
     logger14.warn("models.dev snapshot parse failure; skipping", {
-      path: path2,
+      path,
       error: e instanceof Error ? e.message : String(e)
     });
-    return { entries: [], path: path2, status: "malformed" };
+    return { entries: [], path, status: "malformed" };
   }
   if (parsed.version !== 1) {
     logger14.warn("models.dev snapshot version unsupported; skipping", {
-      path: path2,
+      path,
       version: parsed.version
     });
-    return { entries: [], path: path2, status: "malformed" };
+    return { entries: [], path, status: "malformed" };
   }
   if (!Array.isArray(parsed.entries)) {
-    logger14.warn("models.dev snapshot missing entries array; skipping", { path: path2 });
-    return { entries: [], path: path2, status: "malformed" };
+    logger14.warn("models.dev snapshot missing entries array; skipping", { path });
+    return { entries: [], path, status: "malformed" };
   }
-  const entries = stripMalformedPricing(parsed.entries, logger14, path2);
+  const entries = stripMalformedPricing(parsed.entries, logger14, path);
   return {
     entries,
-    path: path2,
+    path,
     status: "loaded",
     ...typeof parsed.fetchedAt === "string" ? { fetchedAt: parsed.fetchedAt } : {}
   };
 }
 
 // src/config/models-generated-loader.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 function defaultGeneratedPath() {
   try {
     const dataPath = nexusDataPath("model-registry.generated.json");
@@ -2426,34 +2426,34 @@ function toModelEntry(rec) {
 }
 function loadGeneratedRegistryEntries(options) {
   const logger14 = createLogger({ component: "models-generated" });
-  const path2 = options?.path ?? defaultGeneratedPath();
+  const path = options?.path ?? defaultGeneratedPath();
   let exists = false;
   try {
-    exists = existsSync3(path2);
+    exists = existsSync3(path);
   } catch {
-    return { entries: [], path: path2, status: "missing" };
+    return { entries: [], path, status: "missing" };
   }
-  if (!exists) return { entries: [], path: path2, status: "missing" };
+  if (!exists) return { entries: [], path, status: "missing" };
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync3(path2, "utf-8"));
+    parsed = JSON.parse(readFileSync3(path, "utf-8"));
   } catch (e) {
     logger14.warn("generated registry parse failure; skipping", {
-      path: path2,
+      path,
       error: e instanceof Error ? e.message : String(e)
     });
-    return { entries: [], path: path2, status: "malformed" };
+    return { entries: [], path, status: "malformed" };
   }
   if (!Array.isArray(parsed.entries)) {
-    logger14.warn("generated registry missing entries array; skipping", { path: path2 });
-    return { entries: [], path: path2, status: "malformed" };
+    logger14.warn("generated registry missing entries array; skipping", { path });
+    return { entries: [], path, status: "malformed" };
   }
   const entries = [];
   for (const raw of parsed.entries) {
     const entry = toModelEntry(raw);
     if (entry !== void 0) entries.push(entry);
   }
-  return { entries, path: path2, status: "loaded" };
+  return { entries, path, status: "loaded" };
 }
 
 // src/config/model-registry.ts
@@ -2653,7 +2653,7 @@ function setDefaultRegistry(registry) {
 }
 async function reloadDefaultRegistry() {
   globalRegistry = buildDefaultRegistry();
-  const { resetGlobalRegistry } = await import("./unified-registry-RPT4O3XB.js");
+  const { resetGlobalRegistry } = await import("./unified-registry-D4QCQ36Z.js");
   resetGlobalRegistry();
   return globalRegistry;
 }
@@ -2923,7 +2923,7 @@ function calculateCost(model, inputTokens, outputTokens) {
 }
 
 // src/core/trace-helpers.ts
-import { randomUUID } from "crypto";
+import { randomUUID } from "node:crypto";
 function generateTraceId() {
   return randomUUID();
 }
@@ -3278,10 +3278,6 @@ var Tracer = class {
 };
 setTracerFactory((config) => new Tracer(config));
 
-// src/core/trace-exporter.ts
-import * as fs from "fs";
-import * as path from "path";
-
 // src/cli/ansi-output.ts
 var colorsEnabled = !("NO_COLOR" in process.env) && process.stdout.isTTY;
 var colors = {
@@ -3388,7 +3384,6 @@ function formatPercentage(value, decimals = 0) {
 }
 
 // src/core/artifact.ts
-import { randomUUID as randomUUID2 } from "crypto";
 import { z as z4 } from "zod";
 var ArtifactType = {
   /** Planning documents and task breakdowns */
@@ -3612,8 +3607,8 @@ function safeRegex(pattern, flags) {
 
 // src/core/zod-helpers.ts
 function formatZodIssue(issue) {
-  const path2 = issue.path.length > 0 ? `${issue.path.join(".")}: ` : "";
-  return `${path2}${issue.message}`;
+  const path = issue.path.length > 0 ? `${issue.path.join(".")}: ` : "";
+  return `${path}${issue.message}`;
 }
 function formatZodError(error) {
   return error.issues.map(formatZodIssue).join("; ");
@@ -5037,8 +5032,8 @@ function detectCapabilityGaps(required) {
 }
 
 // src/core/task-analysis/capability-gap-ledger-persistence.ts
-import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname4 } from "path";
+import { appendFileSync, existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4 } from "node:fs";
+import { dirname as dirname3 } from "node:path";
 var DEFAULT_MAX_ENTRIES = 5e3;
 var DEFAULT_RETENTION_DAYS = 90;
 var MAX_EXAMPLE_GOALS = 3;
@@ -5084,7 +5079,7 @@ function loadEntries(filePath, cutoff, maxEntries) {
   const entries = [];
   let malformedLines = 0;
   let expiredEntries = 0;
-  const fileExisted = existsSync5(filePath);
+  const fileExisted = existsSync4(filePath);
   if (!fileExisted) {
     return { entries, report: { fileExisted, loaded: 0, malformedLines: 0, expiredEntries: 0 } };
   }
@@ -5143,7 +5138,7 @@ function createPersistentCapabilityGapLedger(config) {
       }
       if (entries.length > maxEntries) entries.splice(0, entries.length - maxEntries);
       try {
-        mkdirSync2(dirname4(config.filePath), { recursive: true });
+        mkdirSync(dirname3(config.filePath), { recursive: true });
         appendFileSync(config.filePath, `${lines.join("\n")}
 `, "utf-8");
       } catch {
@@ -5349,7 +5344,7 @@ function toExpertTaskAnalysisResult(analysis) {
 }
 
 // src/core/random-provider.ts
-import { randomBytes as randomBytes2, randomInt as cryptoRandomInt, randomUUID as randomUUID3 } from "crypto";
+import { randomBytes as randomBytes2, randomInt as cryptoRandomInt, randomUUID as randomUUID2 } from "node:crypto";
 var CHARS = "abcdefghijklmnopqrstuvwxyz0123456789";
 var UNBIASED_LIMIT = CHARS.length * Math.floor(256 / CHARS.length);
 var SystemRandomProvider = class {
@@ -5392,7 +5387,7 @@ var SystemRandomProvider = class {
     return result;
   }
   uuid() {
-    return randomUUID3();
+    return randomUUID2();
   }
 };
 var globalRandomProvider = new SystemRandomProvider();
@@ -7061,7 +7056,7 @@ var LinUCBBandit = class {
 };
 
 // src/cli-adapters/preference-router.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 
 // src/cli-adapters/preference-router-types.ts
 import { z as z8 } from "zod";
@@ -7182,7 +7177,7 @@ var InMemoryPreferenceStore = class {
 };
 
 // src/cli-adapters/preference-router-extractor.ts
-import { createHash } from "crypto";
+import { createHash } from "node:crypto";
 var CODE_KEYWORDS = [
   "function",
   "class",
@@ -7350,7 +7345,7 @@ var PreferenceRouter = class {
   recordPreference(query, strongModelPreferred, strongModelQuality, weakModelQuality) {
     const features = this.featureExtractor.extract(query);
     const dataPoint = {
-      id: randomUUID4(),
+      id: randomUUID3(),
       query,
       features,
       strongModelPreferred,
@@ -10392,9 +10387,9 @@ function getOutcomeStore() {
 }
 async function attachOutcomeStoreToRegistry(store) {
   try {
-    const { getMemoryRegistry } = await import("./dist-IKZ53APZ.js");
+    const { getMemoryRegistry } = await import("./dist-JK32DFHT.js");
     const { OutcomeStoreAdapter } = await import("./outcome-store-adapter-K4L3RUJE.js");
-    const { ensureSharedMemoryRegistry } = await import("./tool-memory-registry-adapters-IMRSOAAV.js");
+    const { ensureSharedMemoryRegistry } = await import("./tool-memory-registry-adapters-35IPCJLV.js");
     ensureSharedMemoryRegistry();
     getMemoryRegistry().attach("outcomes", new OutcomeStoreAdapter(store));
   } catch {
@@ -11676,7 +11671,7 @@ function createMetricsMiddleware() {
 }
 
 // src/agents/heartbeat-monitor.ts
-import { randomBytes as randomBytes3 } from "crypto";
+import { randomBytes as randomBytes3 } from "node:crypto";
 
 // src/config/defaults-types.ts
 import { z as z15 } from "zod";
@@ -12168,7 +12163,7 @@ function validateTimeout(requestedMs, minMs = VOTE_TIMEOUTS.minMs, maxMs = VOTE_
 }
 
 // src/agents/heartbeat-monitor.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 var DEFAULT_SLOW_THRESHOLD_MS = HEARTBEAT_TIMEOUTS.slowThresholdMs;
 var DEFAULT_STALLED_THRESHOLD_MS = HEARTBEAT_TIMEOUTS.stalledThresholdMs;
 var DEFAULT_ABSOLUTE_MAX_MS = HEARTBEAT_TIMEOUTS.absoluteMaxMs;
@@ -12354,8 +12349,8 @@ function aggregateDecisionCosts(records, windowMs) {
 import { z as z17 } from "zod";
 
 // src/config/jsonl-store.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname5 } from "path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync } from "node:fs";
+import { dirname as dirname4 } from "node:path";
 var DIR_MODE = 448;
 var JsonlStore = class {
   filePath;
@@ -12408,7 +12403,7 @@ var JsonlStore = class {
   // ==========================================================================
   ensureDir() {
     try {
-      mkdirSync3(dirname5(this.filePath), { recursive: true, mode: DIR_MODE });
+      mkdirSync2(dirname4(this.filePath), { recursive: true, mode: DIR_MODE });
     } catch (error) {
       this.logger.warn("Failed to create JSONL store directory", {
         error: getErrorMessage(error),
@@ -12417,7 +12412,7 @@ var JsonlStore = class {
     }
   }
   hydrate() {
-    if (!existsSync6(this.filePath)) {
+    if (!existsSync5(this.filePath)) {
       this.logger.debug("No JSONL file found, starting fresh", { path: this.filePath });
       return;
     }
@@ -12473,7 +12468,7 @@ var JsonlStore = class {
   rewriteFile() {
     try {
       const content = this.records.map((r) => JSON.stringify(r)).join("\n") + "\n";
-      writeFileSync2(this.filePath, content, "utf-8");
+      writeFileSync(this.filePath, content, "utf-8");
       return true;
     } catch (error) {
       this.logger.warn("Failed to rewrite JSONL store file", {
@@ -12718,7 +12713,6 @@ var DecisionCostStore = class {
 };
 
 // src/orchestration/strategy-manifest.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
 import { parse as parseYaml2 } from "yaml";
 import { z as z18 } from "zod";
 var STRATEGY_MANIFEST_SCHEMA_VERSION = 1;
@@ -14745,7 +14739,7 @@ function resolveModelForTier(cliName, tier, opts = {}) {
 }
 
 // src/cli-adapters/model-selection-shadow.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { appendFileSync as appendFileSync3, existsSync as existsSync6, readFileSync as readFileSync6 } from "node:fs";
 import { z as z21 } from "zod";
 function isRouteModelShadowEnabled() {
   return process.env["NEXUS_ROUTE_MODEL_SHADOW"] === "1" && isPersistenceEnabled();
@@ -14796,11 +14790,11 @@ function persistModelSelectionShadowRecord(record) {
 }
 function readModelSelectionShadowRecords() {
   const file = getModelSelectionShadowFile();
-  if (!existsSync8(file)) return [];
+  if (!existsSync6(file)) return [];
   const records = [];
   try {
     const cutoff = Date.now() - READ_LOOKBACK_MS;
-    const lines = readFileSync7(file, "utf-8").split("\n").filter((l) => l.trim().length > 0);
+    const lines = readFileSync6(file, "utf-8").split("\n").filter((l) => l.trim().length > 0);
     for (const line of lines) {
       let parsed;
       try {
@@ -15333,7 +15327,7 @@ var CompositeRouter = class _CompositeRouter {
    */
   async consultUnifiedContext(task) {
     try {
-      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-3OO6N4V6.js");
+      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-CCVDD7TO.js");
       const ctx = await getContextForTask({
         task: task.content,
         category: inferTaskCategory(task.content),
@@ -15852,10 +15846,33 @@ var OrchestratorError = class extends Error {
   }
 };
 
-// src/context/mobimem.ts
-import Database from "better-sqlite3";
-import { dirname as dirname6 } from "path";
-import { mkdirSync as mkdirSync4 } from "fs";
+// src/context/open-database.ts
+import { DatabaseSync } from "node:sqlite";
+import { mkdirSync as mkdirSync3 } from "node:fs";
+import { dirname as dirname5 } from "node:path";
+function isInMemory(dbPath) {
+  return dbPath === ":memory:" || dbPath === "";
+}
+function openSqliteDatabase(dbPath) {
+  if (!isInMemory(dbPath)) {
+    mkdirSync3(dirname5(dbPath), { recursive: true });
+  }
+  const db = new DatabaseSync(dbPath);
+  db.exec("PRAGMA journal_mode = WAL");
+  return makeIdempotentClose(db);
+}
+function makeIdempotentClose(db) {
+  const narrowed = db;
+  return {
+    exec: (sql) => {
+      db.exec(sql);
+    },
+    prepare: narrowed.prepare.bind(narrowed),
+    close: () => {
+      if (db.isOpen) db.close();
+    }
+  };
+}
 
 // src/context/mobimem-types.ts
 import { z as z23 } from "zod";
@@ -15882,10 +15899,10 @@ var MobiMemConfigSchema = z23.object({
 });
 
 // src/context/mobimem-impl.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 
 // src/context/mobimem-impl-helpers.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash2 } from "node:crypto";
 function calculateConfidence2(observationCount) {
   return Math.min(1, Math.log10(observationCount + 1) / 2);
 }
@@ -16033,7 +16050,7 @@ var ProfileMemoryImpl = class {
       return updated;
     }
     const entry = {
-      id: randomUUID5(),
+      id: randomUUID4(),
       entityId,
       entityType,
       preferenceKey,
@@ -16130,7 +16147,7 @@ var ExperienceMemoryImpl = class {
       return updated;
     }
     const entry = {
-      id: randomUUID5(),
+      id: randomUUID4(),
       taskType,
       actionSequence,
       outcome,
@@ -16238,7 +16255,7 @@ var ActionCacheImpl = class {
     const inputHash = hashInput(input);
     const now = new Date(getTimeProvider().now());
     const entry = {
-      id: randomUUID5(),
+      id: randomUUID4(),
       inputHash,
       input,
       result,
@@ -16346,10 +16363,7 @@ var MobiMem = class {
     if (validated.dbPath === ":memory:" || validated.dbPath === "") {
       this.db = null;
     } else {
-      mkdirSync4(dirname6(validated.dbPath), { recursive: true });
-      const db = new Database(validated.dbPath);
-      db.pragma("journal_mode = WAL");
-      this.db = db;
+      this.db = openSqliteDatabase(validated.dbPath);
     }
     this.profile = new ProfileMemoryImpl(this.config, this.db);
     this.experience = new ExperienceMemoryImpl(this.config, this.db);
@@ -16897,6 +16911,7 @@ export {
   PreferenceRouter,
   createPreferenceRouter,
   DEFAULT_ZERO_ROUTER_CONFIG,
+  openSqliteDatabase,
   getSharedMobiMem,
   setSharedMobiMemDbPathResolver,
   buildResearchContext,
@@ -16957,4 +16972,4 @@ export {
   AgentCapability,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-Y742U2YM.js.map
+//# sourceMappingURL=chunk-J7SPTP2E.js.map