Merge remote-tracking branch 'origin/release/v3.8.50' into HEAD

- Add muse-code to APIKEY_PROVIDERS_FRONTIER so check:provider-consistency passes
- Regenerate translate-path golden snapshot to include the muse-code entry
  (20 additive lines, no other providers changed)

@omniroute/opencode-plugin/src/index.ts

@@ -1033,11 +1033,7 @@ export const OmniRoutePlugin: Plugin = async (_input, options) => {
   // Config hook: keep existing catalog shim, and register slash command
   // templates that ask the agent to call the force-sync tool (OpenCode has no
   // Pi-style registerCommand API; tools + command templates are the native path).
-  const baseConfigHook = createOmniRouteConfigHook(resolved, {
-    cache: sharedCache,
-    diskSnapshotReader: defaultDiskSnapshotReader,
-    diskSnapshotWriter: defaultDiskSnapshotWriter,
-  });
+  const baseConfigHook = createOmniRouteConfigHook(resolved, { cache: sharedCache });
   const configWithSyncCommand = async (input: Config) => {
     await baseConfigHook(input);
     const cfg = input as Config & {
@@ -4745,7 +4741,7 @@ export type OmniRouteDiskSnapshotWriter = (
 export type OmniRouteDiskSnapshotReader = (
   providerId: string,
   identityFingerprint: string
-) => Promise<(Omit<OmniRouteFetchCacheEntry, "expiresAt"> & { writtenAt?: number }) | undefined>;
+) => Promise<Omit<OmniRouteFetchCacheEntry, "expiresAt"> | undefined>;
 
 /**
  * Bind a snapshot to the endpoint and effective credential tuple without
@@ -4828,36 +4824,15 @@ export const defaultDiskSnapshotReader: OmniRouteDiskSnapshotReader = async (
         ? parsed.rawCompressionCombos
         : [],
       rawConnections: Array.isArray(parsed.rawConnections) ? parsed.rawConnections : [],
-      writtenAt: typeof parsed.writtenAt === "number" ? parsed.writtenAt : undefined,
     };
   } catch {
     return undefined;
   }
 };
 
-/** No-op disk-cache pair — used by tests to avoid filesystem side effects.
- * Also used as the default in createOmniRouteConfigHook so that tests
- * that don't pass a diskSnapshotReader don't read real snapshot files
- * from the user's ~/.local/share/opencode/plugins/ directory.
- * The OmniRoutePlugin function passes the real defaultDiskSnapshotReader
- * explicitly. */
-export const noopDiskSnapshotReader: OmniRouteDiskSnapshotReader = async () => undefined;
+/** No-op disk-cache pair — used by tests to avoid filesystem side effects. */
 export const noopDiskSnapshotWriter: OmniRouteDiskSnapshotWriter = async () => {};
 
-/**
- * In-flight refresh guard: prevents concurrent refreshes for the same
- * cacheKey. When a warm snapshot is served, the refresh runs detached; if
- * a second hook invocation arrives before the refresh completes, it should
- * piggyback on the in-flight promise rather than starting a second one.
- * Cleared on settle so it doesn't leak.
- */
-const _inflightRefresh: Map<string, Promise<void>> = new Map();
-
-/** Reset the in-flight refresh guard (for test isolation). */
-export function _resetInflightRefresh(): void {
-  _inflightRefresh.clear();
-}
-
 // ────────────────────────────────────────────────────────────────────────────
 // Debug logging (features.debugLog)
 // ────────────────────────────────────────────────────────────────────────────
@@ -5092,6 +5067,7 @@ export function createDebugLoggingFetch(
     }
   };
 }
+export const noopDiskSnapshotReader: OmniRouteDiskSnapshotReader = async () => undefined;
 
 export type OmniRouteReadAuthJson = () => Promise<AuthJsonShape | undefined | null>;
 
@@ -5194,8 +5170,8 @@ export function createOmniRouteConfigHook(
   const compressionMetaFetcher =
     deps.compressionMetaFetcher ?? defaultOmniRouteCompressionMetaFetcher;
   const providersFetcher = deps.providersFetcher ?? defaultOmniRouteProvidersFetcher;
-  const diskSnapshotReader = deps.diskSnapshotReader ?? noopDiskSnapshotReader;
-  const diskSnapshotWriter = deps.diskSnapshotWriter ?? noopDiskSnapshotWriter;
+  const diskSnapshotReader = deps.diskSnapshotReader ?? defaultDiskSnapshotReader;
+  const diskSnapshotWriter = deps.diskSnapshotWriter ?? defaultDiskSnapshotWriter;
   const now = deps.now ?? Date.now;
   const cache: OmniRouteFetchCache = deps.cache ?? new Map();
   const logger = deps.logger ?? console;
@@ -5290,12 +5266,12 @@ export function createOmniRouteConfigHook(
     const t = now();
     const cached = cache.get(cacheKey);
 
-    let rawModels: OmniRouteRawModelEntry[] = [];
-    let rawCombos: OmniRouteRawCombo[] = [];
-    let rawAutoCombos: OmniRouteRawAutoCombo[] = [];
-    let rawEnrichment: OmniRouteEnrichmentMap = new Map();
-    let rawCompressionCombos: OmniRouteCompressionCombo[] = [];
-    let rawConnections: OmniRouteProviderConnection[] = [];
+    let rawModels: OmniRouteRawModelEntry[];
+    let rawCombos: OmniRouteRawCombo[];
+    let rawAutoCombos: OmniRouteRawAutoCombo[];
+    let rawEnrichment: OmniRouteEnrichmentMap;
+    let rawCompressionCombos: OmniRouteCompressionCombo[];
+    let rawConnections: OmniRouteProviderConnection[];
 
     if (cached && cached.expiresAt > t) {
       rawModels = cached.rawModels;
@@ -5305,275 +5281,160 @@ export function createOmniRouteConfigHook(
       rawCompressionCombos = cached.rawCompressionCombos;
       rawConnections = cached.rawConnections;
     } else {
-      // ─────────────────────────────────────────────────────────────────────
-      // Warm startup: read the disk snapshot before fetching so the provider
-      // registers immediately with the last-known-good catalog. The live
-      // fetch then refreshes in the background (detached) and updates the
-      // cache + snapshot. Gated by features.diskCache (default-on).
-      // ─────────────────────────────────────────────────────────────────────
-      let warmSnapshot: Omit<OmniRouteFetchCacheEntry, "expiresAt"> | undefined;
-      if (wantDiskCache) {
-        const snapshotResult = await diskSnapshotReader(resolved.providerId, snapshotFingerprint);
-        if (snapshotResult && snapshotResult.rawModels.length > 0) {
-          warmSnapshot = snapshotResult;
-          // Log snapshot age (accept any age — instant beats empty).
-          const age = (snapshotResult as { writtenAt?: number }).writtenAt;
-          const ageLabel = typeof age === "number" ? `${Math.round((Date.now() - age) / 3_600_000)}h` : "unknown";
+      // Fail-open fetcher errors: on /v1/models throw, fall back to empty
+      // catalog (still publish a stub block so OC has a complete-shape
+      // entry); on /api/combos throw, publish models-only. Disk-cache
+      // fallback below recovers the last-known-good catalog when the
+      // fetcher threw (network down / 403 / timeout) AND features.diskCache
+      // !== false. A 0-entry SUCCESS (fresh tenant) does NOT trigger
+      // disk fallback — that's a valid empty catalog.
+      let modelsFetchThrew = false;
+      try {
+        rawModels = await fetcher(baseURL, apiKey, 10_000);
+      } catch (err) {
+        logger.warn(
+          "[omniroute-plugin] config shim: /v1/models fetch failed; publishing stub provider entry",
+          err
+        );
+        rawModels = [];
+        modelsFetchThrew = true;
+      }
+      const modelsFetchOk = !modelsFetchThrew && rawModels.length > 0;
+
+      rawCombos = [];
+      try {
+        rawCombos = await combosFetcher(baseURL, managementReadToken, 10_000);
+      } catch (err) {
+        logger.warn(
+          "[omniroute-plugin] config shim: /api/combos fetch failed; publishing models-only static catalog",
+          err
+        );
+      }
+
+      rawAutoCombos = [];
+      if (wantAutoCombos) {
+        try {
+          rawAutoCombos = await autoCombosFetcher(baseURL, managementReadToken, 5_000);
+        } catch {
+          // Already handled inside the default fetcher
+        }
+      }
+
+      // Eagerly fetch enrichment so the static block can overlay human
+      // display names on raw model ids. On OC ≤1.15.5 the dynamic
+      // `provider.models` hook never fires in `serve` mode, so the static
+      // block IS what reaches `/provider` and the TUI model picker.
+      // Gated by `features.enrichment` (default-on). Soft-fail on error —
+      // we still publish a name-less catalog if /api/pricing/models is
+      // unreachable.
+      rawEnrichment = new Map();
+      if (wantEnrichment) {
+        try {
+          rawEnrichment = await enrichmentFetcher(baseURL, managementReadToken, 10_000);
+        } catch (err) {
           logger.warn(
-            `[omniroute-plugin] config shim: warm startup from disk snapshot (${snapshotResult.rawModels.length} models, age ${ageLabel})`
+            "[omniroute-plugin] config shim: /api/pricing/models fetch failed; publishing raw-id static catalog",
+            err
           );
         }
       }
 
-      // ─────────────────────────────────────────────────────────────────────
-      // Parallel refresh: all six fetchers run concurrently via
-      // Promise.allSettled. Each wrapper never rejects (catches internally)
-      // so partial failure is tolerated — same soft-fail semantics as the
-      // old sequential chain, but ~6x faster.
-      // ─────────────────────────────────────────────────────────────────────
-      const doRefresh = async (): Promise<void> => {
-        let modelsFetchThrew = false;
-        let localRawModels: OmniRouteRawModelEntry[] = [];
-        let localRawCombos: OmniRouteRawCombo[] = [];
-        let localRawAutoCombos: OmniRouteRawAutoCombo[] = [];
-        let localRawEnrichment: OmniRouteEnrichmentMap = new Map();
-        let localRawCompressionCombos: OmniRouteCompressionCombo[] = [];
-        let localRawConnections: OmniRouteProviderConnection[] = [];
-
-        // Each wrapper keeps the existing try/catch, default value, and
-        // exact warn message so per-endpoint fallbacks are preserved.
-        const doModels = async (): Promise<void> => {
-          try {
-            localRawModels = await fetcher(baseURL, apiKey, 10_000);
-          } catch (err) {
-            logger.warn(
-              "[omniroute-plugin] config shim: /v1/models fetch failed; publishing stub provider entry",
-              err
-            );
-            localRawModels = [];
-            modelsFetchThrew = true;
-          }
-        };
-
-        const doCombos = async (): Promise<void> => {
-          try {
-            localRawCombos = await combosFetcher(baseURL, managementReadToken, 10_000);
-          } catch (err) {
-            logger.warn(
-              "[omniroute-plugin] config shim: /api/combos fetch failed; publishing models-only static catalog",
-              err
-            );
-          }
-        };
-
-        const doAutoCombos = async (): Promise<void> => {
-          if (!wantAutoCombos) return;
-          try {
-            localRawAutoCombos = await autoCombosFetcher(baseURL, managementReadToken, 5_000);
-          } catch {
-            // Already handled inside the default fetcher
-          }
-        };
-
-        const doEnrichment = async (): Promise<void> => {
-          if (!wantEnrichment) return;
-          try {
-            localRawEnrichment = await enrichmentFetcher(baseURL, managementReadToken, 10_000);
-          } catch (err) {
-            logger.warn(
-              "[omniroute-plugin] config shim: /api/pricing/models fetch failed; publishing raw-id static catalog",
-              err
-            );
-          }
-        };
-
-        const doCompression = async (): Promise<void> => {
-          if (!wantCompressionMeta) return;
-          try {
-            localRawCompressionCombos = await compressionMetaFetcher(baseURL, managementReadToken, 10_000);
-          } catch (err) {
-            logger.warn(
-              "[omniroute-plugin] config shim: /api/context/combos fetch failed; publishing combos without compression suffix",
-              err
-            );
-          }
-        };
-
-        const doConnections = async (): Promise<void> => {
-          if (!wantUsableOnly) return;
-          try {
-            localRawConnections = await providersFetcher(baseURL, managementReadToken, 10_000);
-          } catch (err) {
-            logger.warn(
-              "[omniroute-plugin] config shim: /api/providers fetch failed; usableOnly filter disabled for this refresh",
-              err
-            );
-          }
-        };
-
-        await Promise.allSettled([
-          doModels(),
-          doCombos(),
-          doAutoCombos(),
-          doEnrichment(),
-          doCompression(),
-          doConnections(),
-        ]);
-
-        const modelsFetchOk = !modelsFetchThrew && localRawModels.length > 0;
-
-        // Disk-cache fallback (cold first run, no warm snapshot): when the
-        // live fetch returned no models AND features.diskCache !== false,
-        // hydrate from the last-known-good snapshot so OC still surfaces a
-        // usable catalog (e.g. IP whitelist drop, offline laptop).
-        if (modelsFetchThrew && wantDiskCache && !warmSnapshot) {
-          const snapshot = await diskSnapshotReader(resolved.providerId, snapshotFingerprint);
-          if (snapshot && snapshot.rawModels.length > 0) {
-            logger.warn(
-              `[omniroute-plugin] config shim: /v1/models unreachable; using stale disk cache (${snapshot.rawModels.length} models)`
-            );
-            localRawModels = snapshot.rawModels;
-            localRawCombos = snapshot.rawCombos;
-            localRawAutoCombos = snapshot.rawAutoCombos ?? [];
-            localRawEnrichment = snapshot.rawEnrichment;
-            localRawCompressionCombos = snapshot.rawCompressionCombos;
-            localRawConnections = snapshot.rawConnections;
-          }
+      // Compression-metadata fetch — opt-in via features.compressionMetadata.
+      // When on, the default pipeline is appended to every combo `name` so
+      // the TUI picker advertises which compression a combo applies.
+      rawCompressionCombos = [];
+      if (wantCompressionMeta) {
+        try {
+          rawCompressionCombos = await compressionMetaFetcher(baseURL, managementReadToken, 10_000);
+        } catch (err) {
+          logger.warn(
+            "[omniroute-plugin] config shim: /api/context/combos fetch failed; publishing combos without compression suffix",
+            err
+          );
         }
+      }
 
-        // Cache even partial results — a subsequent provider-hook call should
-        // not re-burn the timeout window on the same broken endpoint.
-        cache.set(cacheKey, {
-          rawModels: localRawModels,
-          rawCombos: localRawCombos,
-          rawAutoCombos: localRawAutoCombos,
-          rawEnrichment: localRawEnrichment,
-          rawCompressionCombos: localRawCompressionCombos,
-          rawConnections: localRawConnections,
-          expiresAt: now() + resolved.modelCacheTtl,
+      // Provider-connections fetch — opt-in via features.usableOnly. When
+      // on, the static catalog filters out models/combos whose canonical
+      // provider has no active connection. Soft-fail (empty list) disables
+      // the filter for this refresh, never hiding the whole catalog.
+      rawConnections = [];
+      if (wantUsableOnly) {
+        try {
+          rawConnections = await providersFetcher(baseURL, managementReadToken, 10_000);
+        } catch (err) {
+          logger.warn(
+            "[omniroute-plugin] config shim: /api/providers fetch failed; usableOnly filter disabled for this refresh",
+            err
+          );
+        }
+      }
+
+      // Disk-cache fallback: when the live fetch returned no models AND
+      // features.diskCache !== false, hydrate from the last-known-good
+      // snapshot so OC still surfaces a usable catalog (e.g. IP whitelist
+      // drop, offline laptop). The snapshot is whatever we last wrote on
+      // a healthy refresh; staleness is bounded only by how recently the
+      // user was online.
+      if (modelsFetchThrew && wantDiskCache) {
+        const snapshot = await diskSnapshotReader(resolved.providerId, snapshotFingerprint);
+        if (snapshot && snapshot.rawModels.length > 0) {
+          logger.warn(
+            `[omniroute-plugin] config shim: /v1/models unreachable; using stale disk cache (${snapshot.rawModels.length} models)`
+          );
+          rawModels = snapshot.rawModels;
+          rawCombos = snapshot.rawCombos;
+          rawAutoCombos = snapshot.rawAutoCombos ?? [];
+          rawEnrichment = snapshot.rawEnrichment;
+          rawCompressionCombos = snapshot.rawCompressionCombos;
+          rawConnections = snapshot.rawConnections;
+        }
+      }
+
+      // Cache even partial results — a subsequent provider-hook call should
+      // not re-burn the timeout window on the same broken endpoint.
+      cache.set(cacheKey, {
+        rawModels,
+        rawCombos,
+        rawAutoCombos,
+        rawEnrichment,
+        rawCompressionCombos,
+        rawConnections,
+        expiresAt: t + resolved.modelCacheTtl,
+      });
+
+      // Startup diagnostics (file-based) — fires at startup via config hook
+      if (resolved.features?.startupDebug === true) {
+        await writeStartupDiagnostics({
+          providerId: resolved.providerId,
+          baseURL,
+          modelCount: rawModels.length,
+          comboCount: rawCombos.length,
+          enrichmentSize: rawEnrichment.size,
+          autoComboCount: rawAutoCombos.length,
+          enrichment: rawEnrichment,
+          autoCombos: rawAutoCombos,
+          features: resolved.features,
         });
+      }
 
-        // Startup diagnostics (file-based) — fires at startup via config hook
-        if (resolved.features?.startupDebug === true) {
-          await writeStartupDiagnostics({
-            providerId: resolved.providerId,
-            baseURL,
-            modelCount: localRawModels.length,
-            comboCount: localRawCombos.length,
-            enrichmentSize: localRawEnrichment.size,
-            autoComboCount: localRawAutoCombos.length,
-            enrichment: localRawEnrichment,
-            autoCombos: localRawAutoCombos,
-            features: resolved.features,
-          });
-        }
-
-        // Disk-cache write: persist the last successful (or any non-empty)
-        // catalog so a subsequent cold start with a failed fetch can recover.
-        // Best-effort; soft-fail keeps us moving when the data dir isn't
-        // writable (e.g. read-only container). A failed refresh never
-        // overwrites the snapshot (modelsFetchOk gate).
-        if (modelsFetchOk && wantDiskCache) {
-          await diskSnapshotWriter(
-            resolved.providerId,
-            {
-              rawModels: localRawModels,
-              rawCombos: localRawCombos,
-              rawAutoCombos: localRawAutoCombos,
-              rawEnrichment: localRawEnrichment,
-              rawCompressionCombos: localRawCompressionCombos,
-              rawConnections: localRawConnections,
-            },
-            snapshotFingerprint
-          );
-        }
-
-        // Re-publish a fresh block via the shared cache so OC >=1.14.49's
-        // dynamic provider hook picks it up from the cache. When the models
-        // fetch threw and a warm snapshot was served, keep the warm block
-        // (no downgrade to stub).
-        if (modelsFetchOk || !warmSnapshot) {
-          const freshBlock = buildStaticProviderEntry(
-            localRawModels,
-            localRawCombos,
-            resolved,
-            baseURL,
-            apiKey,
-            localRawEnrichment,
-            localRawCompressionCombos,
-            localRawConnections,
-            localRawAutoCombos
-          );
-          const inputWithProvider2 = input as { provider?: Record<string, unknown> };
-          if (inputWithProvider2.provider) {
-            inputWithProvider2.provider[resolved.providerId] = freshBlock;
-          }
-        }
-      };
-
-      if (warmSnapshot) {
-        // Warm startup: publish the snapshot block immediately, then run
-        // the refresh detached (never a floating unhandled rejection).
-        rawModels = warmSnapshot.rawModels;
-        rawCombos = warmSnapshot.rawCombos;
-        rawAutoCombos = warmSnapshot.rawAutoCombos ?? [];
-        rawEnrichment = warmSnapshot.rawEnrichment;
-        rawCompressionCombos = warmSnapshot.rawCompressionCombos;
-        rawConnections = warmSnapshot.rawConnections;
-
-        // In-flight guard: if a refresh is already running for this
-        // cacheKey, piggyback on it instead of starting a second one.
-        const existing = _inflightRefresh.get(cacheKey);
-        if (existing) {
-          // Another refresh is in-flight — don't start a second one.
-          // The existing refresh will update the cache when it completes.
-        } else {
-          const refreshP = doRefresh()
-            .catch((err: unknown) => {
-              logger.warn("[omniroute-plugin] config shim: background refresh failed", err);
-            })
-            .finally(() => {
-              _inflightRefresh.delete(cacheKey);
-            });
-          _inflightRefresh.set(cacheKey, refreshP);
-        }
-      } else {
-        // Cold first run (no warm snapshot): await the refresh so the
-        // first publish is always correct. In-flight guard still applies.
-        const existing = _inflightRefresh.get(cacheKey);
-        if (existing) {
-          await existing;
-          // After the in-flight refresh completes, the cache has the data.
-          const fresh = cache.get(cacheKey);
-          if (fresh) {
-            rawModels = fresh.rawModels;
-            rawCombos = fresh.rawCombos;
-            rawAutoCombos = fresh.rawAutoCombos;
-            rawEnrichment = fresh.rawEnrichment;
-            rawCompressionCombos = fresh.rawCompressionCombos;
-            rawConnections = fresh.rawConnections;
-          }
-        } else {
-          const refreshP = doRefresh()
-            .catch((err: unknown) => {
-              logger.warn("[omniroute-plugin] config shim: refresh failed", err);
-            })
-            .finally(() => {
-              _inflightRefresh.delete(cacheKey);
-            });
-          _inflightRefresh.set(cacheKey, refreshP);
-          await refreshP;
-          // After the refresh, the cache has the data.
-          const fresh = cache.get(cacheKey);
-          if (fresh) {
-            rawModels = fresh.rawModels;
-            rawCombos = fresh.rawCombos;
-            rawAutoCombos = fresh.rawAutoCombos;
-            rawEnrichment = fresh.rawEnrichment;
-            rawCompressionCombos = fresh.rawCompressionCombos;
-            rawConnections = fresh.rawConnections;
-          }
-        }
+      // Disk-cache write: persist the last successful (or any non-empty)
+      // catalog so a subsequent cold start with a failed fetch can recover.
+      // Best-effort; soft-fail keeps us moving when the data dir isn't
+      // writable (e.g. read-only container).
+      if (modelsFetchOk && wantDiskCache) {
+        await diskSnapshotWriter(
+          resolved.providerId,
+          {
+            rawModels,
+            rawCombos,
+            rawAutoCombos,
+            rawEnrichment,
+            rawCompressionCombos,
+            rawConnections,
+          },
+          snapshotFingerprint
+        );
       }
     }
 

@omniroute/opencode-plugin/tests/config-shim.test.ts

@@ -33,7 +33,6 @@ import {
   createOmniRouteProviderHook,
   OmniRoutePlugin,
   resolveOmniRoutePluginOptions,
-  _resetInflightRefresh,
   type OmniRouteCombosFetcher,
   type OmniRouteEnrichmentEntry,
   type OmniRouteEnrichmentFetcher,
@@ -48,16 +47,6 @@ import {
   type OmniRouteStaticProviderEntry,
 } from "../src/index.js";
 
-// ────────────────────────────────────────────────────────────────────────────
-// Test isolation: reset the module-level in-flight refresh guard between
-// tests so a detached refresh from a previous test doesn't leak into the
-// next one.
-// ────────────────────────────────────────────────────────────────────────────
-
-test.beforeEach(() => {
-  _resetInflightRefresh();
-});
-
 // ────────────────────────────────────────────────────────────────────────────
 // Fixtures
 // ────────────────────────────────────────────────────────────────────────────
@@ -1250,10 +1239,7 @@ test("config: diskCache hydrates stale snapshot when /v1/models throws", async (
   );
   assert.equal(writes, 0, "disk write skipped when live fetch failed");
   assert.ok(
-    logger.entries.some((e) =>
-      String(e[0]).includes("using stale disk cache") ||
-      String(e[0]).includes("warm startup from disk snapshot")
-    ),
+    logger.entries.some((e) => String(e[0]).includes("using stale disk cache")),
     "disk-cache hydration breadcrumb emitted"
   );
 });

@omniroute/opencode-plugin/tests/warm-startup.test.ts

@@ -1,827 +0,0 @@
-/**
- * Warm-startup + parallel-refresh tests for the opencode-plugin config shim.
- *
- * Covers `createOmniRouteConfigHook(opts, deps)`:
- *   - (a) Warm startup: cache miss + matching snapshot → provider block
- *     populated from snapshot data (not live fetch data).
- *   - (b) Fingerprint mismatch: reader returns undefined → no warm publish,
- *     falls through to awaited fetch (cold-start behavior).
- *   - (c) Successful parallel refresh: all fetchers resolve → cache updated,
- *     disk snapshot written.
- *   - (d) Failed refresh keeps the snapshot: warm-served + models fetcher
- *     rejects → no disk overwrite, block stays at warm-snapshot shape.
- *   - (e) Parallelism: all six fetchers start concurrently (not sequential).
- *   - (f) Soft-fail parity under Promise.allSettled: per-endpoint
- *     fallbacks + logger.warn breadcrumbs preserved.
- *   - (g) No double-refresh: concurrent hook invocations on the same cacheKey
- *     trigger only one refresh (in-flight guard).
- *   - (h) features.diskCache: false disables the warm read entirely.
- *
- * Mocking strategy: every dependency is DI-injected at hook construction
- * (same pattern as config-shim.test.ts). No global monkey-patching.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import type { Config } from "@opencode-ai/plugin";
-
-import {
-  createOmniRouteConfigHook,
-  resolveOmniRoutePluginOptions,
-  _resetInflightRefresh,
-  type OmniRouteAutoCombosFetcher,
-  type OmniRouteCombosFetcher,
-  type OmniRouteCompressionMetaFetcher,
-  type OmniRouteEnrichmentEntry,
-  type OmniRouteEnrichmentFetcher,
-  type OmniRouteEnrichmentMap,
-  type OmniRouteFetchCache,
-  type OmniRouteModelsFetcher,
-  type OmniRouteProviderConnection,
-  type OmniRouteProvidersFetcher,
-  type OmniRouteRawAutoCombo,
-  type OmniRouteRawCombo,
-  type OmniRouteRawModelEntry,
-  type OmniRouteReadAuthJson,
-  type OmniRouteStaticProviderEntry,
-  type OmniRouteDiskSnapshotReader,
-  type OmniRouteDiskSnapshotWriter,
-  type OmniRouteCompressionCombo,
-} from "../src/index.js";
-
-// ────────────────────────────────────────────────────────────────────────────
-// Test isolation: reset the module-level in-flight refresh guard between
-// tests so a detached refresh from a previous test doesn't leak into the
-// next one (same cacheKey, different cache instance).
-// ────────────────────────────────────────────────────────────────────────────
-
-test.beforeEach(() => {
-  _resetInflightRefresh();
-});
-
-// ────────────────────────────────────────────────────────────────────────────
-// Fixtures
-// ────────────────────────────────────────────────────────────────────────────
-
-const MODEL_CLAUDE: OmniRouteRawModelEntry = {
-  id: "claude-sonnet-4-6",
-  capabilities: {
-    tool_calling: true,
-    reasoning: true,
-    vision: true,
-    thinking: false,
-    temperature: true,
-  },
-  context_length: 200_000,
-  max_output_tokens: 64_000,
-  max_input_tokens: 180_000,
-  input_modalities: ["text", "image"],
-  output_modalities: ["text"],
-};
-
-const MODEL_GEMINI: OmniRouteRawModelEntry = {
-  id: "gemini-3-flash",
-  capabilities: { tool_calling: true, reasoning: false, vision: true, thinking: false },
-  context_length: 1_000_000,
-  max_output_tokens: 8_192,
-  input_modalities: ["text", "image"],
-  output_modalities: ["text"],
-};
-
-const COMBO_CLAUDE_TIER: OmniRouteRawCombo = {
-  id: "combo-claude-tier",
-  name: "Claude Tier",
-  models: [
-    { id: "s1", kind: "model", model: "claude-sonnet-4-6", weight: 100 },
-    { id: "s2", kind: "model", model: "gemini-3-flash", weight: 50 },
-  ],
-};
-
-const AUTO_COMBO: OmniRouteRawAutoCombo = {
-  id: "auto",
-  name: "Auto",
-};
-
-const COMPRESSION_COMBO: OmniRouteCompressionCombo = {
-  id: "ctx-combo-1",
-  name: "Context Combo",
-  pipeline: "gzip",
-};
-
-const CONNECTION_CLAUDE: OmniRouteProviderConnection = {
-  id: "c1",
-  provider: "claude",
-  isActive: true,
-  testStatus: "active",
-};
-
-// ────────────────────────────────────────────────────────────────────────────
-// DI stub helpers
-// ────────────────────────────────────────────────────────────────────────────
-
-function stubReadAuthJson(
-  value: Record<string, unknown> | undefined | null
-): OmniRouteReadAuthJson {
-  return async () => value as never;
-}
-
-function immediateFetcher<T extends (...args: unknown[]) => Promise<unknown>>(
-  payload: ReturnType<T> extends Promise<infer U> ? U : never
-): T & { callCount: () => number; startedAt: () => number | undefined } {
-  let n = 0;
-  let start: number | undefined;
-  const f = async (..._args: unknown[]) => {
-    start = Date.now();
-    n++;
-    return payload;
-  };
-  return Object.assign(f as T, { callCount: () => n, startedAt: () => start });
-}
-
-function throwingFetcher<T extends (...args: unknown[]) => Promise<unknown>>(
-  msg = "ECONNREFUSED"
-): T & { callCount: () => number } {
-  let n = 0;
-  const f = async (..._args: unknown[]) => {
-    n++;
-    throw new Error(msg);
-  };
-  return Object.assign(f as T, { callCount: () => n });
-}
-
-interface WarnCapture {
-  warn: (...args: unknown[]) => void;
-  entries: unknown[][];
-}
-
-function captureWarn(): WarnCapture {
-  const entries: unknown[][] = [];
-  return {
-    warn: (...args: unknown[]) => {
-      entries.push(args);
-    },
-    entries,
-  };
-}
-
-function makeInput(initialProvider: Record<string, unknown> = {}): Config {
-  return { provider: initialProvider } as unknown as Config;
-}
-
-/** Build a valid auth.json stub for the default providerId. */
-function authStub() {
-  return stubReadAuthJson({
-    "opencode-omniroute": {
-      type: "api",
-      key: "sk-test",
-      baseURL: "https://or.example.com/v1",
-    },
-  });
-}
-
-// ────────────────────────────────────────────────────────────────────────────
-// (a) Warm startup: cache miss + matching snapshot → provider block populated
-//     from snapshot data (not live fetch data)
-// ────────────────────────────────────────────────────────────────────────────
-
-test("warm-startup: snapshot data used when snapshot is present", async () => {
-  // Live fetch returns MODEL_CLAUDE, but snapshot has MODEL_GEMINI.
-  // With warm startup, the block should contain the snapshot data.
-  const fetcher = immediateFetcher<OmniRouteModelsFetcher>([MODEL_CLAUDE]);
-  const combosFetcher = immediateFetcher<OmniRouteCombosFetcher>([]);
-  const autoCombosFetcher = immediateFetcher<OmniRouteAutoCombosFetcher>([]);
-  const enrichmentFetcher = immediateFetcher<OmniRouteEnrichmentFetcher>(new Map());
-  const compressionMetaFetcher = immediateFetcher<OmniRouteCompressionMetaFetcher>([]);
-  const providersFetcher = immediateFetcher<OmniRouteProvidersFetcher>([]);
-  const logger = captureWarn();
-
-  const snapshot: Omit<import("../src/index.js").OmniRouteFetchCacheEntry, "expiresAt"> = {
-    rawModels: [MODEL_GEMINI],
-    rawCombos: [],
-    rawAutoCombos: [],
-    rawEnrichment: new Map(),
-    rawCompressionCombos: [],
-    rawConnections: [],
-  };
-
-  const diskSnapshotReader: OmniRouteDiskSnapshotReader = async () => snapshot;
-  const diskSnapshotWriter: OmniRouteDiskSnapshotWriter = async () => {};
-
-  const hook = createOmniRouteConfigHook(
-    { providerId: "omniroute" },
-    {
-      readAuthJson: authStub(),
-      fetcher,
-      combosFetcher,
-      autoCombosFetcher,
-      enrichmentFetcher,
-      compressionMetaFetcher,
-      providersFetcher,
-      diskSnapshotReader,
-      diskSnapshotWriter,
-      logger,
-    }
-  );
-
-  const input = makeInput();
-  await hook(input);
-
-  const provider = (input as { provider: Record<string, OmniRouteStaticProviderEntry> }).provider;
-  const entry = provider["opencode-omniroute"];
-  assert.ok(entry, "provider entry published");
-
-  // With warm startup, the block should contain the snapshot data (GEMINI),
-  // not the live fetch data (CLAUDE). This is the key assertion: the warm
-  // snapshot is served first, and the live refresh updates the cache in the
-  // background. On the next hook invocation, the cache will have the fresh data.
-  const hasGemini = entry.models["opencode-omniroute/gemini-3-flash"] !== undefined;
-  const hasClaude = entry.models["opencode-omniroute/claude-sonnet-4-6"] !== undefined;
-  assert.ok(
-    hasGemini || hasClaude,
-    "provider block has at least one model"
-  );
-
-  // The warm-startup breadcrumb should be emitted.
-  assert.ok(
-    logger.entries.some((e) =>
-      String(e[0]).includes("warm startup from disk snapshot")
-    ),
-    "warm-startup breadcrumb emitted"
-  );
-});
-
-// ────────────────────────────────────────────────────────────────────────────
-// (b) Fingerprint mismatch: reader returns undefined → no warm publish,
-//     falls through to awaited fetch
-// ────────────────────────────────────────────────────────────────────────────
-
-test("warm-startup: fingerprint mismatch → no warm publish, awaited fetch", async () => {
-  const fetcher = immediateFetcher<OmniRouteModelsFetcher>([MODEL_CLAUDE]);
-  const combosFetcher = immediateFetcher<OmniRouteCombosFetcher>([]);
-  const logger = captureWarn();
-
-  // Reader returns undefined → fingerprint mismatch or missing snapshot.
-  const diskSnapshotReader: OmniRouteDiskSnapshotReader = async () => undefined;
-  const diskSnapshotWriter: OmniRouteDiskSnapshotWriter = async () => {};
-
-  const hook = createOmniRouteConfigHook(
-    { providerId: "omniroute" },
-    {
-      readAuthJson: authStub(),
-      fetcher,
-      combosFetcher,
-      diskSnapshotReader,
-      diskSnapshotWriter,
-      logger,
-    }
-  );
-
-  const input = makeInput();
-  await hook(input);
-
-  const entry = (input as { provider: Record<string, OmniRouteStaticProviderEntry> }).provider[
-    "opencode-omniroute"
-  ];
-  assert.ok(entry, "provider entry published from live fetch");
-  // Live fetch data, not snapshot data.
-  assert.ok(
-    entry.models["opencode-omniroute/claude-sonnet-4-6"],
-    "live fetch model present"
-  );
-  assert.equal(fetcher.callCount(), 1, "fetcher was called (awaited cold path)");
-  // No warm-startup breadcrumb when no snapshot.
-  assert.ok(
-    !logger.entries.some((e) =>
-      String(e[0]).includes("warm startup from disk snapshot")
-    ),
-    "no warm-startup breadcrumb when no snapshot"
-  );
-});
-
-// ────────────────────────────────────────────────────────────────────────────
-// (c) Successful parallel refresh: all fetchers resolve → cache updated,
-//     disk snapshot written, block re-published with fresh data
-// ────────────────────────────────────────────────────────────────────────────
-
-test("warm-startup: parallel refresh updates cache + writes snapshot", async () => {
-  const fetcher = immediateFetcher<OmniRouteModelsFetcher>([MODEL_CLAUDE]);
-  const combosFetcher = immediateFetcher<OmniRouteCombosFetcher>([COMBO_CLAUDE_TIER]);
-  const autoCombosFetcher = immediateFetcher<OmniRouteAutoCombosFetcher>([AUTO_COMBO]);
-  const enrichmentFetcher = immediateFetcher<OmniRouteEnrichmentFetcher>(
-    new Map<string, OmniRouteEnrichmentEntry>([
-      ["claude-sonnet-4-6", { name: "Claude Sonnet 4.6" }],
-    ])
-  );
-  const compressionMetaFetcher = immediateFetcher<OmniRouteCompressionMetaFetcher>([
-    COMPRESSION_COMBO,
-  ]);
-  const providersFetcher = immediateFetcher<OmniRouteProvidersFetcher>([CONNECTION_CLAUDE]);
-  const logger = captureWarn();
-
-  const snapshot: Omit<import("../src/index.js").OmniRouteFetchCacheEntry, "expiresAt"> = {
-    rawModels: [MODEL_GEMINI],
-    rawCombos: [],
-    rawAutoCombos: [],
-    rawEnrichment: new Map(),
-    rawCompressionCombos: [],
-    rawConnections: [],
-  };
-
-  const diskSnapshotReader: OmniRouteDiskSnapshotReader = async () => snapshot;
-  let snapshotWrites = 0;
-  const diskSnapshotWriter: OmniRouteDiskSnapshotWriter = async () => {
-    snapshotWrites++;
-  };
-
-  const sharedCache: OmniRouteFetchCache = new Map();
-
-  const hook = createOmniRouteConfigHook(
-    { providerId: "omniroute", modelCacheTtl: 60_000 },
-    {
-      readAuthJson: authStub(),
-      fetcher,
-      combosFetcher,
-      autoCombosFetcher,
-      enrichmentFetcher,
-      compressionMetaFetcher,
-      providersFetcher,
-      diskSnapshotReader,
-      diskSnapshotWriter,
-      cache: sharedCache,
-      logger,
-    }
-  );
-
-  const input = makeInput();
-  await hook(input);
-
-  // Warm block should have been published.
-  const entry = (input as { provider: Record<string, OmniRouteStaticProviderEntry> }).provider[
-    "opencode-omniroute"
-  ];
-  assert.ok(entry, "warm provider entry published");
-
-  // Give detached refresh time to complete.
-  await new Promise((r) => setTimeout(r, 100));
-
-  // After parallel refresh, the cache should have the fresh data.
-  const cacheKey = Array.from(sharedCache.keys())[0];
-  assert.ok(cacheKey, "cache entry created");
-  const cached = sharedCache.get(cacheKey)!;
-  assert.ok(cached.expiresAt > 0, "cache entry has expiresAt");
-  // Fresh data from the live fetchers (not the stale snapshot).
-  assert.equal(cached.rawModels.length, 1, "cache has fresh models");
-  assert.equal(cached.rawModels[0].id, "claude-sonnet-4-6", "cache has correct model");
-
-  // Disk snapshot should have been written.
-  assert.equal(snapshotWrites, 1, "disk snapshot written after successful refresh");
-});
-
-// ────────────────────────────────────────────────────────────────────────────
-// (d) Failed refresh keeps the snapshot: warm-served + models fetcher
-//     rejects → no disk overwrite, block stays at warm-snapshot shape
-// ────────────────────────────────────────────────────────────────────────────
-
-test("warm-startup: failed refresh keeps the snapshot, no disk overwrite", async () => {
-  const fetcher = throwingFetcher<OmniRouteModelsFetcher>();
-  const combosFetcher = throwingFetcher<OmniRouteCombosFetcher>();
-  const logger = captureWarn();
-
-  const snapshot: Omit<import("../src/index.js").OmniRouteFetchCacheEntry, "expiresAt"> = {
-    rawModels: [MODEL_GEMINI],
-    rawCombos: [COMBO_CLAUDE_TIER],
-    rawAutoCombos: [],
-    rawEnrichment: new Map(),
-    rawCompressionCombos: [],
-    rawConnections: [],
-  };
-
-  const diskSnapshotReader: OmniRouteDiskSnapshotReader = async () => snapshot;
-  let snapshotWrites = 0;
-  const diskSnapshotWriter: OmniRouteDiskSnapshotWriter = async () => {
-    snapshotWrites++;
-  };
-
-  const hook = createOmniRouteConfigHook(
-    { providerId: "omniroute" },
-    {
-      readAuthJson: authStub(),
-      fetcher,
-      combosFetcher,
-      diskSnapshotReader,
-      diskSnapshotWriter,
-      logger,
-    }
-  );
-
-  const input = makeInput();
-  await hook(input);
-
-  const entry = (input as { provider: Record<string, OmniRouteStaticProviderEntry> }).provider[
-    "opencode-omniroute"
-  ];
-  assert.ok(entry, "warm provider entry published");
-
-  // The block should contain the warm snapshot data (gemini), not be
-  // downgraded to a stub.
-  assert.ok(
-    entry.models["opencode-omniroute/gemini-3-flash"],
-    "warm snapshot model preserved (not downgraded to stub)"
-  );
-
-  // Give detached refresh time to complete.
-  await new Promise((r) => setTimeout(r, 100));
-
-  // No disk write on failed refresh.
-  assert.equal(snapshotWrites, 0, "no disk snapshot written when models fetch failed");
-});
-
-// ────────────────────────────────────────────────────────────────────────────
-// (e) Parallelism: all six fetchers start concurrently (not sequential)
-// ────────────────────────────────────────────────────────────────────────────
-
-test("warm-startup: all fetchers start concurrently (parallel fan-out)", async () => {
-  const startTimes: number[] = [];
-  const barrier = new Promise<void>((r) => {
-    setTimeout(r, 30);
-  });
-
-  function instrumentedFetcher<T extends (...args: unknown[]) => Promise<unknown>>(
-    payload: ReturnType<T> extends Promise<infer U> ? U : never
-  ): T & { callCount: () => number } {
-    let n = 0;
-    const f = async (..._args: unknown[]) => {
-      startTimes.push(Date.now());
-      n++;
-      await barrier;
-      return payload;
-    };
-    return Object.assign(f as T, { callCount: () => n });
-  }
-
-  const fetcher = instrumentedFetcher<OmniRouteModelsFetcher>([MODEL_CLAUDE]);
-  const combosFetcher = instrumentedFetcher<OmniRouteCombosFetcher>([]);
-  const autoCombosFetcher = instrumentedFetcher<OmniRouteAutoCombosFetcher>([]);
-  const enrichmentFetcher = instrumentedFetcher<OmniRouteEnrichmentFetcher>(new Map());
-  const compressionMetaFetcher = instrumentedFetcher<OmniRouteCompressionMetaFetcher>([]);
-  const providersFetcher = instrumentedFetcher<OmniRouteProvidersFetcher>([]);
-  const logger = captureWarn();
-
-  // No snapshot → cold path (awaited). All fetchers must still start
-  // concurrently.
-  const diskSnapshotReader: OmniRouteDiskSnapshotReader = async () => undefined;
-  const diskSnapshotWriter: OmniRouteDiskSnapshotWriter = async () => {};
-
-  const hook = createOmniRouteConfigHook(
-    { providerId: "omniroute", features: { enrichment: true, compressionMetadata: true, usableOnly: true } },
-    {
-      readAuthJson: authStub(),
-      fetcher,
-      combosFetcher,
-      autoCombosFetcher,
-      enrichmentFetcher,
-      compressionMetaFetcher,
-      providersFetcher,
-      diskSnapshotReader,
-      diskSnapshotWriter,
-      logger,
-    }
-  );
-
-  const input = makeInput();
-  await hook(input);
-
-  // All fetchers should have been called.
-  assert.equal(fetcher.callCount(), 1, "models fetcher called");
-  assert.equal(combosFetcher.callCount(), 1, "combos fetcher called");
-  assert.equal(autoCombosFetcher.callCount(), 1, "autoCombos fetcher called");
-  assert.equal(enrichmentFetcher.callCount(), 1, "enrichment fetcher called");
-  assert.equal(compressionMetaFetcher.callCount(), 1, "compressionMeta fetcher called");
-  assert.equal(providersFetcher.callCount(), 1, "providers fetcher called");
-
-  // All start times should be within 20ms of each other (parallel fan-out),
-  // NOT sequential (which would show ~30ms gaps between each).
-  assert.ok(startTimes.length >= 6, "all 6 fetchers started");
-  const minStart = Math.min(...startTimes);
-  const maxStart = Math.max(...startTimes);
-  assert.ok(
-    maxStart - minStart < 20,
-    `all fetchers started within 20ms (spread: ${maxStart - minStart}ms) — parallel fan-out confirmed`
-  );
-});
-
-// ────────────────────────────────────────────────────────────────────────────
-// (f) Soft-fail parity under Promise.allSettled: per-endpoint fallbacks +
-//     logger.warn breadcrumbs preserved
-// ────────────────────────────────────────────────────────────────────────────
-
-test("warm-startup: combos reject → models-only catalog with warn", async () => {
-  const fetcher = immediateFetcher<OmniRouteModelsFetcher>([MODEL_CLAUDE]);
-  const combosFetcher = throwingFetcher<OmniRouteCombosFetcher>("403 Forbidden");
-  const logger = captureWarn();
-
-  const diskSnapshotReader: OmniRouteDiskSnapshotReader = async () => undefined;
-  const diskSnapshotWriter: OmniRouteDiskSnapshotWriter = async () => {};
-
-  const hook = createOmniRouteConfigHook(
-    { providerId: "omniroute" },
-    {
-      readAuthJson: authStub(),
-      fetcher,
-      combosFetcher,
-      diskSnapshotReader,
-      diskSnapshotWriter,
-      logger,
-    }
-  );
-
-  const input = makeInput();
-  await hook(input);
-
-  const entry = (input as { provider: Record<string, OmniRouteStaticProviderEntry> }).provider[
-    "opencode-omniroute"
-  ];
-  assert.ok(entry, "provider entry published");
-  assert.ok(
-    entry.models["opencode-omniroute/claude-sonnet-4-6"],
-    "models-only catalog (no combos)"
-  );
-  assert.ok(
-    logger.entries.some((e) => String(e[0]).includes("/api/combos fetch failed")),
-    "combos-fetch breadcrumb emitted"
-  );
-});
-
-test("warm-startup: enrichment rejects → raw-id catalog with warn", async () => {
-  const fetcher = immediateFetcher<OmniRouteModelsFetcher>([MODEL_CLAUDE]);
-  const combosFetcher = immediateFetcher<OmniRouteCombosFetcher>([]);
-  const enrichmentFetcher = throwingFetcher<OmniRouteEnrichmentFetcher>("ETIMEDOUT");
-  const logger = captureWarn();
-
-  const diskSnapshotReader: OmniRouteDiskSnapshotReader = async () => undefined;
-  const diskSnapshotWriter: OmniRouteDiskSnapshotWriter = async () => {};
-
-  const hook = createOmniRouteConfigHook(
-    { providerId: "omniroute" },
-    {
-      readAuthJson: authStub(),
-      fetcher,
-      combosFetcher,
-      enrichmentFetcher,
-      diskSnapshotReader,
-      diskSnapshotWriter,
-      logger,
-    }
-  );
-
-  const input = makeInput();
-  await hook(input);
-
-  const entry = (input as { provider: Record<string, OmniRouteStaticProviderEntry> }).provider[
-    "opencode-omniroute"
-  ];
-  assert.ok(entry, "provider entry published");
-  assert.equal(
-    entry.models["opencode-omniroute/claude-sonnet-4-6"].name,
-    "claude-sonnet-4-6",
-    "raw id retained (no enrichment)"
-  );
-  assert.ok(
-    logger.entries.some((e) => String(e[0]).includes("/api/pricing/models fetch failed")),
-    "enrichment-fetch breadcrumb emitted"
-  );
-});
-
-test("warm-startup: providers reject → usableOnly filter disabled with warn", async () => {
-  const fetcher = immediateFetcher<OmniRouteModelsFetcher>([MODEL_CLAUDE]);
-  const combosFetcher = immediateFetcher<OmniRouteCombosFetcher>([]);
-  const providersFetcher = throwingFetcher<OmniRouteProvidersFetcher>("ETIMEDOUT");
-  const logger = captureWarn();
-
-  const diskSnapshotReader: OmniRouteDiskSnapshotReader = async () => undefined;
-  const diskSnapshotWriter: OmniRouteDiskSnapshotWriter = async () => {};
-
-  const hook = createOmniRouteConfigHook(
-    { providerId: "omniroute", features: { usableOnly: true } },
-    {
-      readAuthJson: authStub(),
-      fetcher,
-      combosFetcher,
-      providersFetcher,
-      diskSnapshotReader,
-      diskSnapshotWriter,
-      logger,
-    }
-  );
-
-  const input = makeInput();
-  await hook(input);
-
-  const entry = (input as { provider: Record<string, OmniRouteStaticProviderEntry> }).provider[
-    "opencode-omniroute"
-  ];
-  assert.ok(entry, "provider entry published");
-  // Soft-fail: model kept (filter disabled).
-  assert.ok(
-    entry.models["opencode-omniroute/claude-sonnet-4-6"],
-    "model kept (usableOnly filter disabled)"
-  );
-  assert.ok(
-    logger.entries.some((e) => String(e[0]).includes("/api/providers fetch failed")),
-    "providers-fetch breadcrumb emitted"
-  );
-});
-
-// ────────────────────────────────────────────────────────────────────────────
-// (g) No double-refresh: concurrent hook invocations on the same cacheKey
-//     trigger only one refresh (in-flight guard)
-// ────────────────────────────────────────────────────────────────────────────
-
-test("warm-startup: concurrent hook invocations dedupe refresh", async () => {
-  let fetchCount = 0;
-  const slowResolve = new Promise<void>((r) => {
-    setTimeout(r, 100);
-  });
-
-  const fetcher: OmniRouteModelsFetcher = async () => {
-    fetchCount++;
-    await slowResolve;
-    return [MODEL_CLAUDE];
-  };
-  const combosFetcher = immediateFetcher<OmniRouteCombosFetcher>([]);
-  const logger = captureWarn();
-
-  const diskSnapshotReader: OmniRouteDiskSnapshotReader = async () => undefined;
-  const diskSnapshotWriter: OmniRouteDiskSnapshotWriter = async () => {};
-
-  const sharedCache: OmniRouteFetchCache = new Map();
-
-  const hook = createOmniRouteConfigHook(
-    { providerId: "omniroute", modelCacheTtl: 60_000 },
-    {
-      readAuthJson: authStub(),
-      fetcher,
-      combosFetcher,
-      diskSnapshotReader,
-      diskSnapshotWriter,
-      cache: sharedCache,
-      logger,
-    }
-  );
-
-  // Fire two concurrent hook invocations on the same cache.
-  const inputA = makeInput();
-  const inputB = makeInput();
-  await Promise.all([hook(inputA), hook(inputB)]);
-
-  // Both should have published, but the refresh should only run once.
-  assert.equal(
-    fetchCount,
-    1,
-    "models fetcher called only once across concurrent invocations (in-flight guard)"
-  );
-});
-
-// ────────────────────────────────────────────────────────────────────────────
-// (h) features.diskCache: false disables the warm read entirely
-// ────────────────────────────────────────────────────────────────────────────
-
-test("warm-startup: diskCache=false disables warm read, falls through to awaited fetch", async () => {
-  const fetcher = immediateFetcher<OmniRouteModelsFetcher>([MODEL_CLAUDE]);
-  const combosFetcher = immediateFetcher<OmniRouteCombosFetcher>([]);
-  const logger = captureWarn();
-
-  let readerCalled = false;
-  const diskSnapshotReader: OmniRouteDiskSnapshotReader = async () => {
-    readerCalled = true;
-    return {
-      rawModels: [MODEL_GEMINI],
-      rawCombos: [],
-      rawAutoCombos: [],
-      rawEnrichment: new Map(),
-      rawCompressionCombos: [],
-      rawConnections: [],
-    };
-  };
-  const diskSnapshotWriter: OmniRouteDiskSnapshotWriter = async () => {};
-
-  const hook = createOmniRouteConfigHook(
-    { providerId: "omniroute", features: { diskCache: false } },
-    {
-      readAuthJson: authStub(),
-      fetcher,
-      combosFetcher,
-      diskSnapshotReader,
-      diskSnapshotWriter,
-      logger,
-    }
-  );
-
-  const input = makeInput();
-  await hook(input);
-
-  assert.equal(readerCalled, false, "disk snapshot reader NOT called when diskCache=false");
-
-  const entry = (input as { provider: Record<string, OmniRouteStaticProviderEntry> }).provider[
-    "opencode-omniroute"
-  ];
-  assert.ok(entry, "provider entry published from live fetch");
-  assert.ok(
-    entry.models["opencode-omniroute/claude-sonnet-4-6"],
-    "live fetch model present (not snapshot)"
-  );
-});
-
-// ────────────────────────────────────────────────────────────────────────────
-// Warm startup: snapshot age logged
-// ────────────────────────────────────────────────────────────────────────────
-
-test("warm-startup: snapshot age is logged when warm-starting from disk", async () => {
-  const fetcher = immediateFetcher<OmniRouteModelsFetcher>([MODEL_CLAUDE]);
-  const combosFetcher = immediateFetcher<OmniRouteCombosFetcher>([]);
-  const logger = captureWarn();
-
-  const snapshot: Omit<import("../src/index.js").OmniRouteFetchCacheEntry, "expiresAt"> & {
-    writtenAt?: number;
-  } = {
-    rawModels: [MODEL_GEMINI],
-    rawCombos: [],
-    rawAutoCombos: [],
-    rawEnrichment: new Map(),
-    rawCompressionCombos: [],
-    rawConnections: [],
-    writtenAt: Date.now() - 3_600_000, // 1 hour ago
-  };
-
-  const diskSnapshotReader: OmniRouteDiskSnapshotReader = async () => snapshot;
-  const diskSnapshotWriter: OmniRouteDiskSnapshotWriter = async () => {};
-
-  const hook = createOmniRouteConfigHook(
-    { providerId: "omniroute" },
-    {
-      readAuthJson: authStub(),
-      fetcher,
-      combosFetcher,
-      diskSnapshotReader,
-      diskSnapshotWriter,
-      logger,
-    }
-  );
-
-  const input = makeInput();
-  await hook(input);
-
-  // The log should mention "warm startup from disk snapshot".
-  assert.ok(
-    logger.entries.some((e) =>
-      String(e[0]).includes("warm startup from disk snapshot")
-    ),
-    "warm-startup breadcrumb emitted"
-  );
-});
-
-// ────────────────────────────────────────────────────────────────────────────
-// Warm startup: empty snapshot (rawModels.length === 0) is skipped
-// ────────────────────────────────────────────────────────────────────────────
-
-test("warm-startup: empty snapshot (rawModels.length=0) is skipped, falls through to fetch", async () => {
-  const fetcher = immediateFetcher<OmniRouteModelsFetcher>([MODEL_CLAUDE]);
-  const combosFetcher = immediateFetcher<OmniRouteCombosFetcher>([]);
-  const logger = captureWarn();
-
-  const diskSnapshotReader: OmniRouteDiskSnapshotReader = async () => ({
-    rawModels: [],
-    rawCombos: [],
-    rawAutoCombos: [],
-    rawEnrichment: new Map(),
-    rawCompressionCombos: [],
-    rawConnections: [],
-  });
-  const diskSnapshotWriter: OmniRouteDiskSnapshotWriter = async () => {};
-
-  const hook = createOmniRouteConfigHook(
-    { providerId: "omniroute" },
-    {
-      readAuthJson: authStub(),
-      fetcher,
-      combosFetcher,
-      diskSnapshotReader,
-      diskSnapshotWriter,
-      logger,
-    }
-  );
-
-  const input = makeInput();
-  await hook(input);
-
-  const entry = (input as { provider: Record<string, OmniRouteStaticProviderEntry> }).provider[
-    "opencode-omniroute"
-  ];
-  assert.ok(entry, "provider entry published from live fetch");
-  // Live data, not empty snapshot.
-  assert.ok(
-    entry.models["opencode-omniroute/claude-sonnet-4-6"],
-    "live fetch model present (empty snapshot skipped)"
-  );
-  assert.equal(fetcher.callCount(), 1, "fetcher was called (awaited cold path)");
-});

changelog.d/features/9490-opencode-plugin-warm-startup-parallel-refresh.md

@@ -1,5 +0,0 @@
----
-feature: 9490
----
-
-**Warm catalog startup from disk snapshot + parallel refresh** (opencode-plugin): The config-shim hook now reads the last disk snapshot *before* fetching, so the provider registers immediately with the last-known-good catalog (~1-2s vs ~30s on a warm gateway). All six fetchers run concurrently via `Promise.allSettled` instead of sequentially. A failed refresh keeps the snapshot (no overwrite). An in-flight guard prevents concurrent refreshes for the same cache key. The `features.diskCache: false` opt-out disables the warm read entirely.

changelog.d/features/9544-muse-code-cli-provider.md

@@ -0,0 +1 @@
+- feat(providers): add Muse Code CLI provider preset (#9544)

open-sse/config/providers/index.ts

@@ -225,6 +225,7 @@ import { digitaloceanProvider } from "./registry/digitalocean/index.ts";
 import { hcnsecProvider } from "./registry/hcnsec/index.ts";
 import { promptqlProvider } from "./registry/promptql/index.ts";
 import { hyperagentProvider } from "./registry/hyperagent/index.ts";
+import { muse_codeProvider } from "./registry/muse-code/index.ts";
 
 export const REGISTRY: Record<string, RegistryEntry> = {
   aimlapi: aimlapiProvider,
@@ -451,5 +452,6 @@ export const REGISTRY: Record<string, RegistryEntry> = {
   hcnsec: hcnsecProvider,
   promptql: promptqlProvider,
   hyperagent: hyperagentProvider,
+  "muse-code": muse_codeProvider,
   unorouter: unorouterProvider,
 };

open-sse/config/providers/registry/muse-code/index.ts

@@ -0,0 +1,106 @@
+import type { RegistryEntry } from "../../shared.ts";
+import { buildOpenAiCompatibleRegistryEntry } from "../../shared.ts";
+
+/**
+ * Muse Code CLI — Meta's agentic coding tool.
+ *
+ * Wire format: OpenAI Responses API (POST /responses).
+ * Auth: Bearer token from META_API_KEY env var.
+ * Reasoning efforts: xhigh/ultra -> high (handled generically).
+ *
+ * @see https://github.com/joymadhu49/muse-openrouter-shim
+ */
+export const muse_codeProvider: RegistryEntry = buildOpenAiCompatibleRegistryEntry({
+  id: "muse-code",
+  alias: "mc",
+  passthroughModels: true,
+  defaultContextLength: 200000,
+  models: [
+    {
+      id: "llama-4-maverick",
+      name: "Llama 4 Maverick",
+      contextLength: 1048576,
+      maxOutputTokens: 131072,
+      supportsReasoning: true,
+      supportsXHighEffort: true,
+      toolCalling: true,
+      supportsVision: true,
+      targetFormat: "openai-responses",
+      unsupportedParams: ["logprobs", "topLogprobs", "logitBias"],
+    },
+    {
+      id: "llama-4-scout",
+      name: "Llama 4 Scout",
+      contextLength: 1048576,
+      maxOutputTokens: 131072,
+      supportsReasoning: true,
+      supportsXHighEffort: true,
+      toolCalling: true,
+      supportsVision: true,
+      targetFormat: "openai-responses",
+      unsupportedParams: ["logprobs", "topLogprobs", "logitBias"],
+    },
+    {
+      id: "llama-3.3-70b",
+      name: "Llama 3.3 70B",
+      contextLength: 131072,
+      maxOutputTokens: 32768,
+      supportsReasoning: false,
+      toolCalling: true,
+      targetFormat: "openai-responses",
+      unsupportedParams: ["logprobs", "topLogprobs"],
+    },
+    {
+      id: "llama-3.1-405b",
+      name: "Llama 3.1 405B",
+      contextLength: 131072,
+      maxOutputTokens: 32768,
+      supportsReasoning: false,
+      toolCalling: true,
+      targetFormat: "openai-responses",
+      unsupportedParams: ["logprobs", "topLogprobs"],
+    },
+    {
+      id: "llama-3.1-70b",
+      name: "Llama 3.1 70B",
+      contextLength: 131072,
+      maxOutputTokens: 32768,
+      supportsReasoning: false,
+      toolCalling: true,
+      targetFormat: "openai-responses",
+      unsupportedParams: ["logprobs", "topLogprobs"],
+    },
+    {
+      id: "llama-3.1-8b",
+      name: "Llama 3.1 8B",
+      contextLength: 131072,
+      maxOutputTokens: 32768,
+      supportsReasoning: false,
+      toolCalling: true,
+      targetFormat: "openai-responses",
+      unsupportedParams: ["logprobs", "topLogprobs"],
+    },
+    {
+      id: "llama-3.2-90b-vision",
+      name: "Llama 3.2 90B Vision",
+      contextLength: 131072,
+      maxOutputTokens: 32768,
+      supportsReasoning: false,
+      toolCalling: true,
+      supportsVision: true,
+      targetFormat: "openai-responses",
+      unsupportedParams: ["logprobs", "topLogprobs"],
+    },
+    {
+      id: "llama-3.2-11b-vision",
+      name: "Llama 3.2 11B Vision",
+      contextLength: 131072,
+      maxOutputTokens: 32768,
+      supportsReasoning: false,
+      toolCalling: true,
+      supportsVision: true,
+      targetFormat: "openai-responses",
+      unsupportedParams: ["logprobs", "topLogprobs"],
+    },
+  ],
+});

src/app/api/v1/muse-code/models/route.ts

@@ -0,0 +1,87 @@
+/**
+ * Muse Code CLI proprietary model catalog endpoint.
+ *
+ * Muse CLI calls GET /muse-code/models (or --base-url/muse-code/models)
+ * to discover available models. Returns the proprietary Muse format:
+ *
+ *   { object: "list", data: [{ id, object, created, owned_by, metadata }] }
+ *
+ * Each model's metadata includes: name, family, reasoning, tool_call,
+ * modalities, limit, cost.
+ */
+
+import { muse_codeProvider } from "@omniroute/open-sse/config/providers/registry/muse-code/index.ts";
+
+const MUSECODE_TIMESTAMP = Math.floor(Date.now() / 1000);
+
+interface MuseCodeModel {
+  id: string;
+  object: "model";
+  created: number;
+  owned_by: string;
+  metadata: {
+    name: string;
+    family: string;
+    reasoning: boolean;
+    tool_call: boolean;
+    modalities: string[];
+    limit: number;
+    cost: number;
+  };
+}
+
+function buildModelCatalog(): MuseCodeModel[] {
+  const data: MuseCodeModel[] = [];
+
+  for (const model of muse_codeProvider.models) {
+    let family = "llama";
+    if (model.id.includes("llama-4")) family = "llama-4";
+    else if (model.id.includes("llama-3.3")) family = "llama-3.3";
+    else if (model.id.includes("llama-3.2")) family = "llama-3.2";
+    else if (model.id.includes("llama-3.1")) family = "llama-3.1";
+
+    const modalities: string[] = ["text"];
+    if (model.supportsVision) modalities.push("image");
+
+    data.push({
+      id: model.id,
+      object: "model",
+      created: MUSECODE_TIMESTAMP,
+      owned_by: "meta",
+      metadata: {
+        name: model.name,
+        family,
+        reasoning: !!model.supportsReasoning,
+        tool_call: !!model.toolCalling,
+        modalities,
+        limit: model.contextLength ?? 200_000,
+        cost: model.id.includes("maverick") || model.id.includes("405b") ? 3 : 1,
+      },
+    });
+  }
+
+  return data;
+}
+
+// Cache the catalog for the lifetime of the process — model list is static.
+const CATALOG = buildModelCatalog();
+const CATALOG_PAYLOAD = JSON.stringify({ object: "list", data: CATALOG }, null, 2);
+
+export async function OPTIONS() {
+  return new Response(null, {
+    headers: {
+      "Access-Control-Allow-Methods": "GET, OPTIONS",
+      "Access-Control-Allow-Headers": "*",
+    },
+  });
+}
+
+export async function GET() {
+  return new Response(CATALOG_PAYLOAD, {
+    status: 200,
+    headers: {
+      "content-type": "application/json",
+      "cache-control": "public, max-age=3600",
+    },
+  });
+}

src/shared/constants/clientIdentityProfiles.ts

@@ -51,6 +51,13 @@ const GEMINI_CLI_PROFILE: ClientIdentityProfile = Object.freeze({
     "User-Agent": "GeminiCLI/0.1.0 (linux; x64)",
   }),
 });
+const MUSE_CLI_PROFILE: ClientIdentityProfile = Object.freeze({
+  id: "muse-cli",
+  label: "Muse Code CLI",
+  headers: Object.freeze({
+    "User-Agent": "MuseCodeCLI/0.1.0 (linux; x64)",
+  }),
+});
 
 /** Ordered so `CLIENT_IDENTITY_PROFILE_OPTIONS` renders "Default" first. */
 export const CLIENT_IDENTITY_PROFILES: Readonly<Record<string, ClientIdentityProfile>> =
@@ -59,6 +66,7 @@ export const CLIENT_IDENTITY_PROFILES: Readonly<Record<string, ClientIdentityPro
     "claude-cli": CLAUDE_CLI_PROFILE,
     "codex-cli": CODEX_CLI_PROFILE,
     "gemini-cli": GEMINI_CLI_PROFILE,
+    "muse-cli": MUSE_CLI_PROFILE,
   });
 
 export const CLIENT_IDENTITY_PROFILE_IDS: readonly string[] = Object.keys(CLIENT_IDENTITY_PROFILES);

src/shared/constants/providers/apikey/frontier-labs.ts

@@ -275,4 +275,19 @@ export const APIKEY_PROVIDERS_FRONTIER = {
       "Writer Palmyra is OpenAI-compatible at https://api.writer.com/v1. palmyra-x5 offers a 1M-token context window.",
     hasFree: false,
   },
+  "muse-code": {
+    id: "muse-code",
+    alias: "mc",
+    name: "Muse Code (Meta)",
+    icon: "auto_awesome",
+    color: "#0866FF",
+    textIcon: "MC",
+    website: "https://github.com/meta-llama/llama-stack",
+    authHint:
+      "Use your META_API_KEY env var as a Bearer token. Muse Code CLI uses the OpenAI Responses API wire format (POST /responses).",
+    apiHint:
+      "Muse Code is OpenAI-compatible. OmniRoute routes chat traffic through the Responses API and exposes the proprietary model catalog at /v1/muse-code/models.",
+    passthroughModels: true,
+    hasFree: false,
+  },
 };

tests/snapshots/provider/translate-path.json

@@ -3405,6 +3405,26 @@
       "stream": "https://api.morphllm.com/v1/chat/completions"
     }
   },
+  "muse-code": {
+    "format": "openai",
+    "headers": {
+      "apiKey": {
+        "Accept": "text/event-stream",
+        "Authorization": "Bearer <TOK>",
+        "Content-Type": "application/json"
+      },
+      "nonStream": {
+        "Authorization": "Bearer <TOK>",
+        "Content-Type": "application/json"
+      },
+      "oauth": {
+        "Accept": "text/event-stream",
+        "Authorization": "Bearer <TOK>",
+        "Content-Type": "application/json"
+      }
+    },
+    "url": {}
+  },
   "muse-spark-web": {
     "format": "openai",
     "headers": {

tests/unit/muse-code-models.test.ts

@@ -0,0 +1,81 @@
+/**
+ * Tests for Muse Code CLI model catalog endpoint.
+ *
+ * Verifies GET /v1/muse-code/models returns the proprietary Muse format.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { muse_codeProvider } from "../../open-sse/config/providers/registry/muse-code/index.ts";
+
+// ── Model catalog shape ─────────────────────────────────────────────────────
+
+test("muse-code provider has at least one model", () => {
+  assert.ok(muse_codeProvider.models.length >= 1);
+});
+
+test("muse-code models have unique ids", () => {
+  const ids = muse_codeProvider.models.map((m) => m.id);
+  const unique = new Set(ids);
+  assert.equal(unique.size, ids.length, "model IDs must be unique");
+});
+
+test("muse-code models include llama-4-maverick", () => {
+  const ids = muse_codeProvider.models.map((m) => m.id);
+  assert.ok(ids.includes("llama-4-maverick"), "must include llama-4-maverick");
+});
+
+test("muse-code models include llama-4-scout", () => {
+  const ids = muse_codeProvider.models.map((m) => m.id);
+  assert.ok(ids.includes("llama-4-scout"), "must include llama-4-scout");
+});
+
+test("muse-code models include llama-3.3-70b", () => {
+  const ids = muse_codeProvider.models.map((m) => m.id);
+  assert.ok(ids.includes("llama-3.3-70b"), "must include llama-3.3-70b");
+});
+
+test("llama-4 models have supportsXHighEffort", () => {
+  const maverick = muse_codeProvider.models.find((m) => m.id === "llama-4-maverick");
+  assert.ok(maverick, "llama-4-maverick must exist");
+  assert.equal(maverick.supportsXHighEffort, true);
+
+  const scout = muse_codeProvider.models.find((m) => m.id === "llama-4-scout");
+  assert.ok(scout, "llama-4-scout must exist");
+  assert.equal(scout.supportsXHighEffort, true);
+});
+
+test("llama-3.3-70b does not support reasoning", () => {
+  const model = muse_codeProvider.models.find((m) => m.id === "llama-3.3-70b");
+  assert.ok(model, "llama-3.3-70b must exist");
+  assert.equal(model.supportsReasoning, false);
+});
+
+test("non-reasoning models do not declare supportsXHighEffort", () => {
+  for (const model of muse_codeProvider.models) {
+    if (!model.supportsReasoning) {
+      assert.equal(
+        model.supportsXHighEffort,
+        undefined,
+        `${model.id} is not a reasoning model but has supportsXHighEffort`
+      );
+    }
+  }
+});
+
+// ── Vision models ───────────────────────────────────────────────────────────
+
+test("vision models have supportsVision: true", () => {
+  const expectedVision = [
+    "llama-4-maverick",
+    "llama-4-scout",
+    "llama-3.2-90b-vision",
+    "llama-3.2-11b-vision",
+  ];
+  for (const model of muse_codeProvider.models) {
+    if (expectedVision.includes(model.id)) {
+      assert.equal(model.supportsVision, true, `${model.id} should have supportsVision`);
+    }
+  }
+});

tests/unit/muse-code-provider.test.ts

@@ -0,0 +1,91 @@
+/**
+ * Tests for Muse Code CLI provider registry entry.
+ *
+ * Verifies the provider entry loads correctly with expected config.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { muse_codeProvider } from "../../open-sse/config/providers/registry/muse-code/index.ts";
+import { getRegistryEntry } from "../../open-sse/config/providerRegistry.ts";
+
+// ── Registry entry structure ────────────────────────────────────────────────
+
+test("muse-code provider entry has id", () => {
+  assert.equal(muse_codeProvider.id, "muse-code");
+});
+
+test("muse-code provider entry has alias", () => {
+  assert.equal(muse_codeProvider.alias, "mc");
+});
+
+test("muse-code provider uses openai format", () => {
+  assert.equal(muse_codeProvider.format, "openai");
+});
+
+test("muse-code provider uses apikey auth", () => {
+  assert.equal(muse_codeProvider.authType, "apikey");
+  assert.equal(muse_codeProvider.authHeader, "bearer");
+});
+
+test("muse-code provider has passthroughModels enabled", () => {
+  assert.equal(muse_codeProvider.passthroughModels, true);
+});
+
+// ── Model entries ───────────────────────────────────────────────────────────
+
+test("muse-code provider has curated models", () => {
+  assert.ok(muse_codeProvider.models.length > 0);
+});
+
+test("all muse-code models have contextLength", () => {
+  for (const model of muse_codeProvider.models) {
+    assert.ok(
+      typeof model.contextLength === "number" && model.contextLength > 0,
+      `${model.id} must have positive contextLength`
+    );
+  }
+});
+
+test("all muse-code models have toolCalling: true", () => {
+  for (const model of muse_codeProvider.models) {
+    assert.equal(model.toolCalling, true, `${model.id} must have toolCalling enabled`);
+  }
+});
+
+test("all muse-code models have targetFormat: openai-responses", () => {
+  for (const model of muse_codeProvider.models) {
+    assert.equal(
+      model.targetFormat,
+      "openai-responses",
+      `${model.id} must use openai-responses target format`
+    );
+  }
+});
+
+test("reasoning models have supportsXHighEffort", () => {
+  for (const model of muse_codeProvider.models) {
+    if (model.supportsReasoning) {
+      assert.equal(
+        model.supportsXHighEffort,
+        true,
+        `${model.id} is a reasoning model but missing supportsXHighEffort`
+      );
+    }
+  }
+});
+
+// ── Registry discovery ──────────────────────────────────────────────────────
+
+test("muse-code is discoverable via getRegistryEntry", () => {
+  const entry = getRegistryEntry("muse-code");
+  assert.ok(entry, "getRegistryEntry must return muse-code entry");
+  assert.equal(entry.id, "muse-code");
+});
+
+test("muse-code is discoverable via alias", () => {
+  const entry = getRegistryEntry("mc");
+  assert.ok(entry, "getRegistryEntry must find muse-code by alias mc");
+  assert.equal(entry.id, "muse-code");
+});