nexus-agents 8.117.0 → 8.118.0

package/dist/{ast-rule-runner-TBEMNCEM.js → ast-rule-runner-E67T34J6.js}

@@ -9,9 +9,9 @@ import {
   getBuiltInAstRulesPath,
   loadRules,
   runAstQaRules
-} from "./chunk-6KXMFUIS.js";
+} from "./chunk-NATBQ42L.js";
 import "./chunk-XEPZSDN5.js";
-import "./chunk-R6QANTJE.js";
+import "./chunk-ZZYHNIKP.js";
 import "./chunk-UE7A2XHM.js";
 import "./chunk-LWOX65CP.js";
 import "./chunk-PX6F3LHL.js";
@@ -27,4 +27,4 @@ export {
   loadRules,
   runAstQaRules
 };
-//# sourceMappingURL=ast-rule-runner-TBEMNCEM.js.map
+//# sourceMappingURL=ast-rule-runner-E67T34J6.js.map

package/dist/{child-mcp-config-ZYAMNUSI.js → child-mcp-config-I7QXA4PU.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-OITVVSWO.js";
 import {
   createLogger
-} from "./chunk-R6QANTJE.js";
+} from "./chunk-ZZYHNIKP.js";
 import "./chunk-UE7A2XHM.js";
 import "./chunk-LWOX65CP.js";
 import "./chunk-PX6F3LHL.js";
@@ -49,4 +49,4 @@ async function generateMcpConfig(options) {
 export {
   generateMcpConfig
 };
-//# sourceMappingURL=child-mcp-config-ZYAMNUSI.js.map
+//# sourceMappingURL=child-mcp-config-I7QXA4PU.js.map

package/dist/{chunk-TC33JR2R.js → chunk-36ZRLRH4.js}

@@ -13,7 +13,7 @@ import {
   lookupInTreeCapability,
   ok,
   resolveRetryAfterMs
-} from "./chunk-R6QANTJE.js";
+} from "./chunk-ZZYHNIKP.js";
 
 // src/adapters/base-adapter.ts
 var AdapterModelError = class extends ModelError {
@@ -1046,4 +1046,4 @@ export {
   gatewayClientOptions,
   gatewayAiSdkOptions
 };
-//# sourceMappingURL=chunk-TC33JR2R.js.map
+//# sourceMappingURL=chunk-36ZRLRH4.js.map

package/dist/chunk-52OA4YRV.js

@@ -0,0 +1,294 @@
+import {
+  ConfigError,
+  DEFAULT_MODEL_PER_CLI,
+  MODEL_IDS,
+  createLogger,
+  err,
+  getErrorMessage,
+  getTimeProvider,
+  logGatewaySlotMapping,
+  resolveModelIdentitySync,
+  setGatewaySlotCatalog
+} from "./chunk-ZZYHNIKP.js";
+
+// src/config/model-availability.ts
+var DEFAULT_TTL_MS = 6e4;
+var DEFAULT_MAX_ENTRIES = 50;
+var AvailabilityCache = class {
+  cache = /* @__PURE__ */ new Map();
+  ttlMs;
+  maxEntries;
+  constructor(config = {}) {
+    this.ttlMs = config.ttlMs ?? DEFAULT_TTL_MS;
+    this.maxEntries = config.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  }
+  /** Get a cached probe result, or undefined if expired/missing. */
+  get(modelId) {
+    const entry = this.cache.get(modelId);
+    if (entry === void 0) return void 0;
+    if (getTimeProvider().now() - entry.checkedAt > this.ttlMs) {
+      this.cache.delete(modelId);
+      return void 0;
+    }
+    return entry;
+  }
+  /** Store a probe result, evicting oldest if at capacity. */
+  set(result) {
+    if (this.cache.size >= this.maxEntries && !this.cache.has(result.modelId)) {
+      const oldest = this.cache.keys().next();
+      if (oldest.done !== true) {
+        this.cache.delete(oldest.value);
+      }
+    }
+    this.cache.set(result.modelId, result);
+  }
+  /** Mark a model as unavailable without a full probe. */
+  markUnavailable(modelId, error) {
+    this.set({
+      modelId,
+      available: false,
+      latencyMs: 0,
+      checkedAt: getTimeProvider().now(),
+      error
+    });
+  }
+  /** Mark a model as available. */
+  markAvailable(modelId, latencyMs) {
+    this.set({
+      modelId,
+      available: true,
+      latencyMs,
+      checkedAt: getTimeProvider().now()
+    });
+  }
+  /** Check if a model is known-unavailable (cached and not expired). */
+  isKnownUnavailable(modelId) {
+    const entry = this.get(modelId);
+    return entry !== void 0 && !entry.available;
+  }
+  /** Get all cached entries (for diagnostics). */
+  entries() {
+    return [...this.cache.values()];
+  }
+  /** Number of cached entries. */
+  get size() {
+    return this.cache.size;
+  }
+  /** Clear all cached entries. */
+  clear() {
+    this.cache.clear();
+  }
+};
+var FALLBACK_CHAINS = {
+  claude: ["claude-opus", "claude-sonnet", "claude-haiku"],
+  gemini: ["gemini-3-pro", "gemini-pro", "gemini-3-flash", "gemini-flash"],
+  codex: ["codex-5.3", "codex-5.2", "codex-5.1-mini"],
+  opencode: ["opencode-custom-opus", "opencode-custom-sonnet", "opencode-default"]
+};
+function resolveFallback(modelId, cache) {
+  const cli = getCliForModelId(modelId);
+  if (cli === void 0) return null;
+  const chain = FALLBACK_CHAINS[cli];
+  for (const candidate of chain) {
+    if (candidate === modelId) continue;
+    if (!cache.isKnownUnavailable(candidate)) {
+      return {
+        modelId: candidate,
+        reason: `Fallback from ${modelId} (unavailable) to ${candidate}`
+      };
+    }
+  }
+  return null;
+}
+function getFallbackChain(cli) {
+  return FALLBACK_CHAINS[cli];
+}
+function getCliForModelId(modelId) {
+  for (const [cli, defaultModel] of Object.entries(DEFAULT_MODEL_PER_CLI)) {
+    const chain = FALLBACK_CHAINS[cli];
+    if (chain.includes(modelId)) return cli;
+    if (defaultModel === modelId) return cli;
+  }
+  return void 0;
+}
+var VENDOR_TO_CLI_SLOT = {
+  anthropic: "claude",
+  google: "gemini",
+  openai: "codex"
+};
+function resolveCliSlot(model) {
+  if (model === void 0 || model === "") return void 0;
+  if (MODEL_IDS.includes(model)) {
+    const exact = getCliForModelId(model);
+    if (exact !== void 0) return exact;
+  }
+  const { vendor } = resolveModelIdentitySync(model);
+  return VENDOR_TO_CLI_SLOT[vendor] ?? "opencode";
+}
+var globalCache;
+function getAvailabilityCache() {
+  globalCache ??= new AvailabilityCache();
+  return globalCache;
+}
+function resetAvailabilityCache() {
+  globalCache = void 0;
+}
+function filterAvailableModels(modelIds, cache) {
+  const available = [];
+  const removed = [];
+  for (const id of modelIds) {
+    if (cache.isKnownUnavailable(id)) {
+      removed.push(id);
+    } else {
+      available.push(id);
+    }
+  }
+  return { available, removed };
+}
+
+// src/adapters/gateway-discovery.ts
+var defaultLogger = createLogger({ component: "gateway-discovery" });
+var probe;
+var settled;
+var lazy;
+function discoverGatewayOnce(logger = defaultLogger) {
+  probe ??= runProbe(logger).then((result) => {
+    settled = { result };
+    return result;
+  });
+  return probe;
+}
+async function runProbe(logger) {
+  try {
+    const { buildOpenAICompatAdapters: build } = await import("./openai-compat-adapter-2UHURUZC.js");
+    return await build(logger);
+  } catch (error) {
+    return err(new ConfigError(`Gateway discovery threw: ${getErrorMessage(error)}`));
+  }
+}
+function gatewayDiscoveryStatus() {
+  if (probe === void 0) return "unattempted";
+  if (settled === void 0) return "pending";
+  const { result } = settled;
+  if (result === null) return "not_configured";
+  return discoveredModels(result) === void 0 ? "failed" : "discovered";
+}
+function discoveredModels(result) {
+  return result.ok && result.value.length > 0 ? result.value : void 0;
+}
+function ensureGatewayCatalogue(logger = defaultLogger) {
+  if (lazy !== void 0) return lazy;
+  if (probe !== void 0) return probe.then(() => void 0);
+  lazy = discoverGatewayOnce(logger).then((result) => {
+    registerLazily(result, logger);
+  });
+  return lazy;
+}
+function registerLazily(result, logger) {
+  if (result === null) return;
+  const models = discoveredModels(result);
+  if (models === void 0) {
+    logger.warn(
+      "OpenAI-compatible gateway discovery failed in this process: no gateway catalogue, so gateway family slots are unavailable and a custom-openai fallback model is unverified",
+      { error: result.ok ? "the gateway listed 0 models" : result.error.message }
+    );
+    return;
+  }
+  setGatewaySlotCatalog(models);
+  logger.info("OpenAI-compatible gateway discovered on first use", {
+    modelCount: models.length
+  });
+  logGatewaySlotMapping(logger);
+}
+
+// src/adapters/gateway-rediscovery.ts
+var GATEWAY_REDISCOVERY_INTERVAL_MS = 6e4;
+var generation = 0;
+function gatewayDiscoveryGeneration() {
+  return generation;
+}
+var GatewayRediscovery = class {
+  constructor(options) {
+    this.options = options;
+    this.minIntervalMs = options.minIntervalMs ?? GATEWAY_REDISCOVERY_INTERVAL_MS;
+    this.lastAttemptAt = options.lastAttemptAt ?? getTimeProvider().now();
+  }
+  options;
+  minIntervalMs;
+  lastAttemptAt;
+  inFlight;
+  refused = false;
+  /**
+   * Re-run discovery if the gateway is still missing and the backoff allows.
+   * Never rejects: a failed attempt is logged and the caller proceeds on
+   * whatever the list holds (empty means the CLI path, as at boot).
+   */
+  ensure() {
+    if (this.refused || this.options.target.length > 0) return Promise.resolve();
+    if (this.inFlight !== void 0) return this.inFlight;
+    const now = getTimeProvider().now();
+    if (now - this.lastAttemptAt < this.minIntervalMs) return Promise.resolve();
+    this.lastAttemptAt = now;
+    this.inFlight = this.attempt().finally(() => {
+      this.inFlight = void 0;
+    });
+    return this.inFlight;
+  }
+  async attempt() {
+    const { logger, target } = this.options;
+    let found;
+    try {
+      found = await this.options.discover();
+    } catch (error) {
+      logger.warn("Gateway re-discovery threw; calls stay on CLI subprocesses", {
+        error: getErrorMessage(error)
+      });
+      return;
+    }
+    if (found === "refused") {
+      this.refused = true;
+      return;
+    }
+    if (found === void 0 || found.length === 0) {
+      logger.warn(
+        `Gateway re-discovery found no usable gateway; calls stay on CLI subprocesses. Next attempt no sooner than ${String(Math.round(this.minIntervalMs / 1e3))} s, on the next gateway call.`
+      );
+      return;
+    }
+    target.push(...found);
+    logger.info("OpenAI-compatible gateway re-discovered; gateway calls now go in-process", {
+      modelCount: found.length
+    });
+    this.options.onDiscovered?.(found);
+    generation += 1;
+  }
+};
+var active;
+function setGatewayRediscovery(rediscovery) {
+  active = rediscovery;
+}
+async function ensureGatewayDiscovered() {
+  if (active !== void 0) {
+    await active.ensure();
+    return;
+  }
+  await ensureGatewayCatalogue();
+}
+
+export {
+  AvailabilityCache,
+  resolveFallback,
+  getFallbackChain,
+  getCliForModelId,
+  resolveCliSlot,
+  getAvailabilityCache,
+  resetAvailabilityCache,
+  filterAvailableModels,
+  discoverGatewayOnce,
+  gatewayDiscoveryStatus,
+  gatewayDiscoveryGeneration,
+  GatewayRediscovery,
+  setGatewayRediscovery,
+  ensureGatewayDiscovered
+};
+//# sourceMappingURL=chunk-52OA4YRV.js.map

package/dist/chunk-52OA4YRV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/config/model-availability.ts","../src/adapters/gateway-discovery.ts","../src/adapters/gateway-rediscovery.ts"],"sourcesContent":["/**\n * nexus-agents/config - Model Availability Probes & Fallback Chains\n *\n * Runtime availability tracking for model APIs. Maintains a bounded\n * TTL cache of probe results and provides fallback chain resolution\n * when a model is unavailable.\n *\n * @module config/model-availability\n * (Source: Issue #869)\n */\n\nimport { getTimeProvider } from '../core/index.js';\nimport type { ModelId, CliNameLiteral } from './model-capabilities-types.js';\nimport { MODEL_IDS } from './model-capabilities-types.js';\nimport { DEFAULT_MODEL_PER_CLI } from './in-tree-data.js';\nimport { resolveModelIdentitySync, type ModelVendor } from './model-identity.js';\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\n/** Status of a model probe. */\nexport interface ProbeResult {\n  readonly modelId: ModelId;\n  readonly available: boolean;\n  readonly latencyMs: number;\n  readonly checkedAt: number;\n  readonly error?: string;\n}\n\n/** Configuration for the availability cache. */\nexport interface AvailabilityCacheConfig {\n  /** Time-to-live in ms for probe results. Default: 60_000 (1 min). */\n  readonly ttlMs?: number;\n  /** Maximum entries in the cache. Default: 50. */\n  readonly maxEntries?: number;\n}\n\n/** A function that probes whether a model is reachable. */\nexport type ProbeFn = (modelId: ModelId) => Promise<ProbeResult>;\n\n/** Fallback chain entry with model and reason for fallback. */\nexport interface FallbackEntry {\n  readonly modelId: ModelId;\n  readonly reason: string;\n}\n\n// ---------------------------------------------------------------------------\n// Availability Cache\n// ---------------------------------------------------------------------------\n\nconst DEFAULT_TTL_MS = 60_000;\nconst DEFAULT_MAX_ENTRIES = 50;\n\n/**\n * Bounded TTL cache for model availability probe results.\n * Thread-safe for single-threaded Node.js; no locks needed.\n */\nexport class AvailabilityCache {\n  private readonly cache = new Map<ModelId, ProbeResult>();\n  private readonly ttlMs: number;\n  private readonly maxEntries: number;\n\n  constructor(config: AvailabilityCacheConfig = {}) {\n    this.ttlMs = config.ttlMs ?? DEFAULT_TTL_MS;\n    this.maxEntries = config.maxEntries ?? DEFAULT_MAX_ENTRIES;\n  }\n\n  /** Get a cached probe result, or undefined if expired/missing. */\n  get(modelId: ModelId): ProbeResult | undefined {\n    const entry = this.cache.get(modelId);\n    if (entry === undefined) return undefined;\n    if (getTimeProvider().now() - entry.checkedAt > this.ttlMs) {\n      this.cache.delete(modelId);\n      return undefined;\n    }\n    return entry;\n  }\n\n  /** Store a probe result, evicting oldest if at capacity. */\n  set(result: ProbeResult): void {\n    if (this.cache.size >= this.maxEntries && !this.cache.has(result.modelId)) {\n      const oldest = this.cache.keys().next();\n      if (oldest.done !== true) {\n        this.cache.delete(oldest.value);\n      }\n    }\n    this.cache.set(result.modelId, result);\n  }\n\n  /** Mark a model as unavailable without a full probe. */\n  markUnavailable(modelId: ModelId, error: string): void {\n    this.set({\n      modelId,\n      available: false,\n      latencyMs: 0,\n      checkedAt: getTimeProvider().now(),\n      error,\n    });\n  }\n\n  /** Mark a model as available. */\n  markAvailable(modelId: ModelId, latencyMs: number): void {\n    this.set({\n      modelId,\n      available: true,\n      latencyMs,\n      checkedAt: getTimeProvider().now(),\n    });\n  }\n\n  /** Check if a model is known-unavailable (cached and not expired). */\n  isKnownUnavailable(modelId: ModelId): boolean {\n    const entry = this.get(modelId);\n    return entry !== undefined && !entry.available;\n  }\n\n  /** Get all cached entries (for diagnostics). */\n  entries(): ReadonlyArray<ProbeResult> {\n    return [...this.cache.values()];\n  }\n\n  /** Number of cached entries. */\n  get size(): number {\n    return this.cache.size;\n  }\n\n  /** Clear all cached entries. */\n  clear(): void {\n    this.cache.clear();\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Fallback Chain Resolution\n// ---------------------------------------------------------------------------\n\n/** Default fallback order per CLI (strongest → weakest). */\nconst FALLBACK_CHAINS: Readonly<Record<CliNameLiteral, readonly ModelId[]>> = {\n  claude: ['claude-opus', 'claude-sonnet', 'claude-haiku'],\n  gemini: ['gemini-3-pro', 'gemini-pro', 'gemini-3-flash', 'gemini-flash'],\n  codex: ['codex-5.3', 'codex-5.2', 'codex-5.1-mini'],\n  opencode: ['opencode-custom-opus', 'opencode-custom-sonnet', 'opencode-default'],\n};\n\n/**\n * Resolves a fallback chain for a given model.\n * Returns the first available model in the chain, skipping known-unavailable ones.\n */\nexport function resolveFallback(modelId: ModelId, cache: AvailabilityCache): FallbackEntry | null {\n  const cli = getCliForModelId(modelId);\n  if (cli === undefined) return null;\n\n  const chain = FALLBACK_CHAINS[cli];\n  for (const candidate of chain) {\n    if (candidate === modelId) continue;\n    if (!cache.isKnownUnavailable(candidate)) {\n      return {\n        modelId: candidate,\n        reason: `Fallback from ${modelId} (unavailable) to ${candidate}`,\n      };\n    }\n  }\n  return null;\n}\n\n/**\n * Get the fallback chain for a CLI tool.\n */\nexport function getFallbackChain(cli: CliNameLiteral): readonly ModelId[] {\n  return FALLBACK_CHAINS[cli];\n}\n\n/**\n * Get the CLI name for a model ID.\n */\nexport function getCliForModelId(modelId: ModelId): CliNameLiteral | undefined {\n  for (const [cli, defaultModel] of Object.entries(DEFAULT_MODEL_PER_CLI)) {\n    const chain = FALLBACK_CHAINS[cli as CliNameLiteral];\n    if (chain.includes(modelId)) return cli as CliNameLiteral;\n    if (defaultModel === modelId) return cli as CliNameLiteral;\n  }\n  return undefined;\n}\n\n/**\n * Vendor → canonical `CliName` slot, for models NOT in the curated registry\n * (brand-new releases, or API/openrouter models). Keeps the routing/outcome/\n * tune pipeline keyed on a real slot instead of dropping the outcome (#3317 /\n * #3293). `opencode` is the multi-model catch-all slot for non-big-3 vendors.\n */\nconst VENDOR_TO_CLI_SLOT: Partial<Record<ModelVendor, CliNameLiteral>> = {\n  anthropic: 'claude',\n  google: 'gemini',\n  openai: 'codex',\n};\n\n/**\n * Resolve a model string to a canonical `CliName` slot for routing/outcome\n * recording. Known models resolve to their exact curated slot; **unknown**\n * models (new releases, API/openrouter models not yet in the registry) fall\n * back to the vendor-derived slot — so the routing/outcome/tune pipeline still\n * records and learns instead of silently dropping the outcome with an\n * undefined cli (#3317 / #3293). Returns undefined only for an absent model\n * (no execution happened).\n */\nexport function resolveCliSlot(model: string | undefined): CliNameLiteral | undefined {\n  if (model === undefined || model === '') return undefined;\n  if ((MODEL_IDS as readonly string[]).includes(model)) {\n    const exact = getCliForModelId(model as ModelId);\n    if (exact !== undefined) return exact;\n  }\n  const { vendor } = resolveModelIdentitySync(model);\n  return VENDOR_TO_CLI_SLOT[vendor] ?? 'opencode';\n}\n\n// ---------------------------------------------------------------------------\n// Singleton Cache (shared across the process)\n// ---------------------------------------------------------------------------\n\nlet globalCache: AvailabilityCache | undefined;\n\n/** Get the shared availability cache (lazy-init). */\nexport function getAvailabilityCache(): AvailabilityCache {\n  globalCache ??= new AvailabilityCache();\n  return globalCache;\n}\n\n/** Reset the global cache (for testing). */\nexport function resetAvailabilityCache(): void {\n  globalCache = undefined;\n}\n\n// ---------------------------------------------------------------------------\n// Filter Integration\n// ---------------------------------------------------------------------------\n\n/**\n * Filters out known-unavailable models from a set of model IDs.\n * Returns the filtered set, or null if no models were removed.\n * Used by scoreAllModels() to skip unavailable models.\n */\nexport function filterAvailableModels(\n  modelIds: readonly string[],\n  cache: AvailabilityCache\n): { available: string[]; removed: string[] } {\n  const available: string[] = [];\n  const removed: string[] = [];\n  for (const id of modelIds) {\n    if (cache.isKnownUnavailable(id as ModelId)) {\n      removed.push(id);\n    } else {\n      available.push(id);\n    }\n  }\n  return { available, removed };\n}\n","/**\n * One gateway discovery per process, for every process (#4392).\n *\n * Discovery (`GET /v1/models`, `buildOpenAICompatAdapters`) used to run only\n * in the MCP server bootstrap (`cli-server-gateway.ts`). A CLI process —\n * `nexus-agents orchestrate`, or any direct `createAutoAdapter` caller — never\n * had a catalogue, so every gateway-aware path fell back to its no-gateway\n * branch: the family slots stayed `inactive` and the `custom-openai` fallback\n * sent `NEXUS_CUSTOM_MODEL ?? 'gpt-5.5'` to a gateway that might not serve it.\n *\n * This module memoizes the discovery for the process:\n *\n * - {@link discoverGatewayOnce} — the one probe. The server bootstrap awaits\n *   it and handles the outcome itself (sandbox exits, arm registration), so a\n *   server never probes twice.\n * - {@link ensureGatewayCatalogue} — the lazy path. Called on first adapter\n *   use (through `ensureGatewayDiscovered`), it runs the probe if nothing has\n *   and registers the family-slot catalogue on success. When the bootstrap\n *   already ran the probe it only waits for it: registration is the\n *   bootstrap's.\n *\n * Outcomes, named (the empty case included):\n * - no gateway configured → `not_configured`: nothing registered, every\n *   caller's behaviour is what it was before this module existed;\n * - models discovered → `discovered`: the catalogue is registered;\n * - probe failed, threw, refused, or listed zero models → `failed`: logged\n *   once, nothing registered. Callers that still send a model read\n *   {@link gatewayDiscoveryStatus} and say the model is unverified\n *   (`auto-adapter.ts` `customModelChoice`) instead of sending it as if valid.\n *\n * A failed lazy probe is not retried in this process: a CLI process is short\n * and the operator sees the warning. The long-lived server retries through\n * `gateway-rediscovery.ts`, which is unaffected.\n *\n * @module adapters/gateway-discovery\n */\n\nimport type { ILogger, IModelAdapter } from '../core/index.js';\nimport { createLogger, err, getErrorMessage, ConfigError } from '../core/index.js';\nimport type { buildOpenAICompatAdapters } from './openai-compat-adapter.js';\nimport { logGatewaySlotMapping, setGatewaySlotCatalog } from './gateway-family-slots.js';\n\n/** One discovery's raw result, as `buildOpenAICompatAdapters` returns it. */\nexport type GatewayDiscoveryResult = Awaited<ReturnType<typeof buildOpenAICompatAdapters>>;\n\n/** Where this process's discovery stands. */\nexport type GatewayDiscoveryStatus =\n  'unattempted' | 'pending' | 'not_configured' | 'discovered' | 'failed';\n\nconst defaultLogger = createLogger({ component: 'gateway-discovery' });\n\nlet probe: Promise<GatewayDiscoveryResult> | undefined;\nlet settled: { readonly result: GatewayDiscoveryResult } | undefined;\nlet lazy: Promise<void> | undefined;\n\n/**\n * The process's one discovery probe; every call after the first returns the\n * same promise. Never rejects: a thrown probe becomes an error result.\n */\nexport function discoverGatewayOnce(\n  logger: ILogger = defaultLogger\n): Promise<GatewayDiscoveryResult> {\n  probe ??= runProbe(logger).then((result) => {\n    settled = { result };\n    return result;\n  });\n  return probe;\n}\n\nasync function runProbe(logger: ILogger): Promise<GatewayDiscoveryResult> {\n  try {\n    // Loaded on first probe, not at import: this module sits under\n    // `gateway-rediscovery.ts`, which every resilient adapter imports, and the\n    // openai-compat chain (the `openai` SDK) should not load with it.\n    const { buildOpenAICompatAdapters: build } = await import('./openai-compat-adapter.js');\n    return await build(logger);\n  } catch (error: unknown) {\n    return err(new ConfigError(`Gateway discovery threw: ${getErrorMessage(error)}`));\n  }\n}\n\n/** Where this process's discovery stands; see the module doc for each value. */\nexport function gatewayDiscoveryStatus(): GatewayDiscoveryStatus {\n  if (probe === undefined) return 'unattempted';\n  if (settled === undefined) return 'pending';\n  const { result } = settled;\n  if (result === null) return 'not_configured';\n  return discoveredModels(result) === undefined ? 'failed' : 'discovered';\n}\n\n/** The discovered models, or undefined for a failed or empty discovery. */\nfunction discoveredModels(\n  result: NonNullable<GatewayDiscoveryResult>\n): readonly IModelAdapter[] | undefined {\n  return result.ok && result.value.length > 0 ? result.value : undefined;\n}\n\n/**\n * Make sure this process has tried discovery, registering the family-slot\n * catalogue when the probe is this call's. Never rejects.\n */\nexport function ensureGatewayCatalogue(logger: ILogger = defaultLogger): Promise<void> {\n  if (lazy !== undefined) return lazy;\n  // The bootstrap's probe: it registers what it found itself.\n  if (probe !== undefined) return probe.then(() => undefined);\n  lazy = discoverGatewayOnce(logger).then((result) => {\n    registerLazily(result, logger);\n  });\n  return lazy;\n}\n\nfunction registerLazily(result: GatewayDiscoveryResult, logger: ILogger): void {\n  if (result === null) return; // not configured: the named empty case\n  const models = discoveredModels(result);\n  if (models === undefined) {\n    logger.warn(\n      'OpenAI-compatible gateway discovery failed in this process: no gateway catalogue, so ' +\n        'gateway family slots are unavailable and a custom-openai fallback model is unverified',\n      { error: result.ok ? 'the gateway listed 0 models' : result.error.message }\n    );\n    return;\n  }\n  setGatewaySlotCatalog(models);\n  logger.info('OpenAI-compatible gateway discovered on first use', {\n    modelCount: models.length,\n  });\n  logGatewaySlotMapping(logger);\n}\n\n/** Test-only: forget this process's discovery. */\nexport function _resetGatewayDiscovery(): void {\n  probe = undefined;\n  settled = undefined;\n  lazy = undefined;\n}\n","/**\n * Lazy gateway re-discovery (#6608 item 4, #6659).\n *\n * Discovery runs once at startup. A gateway that was down at boot used to\n * leave the process on CLI subprocesses for its whole life. When the boot\n * probe fails for a reason that can clear on its own (unreachable, error\n * status, zero models), the bootstrap hands the tools an EMPTY, live adapter\n * list and arms a {@link GatewayRediscovery}; the first gateway-needing call\n * after the backoff re-runs discovery and fills that list in place, so every\n * holder of the reference sees the gateway from then on.\n *\n * Who triggers it (#6659): every adapter the registry hands out is a\n * `ResilientAdapter`, whose `ensureAdapter` calls\n * {@link ensureGatewayDiscovered} before each call, so orchestrate,\n * execute_expert and every other registry consumer trigger it, not only the\n * voter paths. A successful late discovery bumps\n * {@link gatewayDiscoveryGeneration}; a resilient adapter that detected\n * before it re-detects once, which moves the default adapter and the\n * family-slot adapters onto the gateway.\n *\n * Bounds, by construction: never at startup (the boot attempt is the first\n * attempt, and the clock starts there); at most one attempt per\n * {@link GATEWAY_REDISCOVERY_INTERVAL_MS}; concurrent callers share one\n * in-flight attempt, which the discovery request's own timeout bounds;\n * nothing retries on a timer, so an idle process makes no calls; once the\n * list is filled, or discovery was refused for a reason retrying cannot fix,\n * the check is a flag test.\n *\n * @module adapters/gateway-rediscovery\n */\n\nimport type { ILogger, IModelAdapter } from '../core/index.js';\nimport { getErrorMessage, getTimeProvider } from '../core/index.js';\nimport { ensureGatewayCatalogue } from './gateway-discovery.js';\n\n/** Minimum spacing between discovery attempts, the boot attempt included. */\nconst GATEWAY_REDISCOVERY_INTERVAL_MS = 60_000;\n\n/**\n * One discovery attempt's result: the adapters; `undefined` when it failed in\n * a way that can clear (already logged; retried after the backoff); or\n * `'refused'` when retrying cannot help (already logged; never retried).\n */\ntype GatewayDiscoveryAttempt = readonly IModelAdapter[] | 'refused' | undefined;\n\nexport interface GatewayRediscoveryOptions {\n  /** The live list the tools hold. Filled in place on success; never replaced. */\n  readonly target: IModelAdapter[];\n  /** One discovery attempt. */\n  readonly discover: () => Promise<GatewayDiscoveryAttempt>;\n  /** Runs once, after the target is filled — the bootstrap registers the arm here. */\n  readonly onDiscovered?: (adapters: readonly IModelAdapter[]) => void;\n  readonly logger: ILogger;\n  readonly minIntervalMs?: number;\n  /** When the last attempt ran; defaults to now (the boot attempt just failed). */\n  readonly lastAttemptAt?: number;\n}\n\n/** Successful late discoveries in this process; 0 until one happens. */\nlet generation = 0;\n\n/**\n * How many late discoveries have succeeded. A holder of an adapter chosen\n * before the gateway existed compares it with the value it saw then, and\n * re-selects when it moved.\n */\nexport function gatewayDiscoveryGeneration(): number {\n  return generation;\n}\n\nexport class GatewayRediscovery {\n  private readonly minIntervalMs: number;\n  private lastAttemptAt: number;\n  private inFlight: Promise<void> | undefined;\n  private refused = false;\n\n  constructor(private readonly options: GatewayRediscoveryOptions) {\n    this.minIntervalMs = options.minIntervalMs ?? GATEWAY_REDISCOVERY_INTERVAL_MS;\n    this.lastAttemptAt = options.lastAttemptAt ?? getTimeProvider().now();\n  }\n\n  /**\n   * Re-run discovery if the gateway is still missing and the backoff allows.\n   * Never rejects: a failed attempt is logged and the caller proceeds on\n   * whatever the list holds (empty means the CLI path, as at boot).\n   */\n  ensure(): Promise<void> {\n    if (this.refused || this.options.target.length > 0) return Promise.resolve();\n    if (this.inFlight !== undefined) return this.inFlight;\n    const now = getTimeProvider().now();\n    if (now - this.lastAttemptAt < this.minIntervalMs) return Promise.resolve();\n    this.lastAttemptAt = now;\n    this.inFlight = this.attempt().finally(() => {\n      this.inFlight = undefined;\n    });\n    return this.inFlight;\n  }\n\n  private async attempt(): Promise<void> {\n    const { logger, target } = this.options;\n    let found: GatewayDiscoveryAttempt;\n    try {\n      found = await this.options.discover();\n    } catch (error: unknown) {\n      logger.warn('Gateway re-discovery threw; calls stay on CLI subprocesses', {\n        error: getErrorMessage(error),\n      });\n      return;\n    }\n    if (found === 'refused') {\n      // Logged with its remedy by `discover`; retrying cannot change it.\n      this.refused = true;\n      return;\n    }\n    if (found === undefined || found.length === 0) {\n      logger.warn(\n        `Gateway re-discovery found no usable gateway; calls stay on CLI subprocesses. ` +\n          `Next attempt no sooner than ${String(Math.round(this.minIntervalMs / 1000))} s, on the next gateway call.`\n      );\n      return;\n    }\n    target.push(...found);\n    logger.info('OpenAI-compatible gateway re-discovered; gateway calls now go in-process', {\n      modelCount: found.length,\n    });\n    this.options.onDiscovered?.(found);\n    generation += 1;\n  }\n}\n\nlet active: GatewayRediscovery | undefined;\n\n/** Install (or with `undefined`, clear) the process's re-discovery. Set by the bootstrap. */\nexport function setGatewayRediscovery(rediscovery: GatewayRediscovery | undefined): void {\n  active = rediscovery;\n}\n\n/**\n * Called on the gateway-needing paths before they read gateway state. With a\n * re-discovery armed (the server's boot probe failed retryably) it runs that.\n * Otherwise it makes sure this process has tried discovery at all (#4392):\n * outside the MCP server nothing else does, so the first call runs the one\n * memoized probe (`gateway-discovery.ts`) and registers the catalogue; every\n * later call, and every call in a server whose bootstrap probed, is a settled\n * promise. No gateway configured probes nothing.\n */\nexport async function ensureGatewayDiscovered(): Promise<void> {\n  if (active !== undefined) {\n    await active.ensure();\n    return;\n  }\n  await ensureGatewayCatalogue();\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-LXHNZWEI.js → chunk-5W2GYHYM.js}

@@ -8,7 +8,7 @@ import {
   err,
   getErrorMessage,
   ok
-} from "./chunk-R6QANTJE.js";
+} from "./chunk-ZZYHNIKP.js";
 import {
   findRepoRoot,
   getActiveWorkspaceRoot,
@@ -213,4 +213,4 @@ export {
   loadPapersRegistry,
   savePapersRegistry
 };
-//# sourceMappingURL=chunk-LXHNZWEI.js.map
+//# sourceMappingURL=chunk-5W2GYHYM.js.map

package/dist/{chunk-2W3EA2WQ.js → chunk-6HJ2LLG4.js}

@@ -8,7 +8,7 @@ import {
   MCP_TIMEOUTS,
   TEST_TIMEOUTS,
   WORKFLOW_TIMEOUTS
-} from "./chunk-R6QANTJE.js";
+} from "./chunk-ZZYHNIKP.js";
 import {
   createGetToolRateLimit
 } from "./chunk-LWOX65CP.js";
@@ -223,4 +223,4 @@ export {
   CUSTOM_API_DEFAULT_MODEL,
   DEFAULTS
 };
-//# sourceMappingURL=chunk-2W3EA2WQ.js.map
+//# sourceMappingURL=chunk-6HJ2LLG4.js.map

package/dist/{chunk-HGHUR3D2.js → chunk-7H33Z34W.js}

@@ -1,6 +1,6 @@
 import {
   redactCredentialShapes
-} from "./chunk-R6QANTJE.js";
+} from "./chunk-ZZYHNIKP.js";
 
 // src/security/output-sanitizer.ts
 var REDACTED_KEY_PLACEHOLDER = "[REDACTED_KEY]";
@@ -54,4 +54,4 @@ export {
   sanitizeErrorDetails,
   sanitizeStringLeaves
 };
-//# sourceMappingURL=chunk-HGHUR3D2.js.map
+//# sourceMappingURL=chunk-7H33Z34W.js.map

package/dist/{chunk-W5CZY7XH.js → chunk-AANXFVMA.js}

@@ -4,7 +4,7 @@ import {
 import {
   assessReputation,
   sanitizeInput
-} from "./chunk-Y45MXDIH.js";
+} from "./chunk-ZUKBQ7TD.js";
 import {
   allOf
 } from "./chunk-EZNIYU5T.js";
@@ -13,7 +13,7 @@ import {
   err,
   getTimeProvider,
   ok
-} from "./chunk-R6QANTJE.js";
+} from "./chunk-ZZYHNIKP.js";
 
 // src/dogfooding/pr-reviewer-helpers.ts
 import { randomUUID } from "node:crypto";
@@ -477,4 +477,4 @@ export {
   createFailedReview,
   reviewPostingBlock
 };
-//# sourceMappingURL=chunk-W5CZY7XH.js.map
+//# sourceMappingURL=chunk-AANXFVMA.js.map

package/dist/{chunk-RYXH3MW5.js → chunk-ACGWYCEH.js}

@@ -7,7 +7,7 @@ import {
   getErrorMessage,
   getTimeProvider,
   ok
-} from "./chunk-R6QANTJE.js";
+} from "./chunk-ZZYHNIKP.js";
 
 // src/context/session-memory.ts
 import * as fs from "node:fs";
@@ -374,4 +374,4 @@ export {
   SessionMemory,
   createSessionMemory
 };
-//# sourceMappingURL=chunk-RYXH3MW5.js.map
+//# sourceMappingURL=chunk-ACGWYCEH.js.map

package/dist/{chunk-2GQ7HGUC.js → chunk-B2KJ36K6.js}

@@ -4,7 +4,7 @@ import {
 import {
   createLogger,
   getTimeProvider
-} from "./chunk-R6QANTJE.js";
+} from "./chunk-ZZYHNIKP.js";
 
 // src/mcp/tools/scanner-registry-fetcher.ts
 import { z } from "zod";
@@ -740,4 +740,4 @@ export {
   generateSecurityPlan,
   buildPlanFromAnalysis
 };
-//# sourceMappingURL=chunk-2GQ7HGUC.js.map
+//# sourceMappingURL=chunk-B2KJ36K6.js.map

package/dist/{chunk-HHXQ6MTA.js → chunk-CKNCC6GY.js}

@@ -8,7 +8,7 @@ import {
   getAdaptiveBonus,
   getOutcomeStore,
   hasMeasuredCategory
-} from "./chunk-R6QANTJE.js";
+} from "./chunk-ZZYHNIKP.js";
 
 // src/cli/doctor-deep.ts
 var CLI_NAMES = ["claude", "gemini", "codex", "opencode"];
@@ -148,4 +148,4 @@ export {
   runDeepDiagnostics,
   formatDeepDiagnostics
 };
-//# sourceMappingURL=chunk-HHXQ6MTA.js.map
+//# sourceMappingURL=chunk-CKNCC6GY.js.map

package/dist/{chunk-2WZLDQ3F.js → chunk-CRMVFXQI.js}

@@ -1,15 +1,13 @@
 import {
   ensureGatewayDiscovered,
-  gatewayDiscoveryGeneration
-} from "./chunk-MX7TQLA6.js";
-import {
+  gatewayDiscoveryGeneration,
   resolveCliSlot
-} from "./chunk-XBUEG2X3.js";
+} from "./chunk-52OA4YRV.js";
 import {
   createLogger,
   getTimeProvider,
   isRateLimitText
-} from "./chunk-R6QANTJE.js";
+} from "./chunk-ZZYHNIKP.js";
 
 // src/pipeline/expert-access-mode.ts
 var logger = createLogger({ component: "expert-bridge" });
@@ -71,7 +69,7 @@ async function getMcpConfigPath() {
   if (cachedMcpConfigPath !== null) return cachedMcpConfigPath;
   mcpConfigInitPromise ??= (async () => {
     try {
-      const { generateMcpConfig } = await import("./child-mcp-config-ZYAMNUSI.js");
+      const { generateMcpConfig } = await import("./child-mcp-config-I7QXA4PU.js");
       const config = await generateMcpConfig();
       cachedMcpConfigPath = config.configPath;
       cachedMcpConfigCleanup = config.cleanup;
@@ -165,8 +163,8 @@ async function getRouter() {
   }
   if (cachedRouter !== null) return cachedRouter;
   routerInitPromise ??= (async () => {
-    const { createAllAdapters } = await import("./factory-D6ZSZ43V.js");
-    const { createCompositeRouter } = await import("./composite-router-32IHJVPU.js");
+    const { createAllAdapters } = await import("./factory-GKPHMR6C.js");
+    const { createCompositeRouter } = await import("./composite-router-2XQS55LZ.js");
     const adapters = createAllAdapters();
     const superseded = generation !== routerGeneration;
     if (adapters.size === 0) {
@@ -177,7 +175,7 @@ async function getRouter() {
     if (superseded) return router;
     cachedRouter = router;
     try {
-      const { createCliCircuitBreakerIntegration } = await import("./cli-circuit-breaker-ATLGIZHJ.js");
+      const { createCliCircuitBreakerIntegration } = await import("./cli-circuit-breaker-MDYHAQUN.js");
       cachedCircuitBreaker = createCliCircuitBreakerIntegration([...adapters.values()]);
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
@@ -325,4 +323,4 @@ export {
   tokenSplitFromUsage,
   executeExpert
 };
-//# sourceMappingURL=chunk-2WZLDQ3F.js.map
+//# sourceMappingURL=chunk-CRMVFXQI.js.map