nexus-agents 2.102.7 → 2.103.0

package/dist/{chunk-KLYBJUTK.js → chunk-Q732LOXE.js}

@@ -1907,14 +1907,14 @@ var ManifestSchema = z2.object({
   models: z2.array(z2.unknown())
 });
 function loadManifestOverlay(options) {
-  const logger11 = options?.logger ?? createLogger({ component: "manifest-overlay" });
+  const logger14 = options?.logger ?? createLogger({ component: "manifest-overlay" });
   if (options?.path !== void 0) {
-    return loadManifestFile(options.path, logger11);
+    return loadManifestFile(options.path, logger14);
   }
   const userPath = resolveUserManifestPath(options?.env);
   const operatorPath = resolveManifestPath(options?.env);
-  const user = loadManifestFile(userPath, logger11);
-  const operator = loadManifestFile(operatorPath, logger11);
+  const user = loadManifestFile(userPath, logger14);
+  const operator = loadManifestFile(operatorPath, logger14);
   return mergeOverlays(user, operator);
 }
 function mergeOverlays(lower, higher) {
@@ -1931,11 +1931,11 @@ function mergeOverlays(lower, higher) {
   return merged;
 }
 function loadUserManifestOverlay(options) {
-  const logger11 = options?.logger ?? createLogger({ component: "manifest-overlay" });
+  const logger14 = options?.logger ?? createLogger({ component: "manifest-overlay" });
   const path2 = options?.path ?? resolveUserManifestPath(options?.env);
-  return loadManifestFile(path2, logger11);
+  return loadManifestFile(path2, logger14);
 }
-function loadManifestFile(path2, logger11) {
+function loadManifestFile(path2, logger14) {
   let exists = false;
   try {
     exists = existsSync(path2);
@@ -1950,7 +1950,7 @@ function loadManifestFile(path2, logger11) {
     return { entries: [], rejections: [], path: path2, status: "empty" };
   }
   if (stat.size > MANIFEST_MAX_BYTES) {
-    logger11.warn("Manifest overlay too large; skipping", {
+    logger14.warn("Manifest overlay too large; skipping", {
       path: path2,
       size: stat.size,
       max: MANIFEST_MAX_BYTES
@@ -1958,9 +1958,9 @@ function loadManifestFile(path2, logger11) {
     return { entries: [], rejections: [], path: path2, status: "too-large" };
   }
   const raw = readFileSync(path2, "utf-8");
-  return parseManifest(raw, path2, logger11);
+  return parseManifest(raw, path2, logger14);
 }
-function parseManifest(raw, path2, logger11) {
+function parseManifest(raw, path2, logger14) {
   let parsed;
   try {
     if (path2.endsWith(".json")) {
@@ -1969,7 +1969,7 @@ function parseManifest(raw, path2, logger11) {
       parsed = parseYaml(raw);
     }
   } catch (e) {
-    logger11.warn("Manifest overlay parse failure; skipping", {
+    logger14.warn("Manifest overlay parse failure; skipping", {
       path: path2,
       error: e instanceof Error ? e.message : String(e)
     });
@@ -1977,7 +1977,7 @@ function parseManifest(raw, path2, logger11) {
   }
   const shape = ManifestSchema.safeParse(parsed);
   if (!shape.success) {
-    logger11.warn("Manifest overlay schema mismatch at root; skipping", {
+    logger14.warn("Manifest overlay schema mismatch at root; skipping", {
       path: path2,
       issues: shape.error.issues.slice(0, 5).map((i) => i.message)
     });
@@ -2052,7 +2052,7 @@ function defaultSnapshotPath() {
   return join(here, "models-dev-snapshot.json");
 }
 function loadModelsDevSnapshot(options) {
-  const logger11 = createLogger({ component: "models-dev-snapshot" });
+  const logger14 = createLogger({ component: "models-dev-snapshot" });
   const path2 = options?.path ?? defaultSnapshotPath();
   let exists = false;
   try {
@@ -2067,21 +2067,21 @@ function loadModelsDevSnapshot(options) {
   try {
     parsed = JSON.parse(readFileSync2(path2, "utf-8"));
   } catch (e) {
-    logger11.warn("models.dev snapshot parse failure; skipping", {
+    logger14.warn("models.dev snapshot parse failure; skipping", {
       path: path2,
       error: e instanceof Error ? e.message : String(e)
     });
     return { entries: [], path: path2, status: "malformed" };
   }
   if (parsed.version !== 1) {
-    logger11.warn("models.dev snapshot version unsupported; skipping", {
+    logger14.warn("models.dev snapshot version unsupported; skipping", {
       path: path2,
       version: parsed.version
     });
     return { entries: [], path: path2, status: "malformed" };
   }
   if (!Array.isArray(parsed.entries)) {
-    logger11.warn("models.dev snapshot missing entries array; skipping", { path: path2 });
+    logger14.warn("models.dev snapshot missing entries array; skipping", { path: path2 });
     return { entries: [], path: path2, status: "malformed" };
   }
   const entries = parsed.entries;
@@ -2116,7 +2116,7 @@ function toModelEntry(rec) {
   };
 }
 function loadGeneratedRegistryEntries(options) {
-  const logger11 = createLogger({ component: "models-generated" });
+  const logger14 = createLogger({ component: "models-generated" });
   const path2 = options?.path ?? defaultGeneratedPath();
   let exists = false;
   try {
@@ -2129,14 +2129,14 @@ function loadGeneratedRegistryEntries(options) {
   try {
     parsed = JSON.parse(readFileSync3(path2, "utf-8"));
   } catch (e) {
-    logger11.warn("generated registry parse failure; skipping", {
+    logger14.warn("generated registry parse failure; skipping", {
       path: path2,
       error: e instanceof Error ? e.message : String(e)
     });
     return { entries: [], path: path2, status: "malformed" };
   }
   if (!Array.isArray(parsed.entries)) {
-    logger11.warn("generated registry missing entries array; skipping", { path: path2 });
+    logger14.warn("generated registry missing entries array; skipping", { path: path2 });
     return { entries: [], path: path2, status: "malformed" };
   }
   const entries = [];
@@ -4737,9 +4737,9 @@ var DEFAULT_OUTPUT_TOKENS = 500;
 var TopsisRouter = class {
   config;
   logger;
-  constructor(config = {}, logger11) {
+  constructor(config = {}, logger14) {
     this.config = { ...DEFAULT_TOPSIS_CONFIG, ...config };
-    this.logger = logger11 ?? createLogger({ component: "TopsisRouter" });
+    this.logger = logger14 ?? createLogger({ component: "TopsisRouter" });
     this.validateWeights();
   }
   /**
@@ -6096,9 +6096,9 @@ var ZeroRouter = class {
   logger;
   outcomes = [];
   calibrationBias = 0;
-  constructor(config, logger11) {
+  constructor(config, logger14) {
     this.config = ZeroRouterConfigSchema.parse(config ?? {});
-    this.logger = logger11 ?? createLogger({ component: "ZeroRouter" });
+    this.logger = logger14 ?? createLogger({ component: "ZeroRouter" });
     this.logger.debug("ZeroRouter initialized", {
       thresholds: this.config.thresholds,
       enableCalibration: this.config.enableCalibration
@@ -6618,9 +6618,9 @@ var ConfidenceCascadeStage = class {
   routingsCount = 0;
   escalationCount = 0;
   complexityDistribution = { simple: 0, moderate: 0, complex: 0 };
-  constructor(config = {}, logger11) {
+  constructor(config = {}, logger14) {
     this.config = { ...DEFAULT_CONFIG, ...config };
-    this.logger = logger11 ?? createLogger({ component: "ConfidenceCascadeStage" });
+    this.logger = logger14 ?? createLogger({ component: "ConfidenceCascadeStage" });
   }
   canHandle(ctx) {
     return getRemainingCandidates(ctx).length > 0;
@@ -6961,9 +6961,9 @@ var CapabilityMatchStage = class {
     creative: 0,
     general: 0
   };
-  constructor(config = {}, logger11) {
+  constructor(config = {}, logger14) {
     this.config = { ...DEFAULT_CONFIG2, ...config };
-    this.logger = logger11 ?? createLogger({ component: "CapabilityMatchStage" });
+    this.logger = logger14 ?? createLogger({ component: "CapabilityMatchStage" });
   }
   canHandle(ctx) {
     return getRemainingCandidates(ctx).length > 0;
@@ -7119,9 +7119,9 @@ var QualityConstraintStage = class {
   filteredCount = 0;
   fallbackCount = 0;
   constraintViolations = { quality: 0, cost: 0, latency: 0 };
-  constructor(config = {}, logger11) {
+  constructor(config = {}, logger14) {
     this.config = { ...DEFAULT_CONFIG3, ...config };
-    this.logger = logger11 ?? createLogger({ component: "QualityConstraintStage" });
+    this.logger = logger14 ?? createLogger({ component: "QualityConstraintStage" });
   }
   canHandle(ctx) {
     return getRemainingCandidates(ctx).length > 0;
@@ -7329,9 +7329,9 @@ var ResourceStrategyStage = class {
   logger;
   routingsCount = 0;
   tierHistory = [];
-  constructor(config = {}, logger11) {
+  constructor(config = {}, logger14) {
     this.config = { ...DEFAULT_CONFIG4, ...config };
-    this.logger = logger11 ?? createLogger({ component: "ResourceStrategyStage" });
+    this.logger = logger14 ?? createLogger({ component: "ResourceStrategyStage" });
   }
   canHandle(ctx) {
     return getRemainingCandidates(ctx).length > 1;
@@ -7440,10 +7440,10 @@ var DistilledRuleStage = class {
   config;
   logger;
   rulesAppliedCount = 0;
-  constructor(distiller, config, logger11) {
+  constructor(distiller, config, logger14) {
     this.distiller = distiller;
     this.config = { ...DEFAULT_CONFIG5, ...config };
-    this.logger = logger11 ?? createLogger({ component: "DistilledRuleStage" });
+    this.logger = logger14 ?? createLogger({ component: "DistilledRuleStage" });
   }
   canHandle(ctx) {
     const candidates = getRemainingCandidates(ctx);
@@ -7582,10 +7582,10 @@ var KnnRoutingStage = class {
   memory;
   routingsCount = 0;
   matchCount = 0;
-  constructor(memory, config = {}, logger11) {
+  constructor(memory, config = {}, logger14) {
     this.config = { ...DEFAULT_CONFIG6, ...config };
     this.memory = memory;
-    this.logger = logger11 ?? createLogger({ component: "KnnRoutingStage" });
+    this.logger = logger14 ?? createLogger({ component: "KnnRoutingStage" });
   }
   canHandle(ctx) {
     return getRemainingCandidates(ctx).length > 0;
@@ -7800,10 +7800,10 @@ var StrategyDistiller = class {
   rules = /* @__PURE__ */ new Map();
   outcomeCounter = 0;
   lastDistillAt;
-  constructor(outcomeStore, logger11, config) {
+  constructor(outcomeStore, logger14, config) {
     this.outcomeStore = outcomeStore;
     this.config = { ...DEFAULT_DISTILLER_CONFIG, ...config };
-    this.logger = logger11 ?? createLogger({ component: "StrategyDistiller" });
+    this.logger = logger14 ?? createLogger({ component: "StrategyDistiller" });
   }
   /** Called for each processed outcome. Triggers distillation at threshold. */
   onOutcome() {
@@ -7967,18 +7967,18 @@ var StrategyDistiller = class {
     };
   }
 };
-function createStrategyDistiller(outcomeStore, logger11, config) {
-  return new StrategyDistiller(outcomeStore, logger11, config);
+function createStrategyDistiller(outcomeStore, logger14, config) {
+  return new StrategyDistiller(outcomeStore, logger14, config);
 }
 var persistentDistillerFactory;
 function registerPersistentDistillerFactory(factory) {
   persistentDistillerFactory = factory;
 }
-function createPersistentDistillerOrFallback(outcomeStore, logger11) {
+function createPersistentDistillerOrFallback(outcomeStore, logger14) {
   if (persistentDistillerFactory !== void 0) {
-    return persistentDistillerFactory(outcomeStore, logger11);
+    return persistentDistillerFactory(outcomeStore, logger14);
   }
-  return new StrategyDistiller(outcomeStore, logger11);
+  return new StrategyDistiller(outcomeStore, logger14);
 }
 
 // src/orchestration/outcomes/outcome-types.ts
@@ -8659,8 +8659,8 @@ function generateSyntheticPriors() {
   }
   return priors;
 }
-function runWarmUp(logger11) {
-  const log = logger11 ?? createLogger({ component: "warm-up" });
+function runWarmUp(logger14) {
+  const log = logger14 ?? createLogger({ component: "warm-up" });
   const store = getOutcomeStore();
   const existing = store.query();
   const hasSynthetic = existing.some((o) => o.qualitySignals?.includes(SYNTHETIC_MARKER) === true);
@@ -11141,6 +11141,256 @@ function selectWithMemoryInfluence(linucbSelection, memoryResult, deps) {
   return linucbSelection;
 }
 
+// src/config/available-models-cache.ts
+var logger10 = createLogger({ component: "available-models-cache" });
+var DEFAULT_TTL_MS = 5 * 60 * 1e3;
+var DEFAULT_STALE_TTL_MS = 25 * 60 * 1e3;
+var AvailableModelsCache = class {
+  sources;
+  ttlMs;
+  staleTtlMs;
+  now;
+  states;
+  constructor(options) {
+    this.sources = [...options.sources];
+    this.ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+    this.staleTtlMs = options.staleTtlMs ?? DEFAULT_STALE_TTL_MS;
+    this.now = options.now ?? Date.now;
+    this.states = /* @__PURE__ */ new Map();
+    for (const s of this.sources) {
+      this.states.set(s.name, { value: null, fetchedAt: 0, inFlight: null });
+    }
+  }
+  /**
+   * Register a source after construction. Used by adapter factories that
+   * wire themselves into the default cache lazily as they're built.
+   * Duplicate names are ignored (first registration wins, on the
+   * assumption that the same factory might run twice in a test session).
+   */
+  addSource(source) {
+    if (this.states.has(source.name)) return;
+    this.sources.push(source);
+    this.states.set(source.name, { value: null, fetchedAt: 0, inFlight: null });
+  }
+  /**
+   * Remove a previously-registered source. Used by tests + by factories
+   * that want to drop a probe when an adapter is being disposed.
+   */
+  removeSource(name) {
+    this.sources = this.sources.filter((s) => s.name !== name);
+    this.states.delete(name);
+  }
+  /**
+   * Returns the union of every source's available models. Stale-while-
+   * revalidate: serve fresh-or-stale immediately, refresh stale entries
+   * in the background. First call (no cache yet) blocks on every source.
+   */
+  async getAll() {
+    const probes = this.sources.map((s) => this.probeOne(s));
+    const results = await Promise.all(probes);
+    const out = [];
+    for (const r of results) {
+      for (const m of r) out.push(m);
+    }
+    return out;
+  }
+  /** Models reported by one named source (subset of getAll). */
+  async byProvider(sourceName) {
+    const all = await this.getAll();
+    return all.filter((m) => m.source === sourceName);
+  }
+  /** True iff some source currently reports the given model id. */
+  async has(modelId) {
+    const all = await this.getAll();
+    return all.some((m) => m.id === modelId);
+  }
+  /** Force a synchronous refresh of every source — used after a 404. */
+  async refresh() {
+    for (const s of this.sources) {
+      const state = this.states.get(s.name);
+      if (state === void 0) continue;
+      state.fetchedAt = 0;
+      state.value = null;
+    }
+    return this.getAll();
+  }
+  /**
+   * Probe one source. Returns:
+   *  - cached value if still fresh
+   *  - cached value AND kicks a background refresh if stale-but-not-expired
+   *  - blocks on the source if no cache or fully expired
+   *
+   * Source errors yield an empty list (logged) so one bad source can't
+   * poison the union.
+   */
+  async probeOne(source) {
+    const state = this.getState(source.name);
+    const age = this.now() - state.fetchedAt;
+    if (state.value !== null && age < this.ttlMs) {
+      return state.value;
+    }
+    if (state.value !== null && age < this.staleTtlMs) {
+      state.inFlight ??= this.fetchSource(source).finally(() => {
+        state.inFlight = null;
+      });
+      return state.value;
+    }
+    if (state.inFlight !== null) return state.inFlight;
+    state.inFlight = this.fetchSource(source).finally(() => {
+      state.inFlight = null;
+    });
+    return state.inFlight;
+  }
+  async fetchSource(source) {
+    const state = this.getState(source.name);
+    try {
+      const raw = await source.listModels();
+      const value = raw.map((m) => normaliseEntry(m, source));
+      state.value = value;
+      state.fetchedAt = this.now();
+      return value;
+    } catch (e) {
+      logger10.warn("AvailableModelsCache source probe failed", {
+        source: source.name,
+        error: e instanceof Error ? e.message : String(e)
+      });
+      return state.value ?? [];
+    }
+  }
+  getState(name) {
+    const state = this.states.get(name);
+    if (state === void 0) {
+      throw new Error(`AvailableModelsCache: unknown source "${name}"`);
+    }
+    return state;
+  }
+};
+function normaliseEntry(raw, source) {
+  const slash = raw.id.indexOf("/");
+  if (slash > 0 && slash < raw.id.length - 1) {
+    return { id: raw.id, source: source.name, provider: raw.id.slice(0, slash) };
+  }
+  if (source.providerHint !== void 0) {
+    return { id: raw.id, source: source.name, provider: source.providerHint };
+  }
+  return { id: raw.id, source: source.name };
+}
+var defaultCache = null;
+function getDefaultAvailableModelsCache() {
+  defaultCache ??= new AvailableModelsCache({ sources: [] });
+  return defaultCache;
+}
+function setDefaultAvailableModelsCache(cache) {
+  defaultCache = cache;
+}
+
+// src/config/openrouter-models-source.ts
+import { z as z15 } from "zod";
+var OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
+var DEFAULT_TIMEOUT_MS = 8e3;
+var MAX_MODELS = 5e3;
+var MAX_BYTES = 8e6;
+var OpenRouterModelSchema = z15.object({ id: z15.string().min(1).max(256) });
+var OpenRouterModelsResponseSchema = z15.object({ data: z15.array(OpenRouterModelSchema) });
+var logger11 = createLogger({ component: "openrouter-models-source" });
+function parseCatalog(text) {
+  if (text.length > MAX_BYTES) {
+    logger11.warn("OpenRouter catalog exceeds byte cap; ignoring", { bytes: text.length });
+    return [];
+  }
+  const parsed = OpenRouterModelsResponseSchema.safeParse(JSON.parse(text));
+  if (!parsed.success) {
+    logger11.warn("OpenRouter catalog failed schema validation; treating as empty", {
+      error: parsed.error.message
+    });
+    return [];
+  }
+  return parsed.data.data.slice(0, MAX_MODELS).map((m) => ({ id: m.id }));
+}
+async function fetchCatalog(url, timeoutMs, doFetch) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => {
+    controller.abort();
+  }, timeoutMs);
+  try {
+    const res = await doFetch(url, {
+      signal: controller.signal,
+      headers: { accept: "application/json" }
+    });
+    if (!res.ok) {
+      logger11.warn("OpenRouter catalog fetch returned non-OK; treating as empty", {
+        status: res.status
+      });
+      return [];
+    }
+    const declaredLen = res.headers.get("content-length");
+    if (declaredLen !== null && Number(declaredLen) > MAX_BYTES) {
+      logger11.warn("OpenRouter catalog Content-Length exceeds byte cap; ignoring", {
+        bytes: declaredLen
+      });
+      return [];
+    }
+    const ids = parseCatalog(await res.text());
+    logger11.debug("OpenRouter catalog loaded", { count: ids.length });
+    return ids;
+  } catch (error) {
+    logger11.warn("OpenRouter catalog fetch failed; treating as empty", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return [];
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function createOpenRouterModelsSource(opts = {}) {
+  const url = opts.url ?? OPENROUTER_MODELS_URL;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const doFetch = opts.fetchImpl ?? fetch;
+  return {
+    name: "openrouter",
+    providerHint: "openrouter",
+    listModels: () => fetchCatalog(url, timeoutMs, doFetch)
+  };
+}
+
+// src/config/register-model-sources.ts
+var logger12 = createLogger({ component: "register-model-sources" });
+function isDynamicModelsEnabled() {
+  return process.env["NEXUS_DYNAMIC_MODELS"] === "true";
+}
+function hasListModels(adapter) {
+  return typeof adapter === "object" && adapter !== null && typeof adapter.listModels === "function";
+}
+function adapterSource(cliName, adapter) {
+  return {
+    name: cliName,
+    listModels: () => adapter.listModels().then((models) => models.map((m) => ({ id: m.id }))).catch((error) => {
+      logger12.debug("adapter listModels failed; treating as empty", {
+        cli: cliName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    })
+  };
+}
+function buildDefaultModelSources(adapters, opts = {}) {
+  const sources = [];
+  if (opts.includeOpenRouter !== false) {
+    sources.push(createOpenRouterModelsSource());
+  }
+  for (const [cliName, adapter] of adapters) {
+    if (hasListModels(adapter)) {
+      sources.push(adapterSource(cliName, adapter));
+    }
+  }
+  return sources;
+}
+function registerDefaultModelSources(cache, adapters, opts = {}) {
+  for (const source of buildDefaultModelSources(adapters, opts)) {
+    cache.addSource(source);
+  }
+}
+
 // src/cli-adapters/composite-router-outcome.ts
 var sharedAnalyzer3 = createSharedTaskAnalyzer();
 function recordBanditOutcome(cliName, task, reward, deps) {
@@ -11346,7 +11596,7 @@ var CompositeRouter = class _CompositeRouter {
   lastRoutedTask;
   // Track last traceId for metrics correlation (Issue #559)
   lastTraceId;
-  constructor(adapters, config, logger11) {
+  constructor(adapters, config, logger14) {
     const {
       preferenceRouterConfig,
       zeroRouterConfig,
@@ -11363,7 +11613,7 @@ var CompositeRouter = class _CompositeRouter {
       ...baseConfig
     } = config ?? {};
     this.config = CompositeRouterConfigSchema.parse(baseConfig);
-    this.logger = logger11 ?? createLogger({ component: "CompositeRouter" });
+    this.logger = logger14 ?? createLogger({ component: "CompositeRouter" });
     this.adapters = adapters;
     this.cliNames = Array.from(adapters.keys());
     if (metricsCollector !== void 0) {
@@ -11522,7 +11772,7 @@ var CompositeRouter = class _CompositeRouter {
    */
   async consultUnifiedContext(task) {
     try {
-      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-SHT7J6BT.js");
+      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-EFEWHU3Z.js");
       const ctx = await getContextForTask({
         task: task.content,
         category: inferTaskCategory(task.content),
@@ -11858,8 +12108,14 @@ var CompositeRouter = class _CompositeRouter {
     return this.routingMemory;
   }
 };
-function createCompositeRouter(adapters, config, logger11) {
-  return new CompositeRouter(adapters, config, logger11);
+function createCompositeRouter(adapters, config, logger14) {
+  let resolved = config;
+  if (isDynamicModelsEnabled() && config?.availableModelsCache === void 0) {
+    const cache = getDefaultAvailableModelsCache();
+    registerDefaultModelSources(cache, adapters);
+    resolved = { ...config, availableModelsCache: cache };
+  }
+  return new CompositeRouter(adapters, resolved, logger14);
 }
 
 // src/core/types/model.ts
@@ -11914,7 +12170,7 @@ import { dirname as dirname4 } from "path";
 import { mkdirSync as mkdirSync2 } from "fs";
 
 // src/context/mobimem-types.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var DEFAULT_MOBIMEM_CONFIG = {
   dbPath: ":memory:",
   maxProfileEntries: 100,
@@ -11926,15 +12182,15 @@ var DEFAULT_MOBIMEM_CONFIG = {
   minExperienceSuccessRate: 0.7,
   autoEviction: true
 };
-var MobiMemConfigSchema = z15.object({
-  dbPath: z15.string(),
-  maxProfileEntries: z15.number().int().positive().default(100),
-  maxExperiencePatterns: z15.number().int().positive().default(500),
-  maxActionCacheEntries: z15.number().int().positive().default(1e3),
-  actionCacheTtlMs: z15.number().int().positive().default(36e5),
-  minProfileConfidence: z15.number().min(0).max(1).default(0.6),
-  minExperienceSuccessRate: z15.number().min(0).max(1).default(0.7),
-  autoEviction: z15.boolean().default(true)
+var MobiMemConfigSchema = z16.object({
+  dbPath: z16.string(),
+  maxProfileEntries: z16.number().int().positive().default(100),
+  maxExperiencePatterns: z16.number().int().positive().default(500),
+  maxActionCacheEntries: z16.number().int().positive().default(1e3),
+  actionCacheTtlMs: z16.number().int().positive().default(36e5),
+  minProfileConfidence: z16.number().min(0).max(1).default(0.6),
+  minExperienceSuccessRate: z16.number().min(0).max(1).default(0.7),
+  autoEviction: z16.boolean().default(true)
 });
 
 // src/context/mobimem-impl.ts
@@ -12385,7 +12641,7 @@ var ActionCacheImpl = class {
 };
 
 // src/context/mobimem.ts
-var logger10 = createLogger({ component: "MobiMem" });
+var logger13 = createLogger({ component: "MobiMem" });
 var MobiMem = class {
   profile;
   experience;
@@ -12406,7 +12662,7 @@ var MobiMem = class {
     this.profile = new ProfileMemoryImpl(this.config, this.db);
     this.experience = new ExperienceMemoryImpl(this.config, this.db);
     this.action = new ActionCacheImpl(this.config, this.db);
-    logger10.info("MobiMem initialized", {
+    logger13.info("MobiMem initialized", {
       dbPath: validated.dbPath,
       persisted: this.db !== null,
       maxProfileEntries: this.config.maxProfileEntries,
@@ -12439,13 +12695,13 @@ var MobiMem = class {
     if (this.config.autoEviction) {
       const evicted = this.action.evictExpired();
       if (evicted > 0) {
-        logger10.debug("Evicted expired action cache entries", { count: evicted });
+        logger13.debug("Evicted expired action cache entries", { count: evicted });
       }
     }
   }
   close() {
     if (this.db !== null) this.db.close();
-    logger10.info("MobiMem closed");
+    logger13.info("MobiMem closed");
   }
 };
 var sharedInstance = null;
@@ -12707,6 +12963,7 @@ export {
   MANIFEST_MAX_BYTES,
   defaultUserManifestPath,
   loadUserManifestOverlay,
+  loadModelsDevSnapshot,
   loadGeneratedRegistryEntries,
   ModelRegistry,
   getDefaultRegistry,
@@ -12851,6 +13108,10 @@ export {
   getAdaptiveBonus,
   shouldExplore,
   getFallbackChainForCategory,
+  AvailableModelsCache,
+  getDefaultAvailableModelsCache,
+  setDefaultAvailableModelsCache,
+  buildDefaultModelSources,
   CompositeRouter,
   createCompositeRouter,
   ModelCapability,
@@ -12858,4 +13119,4 @@ export {
   ParseError,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-KLYBJUTK.js.map
+//# sourceMappingURL=chunk-Q732LOXE.js.map