nexus-agents 10.2.0 → 11.0.1

package/dist/{chunk-WKFPKPEM.js → chunk-EBOAFTOG.js}

@@ -7,13 +7,13 @@ import {
   getModelSelectionShadowFile,
   isPersistenceEnabled,
   isStrategyDistillationEnabled
-} from "./chunk-UE7A2XHM.js";
+} from "./chunk-RUHKJC3X.js";
 import {
   findRepoRoot,
   getNexusDataDir,
   nexusDataPath,
   parseBoolEnv
-} from "./chunk-LWOX65CP.js";
+} from "./chunk-CH6IBWXH.js";
 import {
   CLI_NAMES,
   CliNameSchema,
@@ -2182,13 +2182,13 @@ function lookupCanonicalPricing(model) {
     const entry2 = registry.getEntry(matched.id);
     return {
       pricing: toPricing(matched.pricing),
-      source: entry2.pricing === void 0 ? "in-tree" : entry2.source
+      source: entry2.pricing === void 0 ? "in-tree" : pricingSourceOf(entry2)
     };
   }
   const entry = registry.getEntry(model);
   return {
     pricing: toPricing(entry.pricing),
-    source: registry.getEntry(entry.resolvedFrom ?? entry.id).source
+    source: pricingSourceOf(registry.getEntry(entry.resolvedFrom ?? entry.id))
   };
 }
 function calculateCost(model, inputTokens, outputTokens) {
@@ -4928,9 +4928,14 @@ function routingArmDisplaySlot(armId) {
     case "api:custom-openai":
       return "opencode";
     default:
-      return armId.startsWith("api:") ? UNKNOWN_ENDPOINT_ARM_DISPLAY_SLOT : armId;
+      return armId;
   }
 }
+function routingArmCliSlot(armId) {
+  if (isCliName(armId)) return armId;
+  const parsed = ApiArmIdSchema.safeParse(armId);
+  return parsed.success ? routingArmDisplaySlot(parsed.data) : void 0;
+}
 var API_ENDPOINT_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/;
 var EndpointArmIdSchema = z3.templateLiteral([
   "api:",
@@ -4941,7 +4946,7 @@ function isEndpointArmId(value) {
 }
 var UNKNOWN_ENDPOINT_ARM_DISPLAY_SLOT = "opencode";
 function observedArmDisplaySlot(armId) {
-  return routingArmDisplaySlot(armId);
+  return routingArmCliSlot(armId) ?? UNKNOWN_ENDPOINT_ARM_DISPLAY_SLOT;
 }
 
 // src/cli-adapters/types-capability.ts
@@ -4974,6 +4979,9 @@ var CLI_VERSION_REQUIREMENTS = {
 var DEFAULT_CAPABILITIES = buildCliCapabilityProfiles();
 
 // src/learning/routing-decision-mappers.ts
+function recordedArm(armId) {
+  return routingArmCliSlot(armId) ?? armId;
+}
 function mapFeedbackRoutingDecision(decision, context) {
   return {
     id: context.id,
@@ -4982,9 +4990,9 @@ function mapFeedbackRoutingDecision(decision, context) {
     routerType: context.routerType,
     routerTypeMeasured: context.routerTypeMeasured,
     query: context.query ?? "",
-    selectedModel: routingArmDisplaySlot(decision.cliName),
+    selectedModel: recordedArm(decision.cliName),
     confidence: decision.confidence,
-    selectedTier: decision.preferenceTier
+    selectedTier: routingArmCliSlot(decision.cliName) === void 0 ? void 0 : decision.preferenceTier
   };
 }
 function mapObserverRoutingDecision(decision, context) {
@@ -4992,10 +5000,10 @@ function mapObserverRoutingDecision(decision, context) {
     timestamp: context.timestamp,
     taskId: context.taskId,
     taskDescription: context.query.length > 100 ? context.query.substring(0, 100) + "..." : context.query,
-    selectedCli: routingArmDisplaySlot(decision.cliName),
+    selectedCli: recordedArm(decision.cliName),
     confidence: decision.confidence,
     reason: decision.reason,
-    alternatives: decision.alternatives.map(routingArmDisplaySlot),
+    alternatives: decision.alternatives.map(recordedArm),
     stagesExecuted: decision.stagesExecuted,
     decisionTimeMs: decision.decisionTimeMs,
     withinBudget: decision.withinBudget,
@@ -5011,8 +5019,8 @@ function mapStoredRoutingDecision(decision, context) {
     timestamp: context.timestamp,
     routerType: context.routerType,
     routerTypeMeasured: context.routerTypeMeasured,
-    selectedModel: routingArmDisplaySlot(decision.cliName),
-    alternativeModels: decision.alternatives.map(routingArmDisplaySlot),
+    selectedModel: recordedArm(decision.cliName),
+    alternativeModels: decision.alternatives.map(recordedArm),
     confidence: decision.confidence,
     reason: decision.reason,
     taskProfile: {
@@ -5803,7 +5811,7 @@ function computeCostDetail(modelId, inputTokens, outputTokens) {
   return {
     costUsd: roundToMicroUsd(costUsd),
     priced: true,
-    ...getDefaultRegistry().getEntry(entry.resolvedFrom ?? entry.id).source === "manifest" ? { declared: true } : {},
+    ...pricingSourceOf(getDefaultRegistry().getEntry(entry.resolvedFrom ?? entry.id)) === "manifest" ? { declared: true } : {},
     resolvedId,
     ...provenance,
     ...entry.pricingProvenance !== void 0 ? { pricingProvenance: entry.pricingProvenance } : {}
@@ -6060,7 +6068,7 @@ function adapterReadiness(adapter, options) {
   const ceiling = resolveClassGuardMs("interactive");
   const requested = options.timeoutMs ?? ceiling;
   const timeoutMs = Number.isFinite(requested) && requested > 0 ? Math.min(requested, ceiling) : ceiling;
-  const flight = import("./cli-readiness-O6EOQV4L.js").then(({ probeServes }) => probeServes(adapter, timeoutMs)).finally(() => readinessFlights.delete(adapter));
+  const flight = import("./cli-readiness-7I5BYWLA.js").then(({ probeServes }) => probeServes(adapter, timeoutMs)).finally(() => readinessFlights.delete(adapter));
   readinessFlights.set(adapter, flight);
   return flight;
 }
@@ -6070,7 +6078,7 @@ async function servesListedModel(adapter, modelId, cli) {
     const models = await adapter.listModels();
     if (models.length === 0) return "unknown";
     const requestedKey = canonicalModelKey(modelId);
-    const findCanonicalModel2 = cli === "codex" ? (await import("./model-config-helpers-QNV3KD2W.js")).findCanonicalModel : void 0;
+    const findCanonicalModel2 = cli === "codex" ? (await import("./model-config-helpers-QFWX2QAO.js")).findCanonicalModel : void 0;
     const requestedEntry = requestedKey === null ? findCanonicalModel2?.("codex", modelId) : void 0;
     const listed = models.some((model) => {
       const listedEntry = findCanonicalModel2?.("codex", model.id);
@@ -6715,6 +6723,9 @@ var DEFAULT_REQUEST_LIMITS = {
 };
 var RATE_LIMIT_WINDOW_MS = 6e4;
 function getDefaultConfig(cli) {
+  if (!isCliName(cli)) {
+    return { tokenLimit: Infinity, requestLimit: Infinity, windowMs: RATE_LIMIT_WINDOW_MS };
+  }
   const envPrefix = `NEXUS_${cli.toUpperCase()}`;
   const tokenEnv = process.env[`${envPrefix}_TOKEN_LIMIT`];
   const requestEnv = process.env[`${envPrefix}_REQUEST_LIMIT`];
@@ -7364,6 +7375,237 @@ function mapModelErrorToCategory(error) {
   }
 }
 
+// src/adapters/sdk/gateway-catalog.ts
+var catalogs = /* @__PURE__ */ new Map();
+var owners = /* @__PURE__ */ new Map();
+function retainGatewayCatalog(arm, owner) {
+  let retained = owners.get(arm);
+  if (retained === void 0) {
+    retained = /* @__PURE__ */ new Set();
+    owners.set(arm, retained);
+  }
+  retained.add(owner);
+}
+function releaseGatewayCatalog(arm, owner) {
+  const retained = owners.get(arm);
+  if (retained?.delete(owner) !== true) return;
+  if (retained.size > 0) return;
+  owners.delete(arm);
+  clearGatewayCatalog(arm);
+}
+function setGatewayCatalog(arm, modelIds) {
+  if (modelIds.length === 0) {
+    throw new Error(
+      `Gateway catalogue for ${arm} is empty; an arm with no model is not registrable`
+    );
+  }
+  catalogs.set(arm, [...modelIds]);
+}
+function getGatewayCatalog(arm) {
+  return catalogs.get(arm);
+}
+function clearGatewayCatalog(arm) {
+  catalogs.delete(arm);
+}
+
+// src/adapters/gateway-arm-adapter.ts
+function createGatewayArmAdapter(armId, models, deps) {
+  if (models.length === 0) {
+    throw new ConfigError(`Gateway arm ${armId} has no models; nothing to register`);
+  }
+  return new GatewayArmAdapter(armId, models, deps);
+}
+function ownsGatewayCircuitAdmission(adapter, armId, registry) {
+  return adapter instanceof GatewayArmAdapter && adapter.gatewayArm === armId && adapter.getCircuitBreakerRegistry() === registry;
+}
+var GatewayArmAdapter = class {
+  constructor(armId, models, deps) {
+    this.armId = armId;
+    this.models = models;
+    this.deps = deps;
+    retainGatewayCatalog(armId, this);
+  }
+  armId;
+  models;
+  deps;
+  selectedAt = /* @__PURE__ */ new Date();
+  resolvedDelegate;
+  /**
+   * The gateway-arm marker (#4392 step 4, `isGatewayModelAdapter`): a
+   * telemetry writer that is handed this wrapper prices its calls by the
+   * arm's `NEXUS_GATEWAY_COST` declaration, never the delegate's list price.
+   */
+  get gatewayArm() {
+    return this.armId;
+  }
+  // --- IModelAdapter (forwarded to the delegate) ---
+  get providerId() {
+    return this.requireDelegate().providerId;
+  }
+  get modelId() {
+    return this.requireDelegate().modelId;
+  }
+  get capabilities() {
+    return this.requireDelegate().capabilities;
+  }
+  /**
+   * Both halves of the breaker contract, as `base-adapter.ts` records them
+   * for the CLI slots on the same shared registry. The success half matters
+   * (#6403 review): in the closed state `recordSuccess` zeroes the failure
+   * count, which is what makes the threshold mean CONSECUTIVE failures, and
+   * in half-open it is what closes the circuit again. Without it a long-lived
+   * process counted scattered blips for its whole lifetime and, once open,
+   * sat half-open forever with any single error re-opening it.
+   */
+  async complete(request) {
+    const resolved = this.resolveDelegate();
+    if (!resolved.ok) {
+      return err(new ModelError(resolved.error.message, { code: ErrorCode.MODEL_UNAVAILABLE }));
+    }
+    const delegate = resolved.value;
+    const breaker = this.deps.circuitBreakerRegistry.getArmBreaker(this.armId);
+    const admission = breaker.canExecute();
+    if (!admission.ok) {
+      return err(
+        new ModelError(admission.error.message, {
+          code: ErrorCode.MODEL_UNAVAILABLE,
+          cause: admission.error,
+          retryable: false
+        })
+      );
+    }
+    const result = await delegate.complete(request);
+    if (result.ok) {
+      breaker.recordSuccess();
+    } else if (isCallerCancelled(result.error)) {
+      breaker.releaseHalfOpenProbe();
+    } else {
+      this.recordFailure(result.error, delegate.providerId);
+    }
+    return result;
+  }
+  stream(request) {
+    return this.requireDelegate().stream(request);
+  }
+  countTokens(text) {
+    return this.requireDelegate().countTokens(text);
+  }
+  validateConfig() {
+    const resolved = this.resolveDelegate();
+    return resolved.ok ? resolved.value.validateConfig() : resolved;
+  }
+  /** The whole catalogue, not the delegate alone — that is what the arm fronts. */
+  listModels() {
+    return Promise.resolve(this.models.map((m) => ({ id: m.modelId })));
+  }
+  // --- IResilientAdapter ---
+  /**
+   * `source: 'api'` always; `degraded` while the arm's breaker is open. There
+   * is no `unavailable`: the arm exists only once discovery succeeded.
+   */
+  getHealth() {
+    return {
+      source: "api",
+      state: this.deps.circuitBreakerRegistry.isArmOpen(this.armId) ? "degraded" : "healthy",
+      selectedAt: this.selectedAt,
+      failoverCount: 0
+    };
+  }
+  /** Nothing to re-detect: the catalogue is fixed at registration. */
+  refresh() {
+    return Promise.resolve();
+  }
+  /** A gateway arm has no CLI to prefer; said at debug so a caller can see it was ignored. */
+  setPreferredCli(cli) {
+    this.deps.logger.debug("setPreferredCli ignored on a gateway arm", { arm: this.armId, cli });
+  }
+  /** The arm never fails over, so the callback is never invoked. */
+  onFailover() {
+    return () => void 0;
+  }
+  getCircuitBreakerRegistry() {
+    return this.deps.circuitBreakerRegistry;
+  }
+  /**
+   * No listeners or timers are held; the breaker outlives the arm on purpose
+   * (a re-registered gateway keeps its failure history). The shared catalogue
+   * stays while any registry owns a live wrapper for this endpoint. Repeated
+   * disposal is harmless, and a wrapper retained before replacement prevents
+   * disposal of the earlier wrapper from clearing the endpoint's metadata.
+   */
+  dispose() {
+    releaseGatewayCatalog(this.armId, this);
+  }
+  // --- Private ---
+  /** Resolve lazily after bootstrap, and pin a successful default to this arm. */
+  resolveDelegate() {
+    if (this.resolvedDelegate !== void 0) return ok(this.resolvedDelegate);
+    const resolved = resolveGatewayDefault(process.env, this.deps.logger);
+    if (resolved.kind !== "resolved") {
+      return err(new ConfigError(`Gateway arm ${this.armId} has no chat default`));
+    }
+    const delegate = this.models.find((model) => model === resolved.adapter);
+    if (delegate === void 0) {
+      return err(new ConfigError(`Gateway default does not belong to arm ${this.armId}`));
+    }
+    this.resolvedDelegate = delegate;
+    return ok(delegate);
+  }
+  /** Metadata and streaming interfaces cannot carry a Result error. */
+  requireDelegate() {
+    const resolved = this.resolveDelegate();
+    if (!resolved.ok) throw resolved.error;
+    return resolved.value;
+  }
+  /**
+   * `ResilientAdapter.recordBreakerFailure`, keyed on the ARM (#3423, #5359):
+   * a transient rate limit is recorded by the telemetry branch and exempt from
+   * the breaker (it would double-count, and open a breaker on a condition that
+   * clears within the minute); a DURABLE capacity cap is counted even though it
+   * is rate-limit-shaped, because it never clears; everything else counts.
+   * Every rate-limit-shaped failure, durable or not, is a telemetry event.
+   */
+  recordFailure(error, provider) {
+    const breaker = this.deps.circuitBreakerRegistry.getArmBreaker(this.armId);
+    const category = mapModelErrorToCategory(error);
+    const rateLimitLike = category === "rate_limit" || isRateLimitLikeError(error);
+    if (rateLimitLike) this.recordRateLimit(error, provider);
+    if (isDurableCapacityError(error)) {
+      breaker.recordFailure(category);
+      this.deps.logger.warn("Durable capacity cap recorded to gateway arm breaker", {
+        arm: this.armId,
+        provider,
+        category
+      });
+      return;
+    }
+    if (rateLimitLike) {
+      breaker.releaseHalfOpenProbe();
+      return;
+    }
+    breaker.recordFailure(category);
+    this.deps.logger.warn("Gateway arm failure recorded to circuit breaker", {
+      arm: this.armId,
+      provider,
+      category
+    });
+  }
+  /** The telemetry branch of `ResilientAdapter.complete`, for the exempted case. */
+  recordRateLimit(error, provider) {
+    const rlError = toRateLimitError(error, provider);
+    recordRateLimitEvent({
+      provider,
+      timestamp: getTimeProvider().now(),
+      retryAfterMs: rlError.retryAfterMs
+    });
+    this.deps.logger.warn("Rate limit detected on gateway arm", {
+      arm: this.armId,
+      provider,
+      retryAfterMs: rlError.retryAfterMs
+    });
+  }
+};
+
 // src/cli-adapters/model-to-cli-adapter.ts
 var DEFAULT_CONTEXT_WINDOW = FALLBACK_CONTEXT_WINDOW;
 var NEUTRAL_CAPABILITIES = {
@@ -7403,16 +7645,26 @@ var ModelToCliAdapter = class {
    * Per-instance, so one arm's exhaustion never speaks for another's.
    */
   capacityTracker;
+  /** Exact admission ownership; other API adapters still need the integration's gate. */
+  ownsCircuitAdmission(registry) {
+    return ownsGatewayCircuitAdmission(this.modelAdapter, this.name, registry);
+  }
   constructor(modelAdapter, config) {
     this.modelAdapter = modelAdapter;
     this.name = config.name;
-    this.capabilities = config.capabilities ?? NEUTRAL_CAPABILITIES;
+    const entry = routingArmCliSlot(config.name) === void 0 ? getDefaultRegistry().getEntry(modelAdapter.modelId) : void 0;
+    this.capabilities = config.capabilities ?? {
+      ...NEUTRAL_CAPABILITIES,
+      ...entry?.qualityScores,
+      contextWindow: entry?.contextWindow ?? DEFAULT_CONTEXT_WINDOW
+    };
     this.capacityTracker = createCapacityTracker(config.name);
   }
   /** Build a single-turn CompletionRequest from a CliTask. */
   toCompletionRequest(task, options) {
     const request = {
-      messages: [{ role: "user", content: task.content }]
+      messages: [{ role: "user", content: task.content }],
+      ...options?.signal !== void 0 ? { signal: options.signal } : {}
     };
     if (task.systemPrompt !== void 0) {
       request.systemPrompt = task.systemPrompt;
@@ -7501,7 +7753,7 @@ var ModelToCliAdapter = class {
   }
   async execute(task, options) {
     const gatewayArm = this.gatewayArmField().gatewayArm;
-    const breaker = gatewayArm !== void 0 && this.modelAdapter.providerId === `cli-${this.name}` ? (await import("./cli-circuit-breaker-62YOQQT3.js")).getDefaultCliCircuitBreakerRegistry().getArmBreaker(breakerKeys.forArm({ name: this.name, gatewayArm })) : void 0;
+    const breaker = gatewayArm !== void 0 && this.modelAdapter.providerId === `cli-${this.name}` ? (await import("./cli-circuit-breaker-CDJKHR7R.js")).getDefaultCliCircuitBreakerRegistry().getArmBreaker(breakerKeys.forArm({ name: this.name, gatewayArm })) : void 0;
     const result = await this.modelAdapter.complete(this.toCompletionRequest(task, options));
     if (!result.ok) {
       const cliError = this.toCliError(result.error);
@@ -7576,7 +7828,7 @@ var ModelToCliAdapter = class {
     return {
       id: this.modelAdapter.modelId,
       name: this.modelAdapter.modelId,
-      contextWindow: DEFAULT_CONTEXT_WINDOW
+      contextWindow: routingArmCliSlot(this.name) === void 0 ? this.capabilities.contextWindow : DEFAULT_CONTEXT_WINDOW
     };
   }
   /** Delegate to the model adapter's listModels surface when present (#2529). */
@@ -7630,6 +7882,11 @@ var GatewaySlotArm = class {
       arm: typeof arm === "string" && isEndpointArmId(arm) ? arm : void 0
     };
   }
+  /** Endpoint this slot may serve, including an undecided CLI-or-gateway target. */
+  get gatewayEndpoint() {
+    const arm = this.deps.gatewayModel.gatewayArm;
+    return typeof arm === "string" && isEndpointArmId(arm) ? arm : void 0;
+  }
   /** The CLI's subprocess adapter; undefined when its binary is not on PATH. */
   get cliBinaryAdapter() {
     return this.deps.cliAdapter;
@@ -7726,6 +7983,9 @@ var GatewaySlotArm = class {
     await this.gatewayAdapter.dispose();
   }
 };
+function gatewaySlotEndpointOf(adapter) {
+  return adapter instanceof GatewaySlotArm ? adapter.gatewayEndpoint : void 0;
+}
 function gatewayServedSlotOf(adapter) {
   return adapter instanceof GatewaySlotArm ? adapter.gatewayServedSlot : void 0;
 }
@@ -7769,23 +8029,6 @@ function buildGatewaySlotRouterArm(cli, createCli, isAvailable, logger16) {
   });
 }
 
-// src/adapters/sdk/gateway-catalog.ts
-var catalogs = /* @__PURE__ */ new Map();
-function setGatewayCatalog(arm, modelIds) {
-  if (modelIds.length === 0) {
-    throw new Error(
-      `Gateway catalogue for ${arm} is empty; an arm with no model is not registrable`
-    );
-  }
-  catalogs.set(arm, [...modelIds]);
-}
-function getGatewayCatalog(arm) {
-  return catalogs.get(arm);
-}
-function clearGatewayCatalog(arm) {
-  catalogs.delete(arm);
-}
-
 // src/cli-adapters/budget-arm-cost.ts
 function estimateRegistryCostUsd(slot, inputTokens, outputTokens) {
   const pricing = getModelPricing(getDefaultModelForCli(slot));
@@ -7947,8 +8190,9 @@ var DEFAULT_OPTIONS = {
   // #4196: per-task-class cost ceilings default OFF (no ceiling configured).
   taskClassCostCeilings: {}
 };
-function latencyOf(slot) {
-  return DEFAULT_COST_MODELS[slot]?.avgLatencyMs;
+function latencyOf(arm) {
+  const slot = routingArmCliSlot(arm);
+  return slot === void 0 ? void 0 : DEFAULT_COST_MODELS[slot]?.avgLatencyMs;
 }
 var BudgetRouter = class {
   adapters;
@@ -8064,7 +8308,7 @@ var BudgetRouter = class {
     const adapter = selected === null ? null : selected.adapter;
     const armCostUsd = selected === null ? void 0 : budgetCostOfArm(selected, estimatedInputTokens, estimatedOutputTokens);
     const estimatedCostUsd = armCostUsd ?? 0;
-    const estimatedLatencyMs = selected === null ? void 0 : latencyOf(routingArmDisplaySlot(selected.arm));
+    const estimatedLatencyMs = selected === null ? void 0 : latencyOf(selected.arm);
     const currentBudget = this.getSessionBudget();
     const withinBudget = armCostUsd !== void 0 && this.checkConstraints(budget, estimatedTokens, estimatedCostUsd);
     const warnings = generateBudgetWarnings(
@@ -8245,8 +8489,8 @@ var BudgetRouter = class {
   }
   selectAdapterWithinBudget(budget, estimatedTokens) {
     const sortedAdapters = [...this.adapters].sort((a, b) => {
-      const capA = DEFAULT_CAPABILITIES[routingArmDisplaySlot(a[0])];
-      const capB = DEFAULT_CAPABILITIES[routingArmDisplaySlot(b[0])];
+      const capA = this.capabilitiesOf(a[0], a[1]);
+      const capB = this.capabilitiesOf(b[0], b[1]);
       return capB.cost - capA.cost;
     });
     const unpricedArms = [];
@@ -8259,19 +8503,25 @@ var BudgetRouter = class {
         unpricedArms.push({ arm, reason });
         continue;
       }
-      if (this.admitsCandidate(budget, estimatedTokens, routingArmDisplaySlot(arm), estimatedCost)) {
+      if (this.admitsCandidate(budget, estimatedTokens, { arm, adapter }, estimatedCost)) {
         return { selected: { arm, adapter }, unpricedArms };
       }
     }
     return { selected: null, unpricedArms };
   }
+  /** Slot profiles apply only to vendor arms; endpoints supply their own profile. */
+  capabilitiesOf(arm, adapter) {
+    const slot = routingArmCliSlot(arm);
+    return slot === void 0 ? adapter.capabilities : DEFAULT_CAPABILITIES[slot];
+  }
   /** The four per-candidate admission checks of `selectAdapterWithinBudget`. */
-  admitsCandidate(budget, estimatedTokens, slot, estimatedCost) {
-    const caps = DEFAULT_CAPABILITIES[slot];
+  admitsCandidate(budget, estimatedTokens, target, estimatedCost) {
+    const caps = this.capabilitiesOf(target.arm, target.adapter);
     const withinTokenBudget = budget.maxTokens === void 0 || estimatedTokens <= budget.maxTokens;
     const withinCostBudget = budget.maxCostUsd === void 0 || estimatedCost <= budget.maxCostUsd;
     const withinContextWindow = estimatedTokens <= caps.contextWindow;
-    const withinLatencyBudget = budget.maxLatencyMs === void 0 || latencyOf(slot) === void 0 || latencyOf(slot) <= budget.maxLatencyMs;
+    const latency = latencyOf(target.arm);
+    const withinLatencyBudget = budget.maxLatencyMs === void 0 || latency === void 0 || latency <= budget.maxLatencyMs;
     return withinTokenBudget && withinCostBudget && withinContextWindow && withinLatencyBudget;
   }
   checkConstraints(budget, estimatedTokens, estimatedCostUsd) {
@@ -8473,6 +8723,15 @@ function generateReasoning(best, ranked, savings) {
   }
   return parts.join(". ");
 }
+function adjustProfileForTask(profile, taskProfile) {
+  if (taskProfile.taskType === "architecture" || taskProfile.reasoningComplexity > 7) {
+    return { ...profile, qualityScore: Math.min(profile.qualityScore * 1.2, 10) };
+  }
+  if (taskProfile.taskType === "bulk_operations" || taskProfile.contextRequired < 1e3) {
+    return { ...profile, averageLatencyMs: profile.averageLatencyMs * 0.8 };
+  }
+  return profile;
+}
 
 // src/cli-adapters/topsis-router.ts
 var WEIGHT_SUM_TOLERANCE = 0.01;
@@ -13498,8 +13757,8 @@ function getOutcomeStore() {
 async function attachOutcomeStoreToRegistry(store) {
   try {
     const { getMemoryRegistry } = await import("./dist-RRRU2OKU.js");
-    const { OutcomeStoreAdapter } = await import("./outcome-store-adapter-WRONSTUD.js");
-    const { ensureSharedMemoryRegistry } = await import("./tool-memory-registry-adapters-FO6JVQSX.js");
+    const { OutcomeStoreAdapter } = await import("./outcome-store-adapter-Y6MS4JJK.js");
+    const { ensureSharedMemoryRegistry } = await import("./tool-memory-registry-adapters-IIORYBCC.js");
     ensureSharedMemoryRegistry();
     getMemoryRegistry().attach("outcomes", new OutcomeStoreAdapter(store));
   } catch {
@@ -13706,9 +13965,10 @@ function getPipelineEventBus() {
 var PRIMARY_REWARD = 0.85;
 var SECONDARY_REWARD = 0.6;
 var OTHER_REWARD = 0.35;
+var ENDPOINT_REWARD = 0.5;
 var SYNTHETIC_MARKER = "synthetic:warm-up";
 var CLI_NAMES2 = ["claude", "gemini", "codex", "opencode"];
-function generateSyntheticPriors() {
+function generateSyntheticPriors(armNames = []) {
   const totals = /* @__PURE__ */ new Map();
   for (const cli of CLI_NAMES2) {
     totals.set(cli, 0);
@@ -13730,6 +13990,11 @@ function generateSyntheticPriors() {
   for (const [cli, total] of totals) {
     priors.set(cli, total / count);
   }
+  for (const arm of armNames.filter(
+    (name) => isEndpointArmId(name) && routingArmCliSlot(name) === void 0
+  )) {
+    priors.set(arm, ENDPOINT_REWARD);
+  }
   return priors;
 }
 function buildSyntheticOutcomes(timestamp) {
@@ -13803,7 +14068,7 @@ function warmStartBandit(bandit, logger16, options = {}) {
         });
       }
     }
-    bandit.seedPriors(generateSyntheticPriors(), replayed === 0 ? 3 : 1);
+    bandit.seedPriors(generateSyntheticPriors(bandit.getArmNames()), replayed === 0 ? 3 : 1);
     if (replayed === 0) {
       fallbackUsed = true;
       const fallback = options.persist === false ? memoryFallback() : persistedFallback(logger16);
@@ -13874,15 +14139,6 @@ function budgetUtilizationForTask(task, budgetRouter, rawConstraints) {
 }
 
 // src/cli-adapters/composite-router-helpers.ts
-function adjustProfileForTask(profile, taskProfile) {
-  if (taskProfile.taskType === "architecture" || taskProfile.reasoningComplexity > 7) {
-    return { ...profile, qualityScore: Math.min(profile.qualityScore * 1.2, 10) };
-  }
-  if (taskProfile.taskType === "bulk_operations" || taskProfile.contextRequired < 1e3) {
-    return { ...profile, averageLatencyMs: profile.averageLatencyMs * 0.8 };
-  }
-  return profile;
-}
 function taskProfileToBanditContext(profile, budgetUtilization) {
   return {
     taskComplexity: profile.reasoningComplexity / 10,
@@ -13930,7 +14186,10 @@ function filterByPreferenceTier(candidates, tier) {
   const strongModels = deriveStrongClis();
   const weakModels = deriveWeakClis();
   const preferred = tier === "strong" ? strongModels : weakModels;
-  const filtered = candidates.filter((c) => preferred.includes(routingArmDisplaySlot(c)));
+  const filtered = candidates.filter((c) => {
+    const slot = routingArmCliSlot(c);
+    return slot === void 0 || preferred.includes(slot);
+  });
   return filtered.length > 0 ? filtered : candidates;
 }
 function cliTaskToTask(cliTask) {
@@ -14001,7 +14260,7 @@ function adjustProfileWithStageScores(profiles, stageScores) {
   });
 }
 function buildAdjustedProfiles(taskProfile, candidates, options) {
-  const candidateSlots = new Set(candidates.map(routingArmDisplaySlot));
+  const candidateSlots = new Set(candidates.map(routingArmCliSlot));
   const profiles = DEFAULT_MODEL_PROFILES.filter((p) => candidateSlots.has(p.cliName));
   let adjusted = profiles.map((p) => adjustProfileForTask(p, taskProfile));
   if (options?.stageScores !== void 0 && options.stageScores.size > 0) {
@@ -14024,15 +14283,17 @@ function applyTopsisRanking(taskProfile, candidates, topsisRouter, options) {
     taskProfile.reasoningComplexity
   );
   const adjustedProfiles = buildAdjustedProfiles(taskProfile, candidates, options);
+  if (adjustedProfiles.length === 0) return { ranking: candidates, topScore: 1 };
   const result = router.selectModel({ profiles: adjustedProfiles });
-  const scoreMap = new Map(result.scores.map((s) => [s.cliName, s.closenessScore]));
-  const scoreOf = (arm) => scoreMap.get(routingArmDisplaySlot(arm)) ?? 0;
+  const scoreOf = (arm) => result.scores.find((score) => score.cliName === routingArmCliSlot(arm))?.closenessScore ?? 0;
   const ranking = [...candidates].sort((a, b) => scoreOf(b) - scoreOf(a));
   const topArm = ranking[0];
   const topScore = topArm !== void 0 ? scoreOf(topArm) : 1;
-  const scoresByArm = new Map(candidates.map((arm) => [arm, scoreOf(arm)]));
+  const scoresByArm = new Map(
+    candidates.filter((arm) => routingArmCliSlot(arm) !== void 0).map((arm) => [arm, scoreOf(arm)])
+  );
   const threshold = topScore * (1 - TOPSIS_TOLERANCE_BAND_PERCENT);
-  const toleranceBandSize = ranking.filter((c) => scoreOf(c) >= threshold).length;
+  const toleranceBandSize = [...scoresByArm.values()].filter((score) => score >= threshold).length;
   return { ranking, topScore, toleranceBandSize, scoresByArm };
 }
 function defaultPreferenceStageResult(candidates) {
@@ -14052,8 +14313,8 @@ function defaultZeroRouterStageResult(candidates) {
 function filterByDifficultyTier(candidates, tier) {
   const preferred = deriveTierToClis()[tier];
   const sortedCandidates = [...candidates].sort((a, b) => {
-    const aIndex = preferred.indexOf(routingArmDisplaySlot(a));
-    const bIndex = preferred.indexOf(routingArmDisplaySlot(b));
+    const aIndex = preferred.findIndex((slot) => slot === routingArmCliSlot(a));
+    const bIndex = preferred.findIndex((slot) => slot === routingArmCliSlot(b));
     const aPos = aIndex === -1 ? preferred.length : aIndex;
     const bPos = bIndex === -1 ? preferred.length : bIndex;
     return aPos - bPos;
@@ -14064,7 +14325,9 @@ function applyZeroRouterFilter(task, candidates, zeroRouter) {
   if (zeroRouter === void 0 || candidates.length === 0) {
     return defaultZeroRouterStageResult(candidates);
   }
-  const decision = zeroRouter.routeByDifficulty(task, candidates.map(routingArmDisplaySlot));
+  const slots = candidates.map(routingArmCliSlot).filter((slot) => slot !== void 0);
+  if (slots.length === 0) return defaultZeroRouterStageResult(candidates);
+  const decision = zeroRouter.routeByDifficulty(task, slots);
   const difficultyEstimate = decision.difficulty;
   const difficultyTier = decision.tier;
   const filteredCandidates = filterByDifficultyTier(candidates, difficultyTier);
@@ -14099,7 +14362,7 @@ function buildDecisionFields(ctx) {
   const alternatives = ctx.topsisRanking.filter((c) => c !== ctx.selectedCli);
   if (ctx.topsisScoresByArm === void 0) return { confidence, reason, alternatives };
   const alternativeScores = new Map(
-    alternatives.map((arm) => [arm, ctx.topsisScoresByArm?.get(arm) ?? 0])
+    alternatives.filter((arm) => ctx.topsisScoresByArm?.has(arm) === true).map((arm) => [arm, ctx.topsisScoresByArm?.get(arm) ?? 0])
   );
   return { confidence, reason, alternatives, alternativeScores };
 }
@@ -17697,7 +17960,10 @@ function buildWeatherCostSection(cfg, deps, includePipelineJoins = false) {
 }
 
 // src/mcp/tools/weather-report-arms.ts
-var ROUTED_ARMS = [...CLI_NAMES, ...ApiArmIdSchema.options];
+var ROUTED_ARMS = [
+  ...CLI_NAMES,
+  ...ApiArmIdSchema.options
+];
 var SLOT_ARMS = new Map(
   CLI_NAMES.map((slot) => [
     slot,
@@ -18275,11 +18541,21 @@ function getFallbackChainForCategory(category, bucketType, registry = DEFAULT_FA
 
 // src/cli-adapters/composite-router-scoring-stages.ts
 function armsToSlots(candidates) {
-  return [...new Set(candidates.map(routingArmDisplaySlot))];
+  return [
+    ...new Set(
+      candidates.flatMap((arm) => {
+        const slot = routingArmCliSlot(arm);
+        return slot === void 0 ? [] : [slot];
+      })
+    )
+  ];
 }
 function keepArmsForSlots(candidates, survivingSlots) {
   const slotSet = new Set(survivingSlots);
-  return candidates.filter((arm) => slotSet.has(routingArmDisplaySlot(arm)));
+  return candidates.filter((arm) => {
+    const slot = routingArmCliSlot(arm);
+    return slot === void 0 || slotSet.has(slot);
+  });
 }
 var DEFAULT_COMPLEXITY = "moderate";
 function extractComplexityFromSignals(signals) {
@@ -18371,7 +18647,14 @@ async function runQualityConstraintStage(candidates, stagesExecuted, deps) {
   if (!deps.config.enableQualityConstraint || deps.qualityConstraintStage === void 0) {
     return { eligible: candidates, filtered: /* @__PURE__ */ new Map(), usedFallback: false };
   }
-  const ctx = createRoutingContext("", armsToSlots(candidates));
+  const slots = armsToSlots(candidates);
+  if (candidates.some((arm) => routingArmCliSlot(arm) === void 0)) {
+    stagesExecuted.push("quality-constraint:endpoint-unmeasured");
+  }
+  if (slots.length === 0) {
+    return { eligible: candidates, filtered: /* @__PURE__ */ new Map(), usedFallback: false };
+  }
+  const ctx = createRoutingContext("", slots);
   const result = await deps.qualityConstraintStage.route(ctx);
   stagesExecuted.push("quality-constraint");
   if (!result.ok) {
@@ -18478,7 +18761,7 @@ function runZeroRouterStage(task, candidates, stagesExecuted, deps) {
   return result;
 }
 function runTopsisStage(taskProfile, candidates, stagesExecuted, deps, options) {
-  if (!deps.config.enableTopsisRanking || deps.topsisRouter === void 0) {
+  if (!deps.config.enableTopsisRanking || deps.topsisRouter === void 0 || armsToSlots(candidates).length === 0) {
     return { ranking: candidates, score: void 0 };
   }
   const topsisOptions = {
@@ -18536,10 +18819,10 @@ function runLatencyStage(candidates, stagesExecuted, deps) {
   }
   const scores = deps.latencyTracker.getScores(armsToSlots(candidates));
   stagesExecuted.push("latency-scoring");
-  const scoreOf = (arm) => scores.find((s) => s.cli === routingArmDisplaySlot(arm))?.score ?? 0;
+  const scoreOf = (arm) => scores.find((s) => s.cli === routingArmCliSlot(arm))?.score ?? 0;
   const sortedCandidates = [...candidates].sort((a, b) => scoreOf(b) - scoreOf(a));
   const topArm = sortedCandidates[0];
-  const topScore = topArm !== void 0 ? scores.find((s) => s.cli === routingArmDisplaySlot(topArm))?.score : void 0;
+  const topScore = topArm !== void 0 ? scores.find((s) => s.cli === routingArmCliSlot(topArm))?.score : void 0;
   deps.logger.debug("Latency scoring applied", {
     scores: scores.map((s) => ({
       cli: s.cli,
@@ -18647,6 +18930,7 @@ function getPerformanceDataForCategory(taskContent) {
     const summary = getOutcomeStore().summarize({ category: match.category });
     const result = /* @__PURE__ */ new Map();
     for (const [cli, stats] of summary.byCli) {
+      if (!isCliName(cli)) continue;
       result.set(cli, {
         successRate: stats.successRate,
         sampleCount: stats.count
@@ -18754,9 +19038,18 @@ function applyCategoryOverride(task, candidates, stagesExecuted) {
   if (match === null) return ok(candidates);
   const override = CATEGORY_CHAIN_OVERRIDES[match.category];
   if (override === void 0) return ok(candidates);
+  if (!isCategoryFailClosed(match.category) && candidates.some((arm) => routingArmCliSlot(arm) === void 0)) {
+    stagesExecuted.push("category-override:endpoint-unmeasured");
+  }
   const overrideSet = new Set(override);
-  const orderIndex = (arm) => override.indexOf(routingArmDisplaySlot(arm));
-  const filtered = candidates.filter((arm) => overrideSet.has(routingArmDisplaySlot(arm))).sort((a, b) => orderIndex(a) - orderIndex(b));
+  const orderIndex = (arm) => {
+    const slot = routingArmCliSlot(arm);
+    return slot === void 0 ? override.length : override.indexOf(slot);
+  };
+  const filtered = candidates.filter((arm) => {
+    const slot = routingArmCliSlot(arm);
+    return slot === void 0 ? !isCategoryFailClosed(match.category) : overrideSet.has(slot);
+  }).sort((a, b) => orderIndex(a) - orderIndex(b));
   if (filtered.length === 0) {
     if (isCategoryFailClosed(match.category)) {
       stagesExecuted.push("category-override:fail-closed");
@@ -18779,8 +19072,9 @@ function applyCategoryOverride(task, candidates, stagesExecuted) {
   return ok(filtered);
 }
 function applyLinUCBFloorOverride(linucbCli, topsisRanking, opts) {
-  if (opts.perfData === void 0) return linucbCli;
-  const cliPerf = opts.perfData.get(routingArmDisplaySlot(linucbCli));
+  const slot = routingArmCliSlot(linucbCli);
+  if (opts.perfData === void 0 || slot === void 0) return linucbCli;
+  const cliPerf = opts.perfData.get(slot);
   if (cliPerf === void 0 || cliPerf.sampleCount < 20 || cliPerf.successRate >= 0.5) {
     return linucbCli;
   }
@@ -18878,11 +19172,13 @@ function buildPipelineResult(p) {
     preferenceScore: p.prefResult.preferenceScore,
     preferenceTier: p.prefResult.preferenceTier,
     topsisRanking: p.topsisResult.ranking,
-    topsisScore: p.topsisResult.score,
+    // An endpoint did not participate in TOPSIS; do not report a CLI score.
+    topsisScore: routingArmCliSlot(p.selectedCli) === void 0 ? void 0 : p.topsisResult.score,
     topsisScoresByArm: p.topsisResult.scoresByArm,
     selectedCli: p.selectedCli,
     ucbScore: p.linucbResult.ucbScore,
-    latencyScore: p.latencyResult.latencyScore,
+    // Endpoint latency is unmeasured; the stage's best CLI score is not its own.
+    latencyScore: routingArmCliSlot(p.selectedCli) === void 0 ? void 0 : p.latencyResult.latencyScore,
     memoryRecommendation: p.memoryResult.recommendation,
     memoryConfidence: p.memoryResult.memoryConfidence,
     ...stageScores.size > 0 ? { stageScores } : {},
@@ -19181,8 +19477,8 @@ function buildDefaultModelSources(adapters, opts = {}) {
   }
   for (const [key, adapter] of adapters) {
     if (hasListModels(adapter)) {
-      const slot = routingArmDisplaySlot(key);
-      sources.push(adapterSource(slot, adapter));
+      const sourceName = routingArmCliSlot(key) ?? key;
+      sources.push(adapterSource(sourceName, adapter));
     }
   }
   return sources;
@@ -19437,12 +19733,10 @@ var PendingRoutingOutcomes = class {
     try {
       if (!isRouteModelShadowEnabled() || decision.difficultyTier === void 0) return void 0;
       if (task.model !== void 0) return void 0;
+      const slot = routingArmCliSlot(decision.cliName);
+      if (slot === void 0) return void 0;
       logModelSelectionReadinessOnce(this.logger);
-      const comparison = computeModelSelectionShadow(
-        routingArmDisplaySlot(decision.cliName),
-        decision.difficultyTier,
-        decision.model
-      );
+      const comparison = computeModelSelectionShadow(slot, decision.difficultyTier, decision.model);
       this.logger.debug("Model-selection shadow computed (#4197)", {
         cli: comparison.cli,
         tier: comparison.tier,
@@ -19536,12 +19830,14 @@ function recordZeroRouterOutcome(task, success, qualityScore, deps, attribution)
     return;
   }
   const { difficulty, selectedCli } = attribution;
+  const slot = routingArmCliSlot(selectedCli);
+  if (slot === void 0) return;
   const outcome = buildDifficultyOutcome(
     task.content,
     difficulty,
     // Difficulty calibration is slot-level; collapse an api:* arm to its
     // display slot here (the bandit retains the distinct arm). (#3422)
-    routingArmDisplaySlot(selectedCli),
+    slot,
     success,
     qualityScore
   );
@@ -19575,8 +19871,8 @@ function getCachedCliSuccessRate(cli) {
 function rewardSuccessRate(arm) {
   const own = getCachedCliSuccessRate(arm);
   if (own !== void 0) return own;
-  const slot = routingArmDisplaySlot(arm);
-  return slot === arm ? void 0 : getCachedCliSuccessRate(slot);
+  const slot = routingArmCliSlot(arm);
+  return slot === void 0 || slot === arm ? void 0 : getCachedCliSuccessRate(slot);
 }
 function computeQualityReward(cli, success, durationMs) {
   if (!success) return 0.1;
@@ -19603,12 +19899,16 @@ function computeQualityReward(cli, success, durationMs) {
 // src/cli-adapters/composite-router-metrics.ts
 function recordDecisionToMetrics(decision, traceId, deps) {
   if (deps.metricsCollector === void 0) return;
-  const selectedModel = routingArmDisplaySlot(decision.cliName);
+  const selectedModel = routingArmCliSlot(decision.cliName);
+  if (selectedModel === void 0) return;
   deps.metricsCollector.recordDecision({
     timestamp: getTimeProvider().nowIso(),
     traceId,
     selectedModel,
-    alternativeModels: decision.alternatives.map(routingArmDisplaySlot),
+    alternativeModels: decision.alternatives.flatMap((arm) => {
+      const slot = routingArmCliSlot(arm);
+      return slot === void 0 ? [] : [slot];
+    }),
     isExploration: decision.ucbScore !== void 0 && decision.ucbScore > 0.5,
     taskType: decision.taskProfile.taskType,
     contextTokens: decision.taskProfile.contextRequired,
@@ -19836,9 +20136,8 @@ var CompositeRouter = class _CompositeRouter {
       type: "routing.decision",
       timestamp: getTimeProvider().now(),
       taskId: taskDescription.slice(0, 100),
-      // Trace attribution is slot-level; collapse the api:* arm (#3422) so this
-      // sink matches every other telemetry sink (the bandit keeps the arm).
-      selectedModel: routingArmDisplaySlot(decision.cliName),
+      // Built-in vendor arms retain slot display; endpoints retain their own identity.
+      selectedModel: routingArmCliSlot(decision.cliName) ?? decision.cliName,
       reasoning: decision.reason,
       decisionPath: decision.stagesExecuted
     });
@@ -19874,7 +20173,7 @@ var CompositeRouter = class _CompositeRouter {
    */
   async consultUnifiedContext(task) {
     try {
-      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-HVPLM6DH.js");
+      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-CBOMGQAP.js");
       const ctx = await getContextForTask({
         task: task.content,
         category: inferTaskCategory(task.content),
@@ -19936,8 +20235,10 @@ var CompositeRouter = class _CompositeRouter {
     const durationMs = getTimeProvider().now() - startTime;
     const success = executeResult.ok;
     this.autoRecordFeedback(decision, task, success, durationMs);
+    const routedSlot = routingArmCliSlot(decision.cliName);
     const routed = {
-      routedCli: routingArmDisplaySlot(decision.cliName),
+      // A gateway endpoint has no routed CLI; routedArm carries its identity.
+      ...routedSlot !== void 0 && { routedCli: routedSlot },
       routedArm: decision.cliName,
       routedDurationMs: armDurationMs
     };
@@ -19946,10 +20247,17 @@ var CompositeRouter = class _CompositeRouter {
   }
   autoRecordFeedback(decision, task, success, durationMs) {
     const arm = decision.cliName;
-    const slot = routingArmDisplaySlot(arm);
+    const slot = routingArmCliSlot(arm);
     const reward = computeQualityReward(arm, success, durationMs);
     this.recordOutcome(arm, task, reward, success);
     this.recordExecutedDifficultyOutcome(decision, task, success);
+    this.logger.debug("Auto-recorded feedback", {
+      cli: arm,
+      success,
+      durationMs,
+      reward
+    });
+    if (slot === void 0) return;
     if (this.latencyTracker !== void 0) {
       this.latencyTracker.record(slot, durationMs, success);
     }
@@ -19977,12 +20285,6 @@ var CompositeRouter = class _CompositeRouter {
         { metricsCollector: this.metricsCollector, logger: this.logger }
       );
     }
-    this.logger.debug("Auto-recorded feedback", {
-      cli: arm,
-      success,
-      durationMs,
-      reward
-    });
   }
   /** Task type inference keywords. */
   static TASK_TYPE_KEYWORDS = [
@@ -20065,9 +20367,10 @@ var CompositeRouter = class _CompositeRouter {
         return this.cliNames;
       }
       const sourcesWithModels = new Set(all.map((m) => m.source));
-      const filtered = this.cliNames.filter(
-        (name) => sourcesWithModels.has(routingArmDisplaySlot(name))
-      );
+      const filtered = this.cliNames.filter((name) => {
+        const slot = routingArmCliSlot(name);
+        return slot === void 0 || sourcesWithModels.has(slot);
+      });
       if (filtered.length === 0) {
         this.logger.info(
           "AvailableModelsCache filtered out all CLIs; falling back to all (possible stale/misconfigured cache)",
@@ -20139,7 +20442,8 @@ var CompositeRouter = class _CompositeRouter {
       decisionTimeMs,
       billingMode: this.config.billingMode
     });
-    const model = isRouteModelSelectionEnabled() && params.difficultyTier !== void 0 ? resolveModelForTier(routingArmDisplaySlot(params.selectedCli), params.difficultyTier) : void 0;
+    const modelSlot = routingArmCliSlot(params.selectedCli);
+    const model = isRouteModelSelectionEnabled() && params.difficultyTier !== void 0 && modelSlot !== void 0 ? resolveModelForTier(modelSlot, params.difficultyTier) : void 0;
     return ok({
       adapter: selectedAdapter,
       cliName: params.selectedCli,
@@ -20163,7 +20467,8 @@ var CompositeRouter = class _CompositeRouter {
   }
   updateStats(selectedCli, decisionTimeMs) {
     this.totalDecisions++;
-    this.decisionsPerCli[routingArmDisplaySlot(selectedCli)]++;
+    const slot = routingArmCliSlot(selectedCli);
+    if (slot !== void 0) this.decisionsPerCli[slot]++;
     this.totalDecisionTimeMs += decisionTimeMs;
   }
   /**
@@ -20191,9 +20496,10 @@ var CompositeRouter = class _CompositeRouter {
   }
   recordOutcome(cliName, task, reward, success) {
     recordBanditOutcome(cliName, task, reward, this.getOutcomeDependencies());
-    if (this.config.enableStrategyDistillation && this.distilledRuleStage !== void 0 && success !== void 0) {
+    const slot = routingArmCliSlot(cliName);
+    if (this.config.enableStrategyDistillation && this.distilledRuleStage !== void 0 && success !== void 0 && slot !== void 0) {
       this.distilledRuleStage.recordOutcome({
-        selectedCli: routingArmDisplaySlot(cliName),
+        selectedCli: slot,
         task: task.content,
         success
       });
@@ -20456,10 +20762,7 @@ function loadManifestOverlay(options) {
   return mergeOverlays(user, operator);
 }
 function mergeOverlays(lower, higher) {
-  const byId = /* @__PURE__ */ new Map();
-  for (const entry of lower.entries) byId.set(entry.id, entry);
-  for (const entry of higher.entries) byId.set(entry.id, entry);
-  const entries = [...byId.values()];
+  const entries = [...lower.entries, ...higher.entries];
   const merged = {
     entries,
     rejections: [...lower.rejections, ...higher.rejections],
@@ -20760,6 +21063,10 @@ function loadGeneratedRegistryEntries(options) {
 }
 
 // src/config/model-registry.ts
+var pricingSources = /* @__PURE__ */ new WeakMap();
+function pricingSourceOf(entry) {
+  return (entry.pricing === void 0 ? void 0 : pricingSources.get(entry.pricing)) ?? entry.source;
+}
 var ModelRegistry = class {
   byId = /* @__PURE__ */ new Map();
   byAlias = /* @__PURE__ */ new Map();
@@ -20875,9 +21182,22 @@ var ModelRegistry = class {
   }
   loadEntries(entries) {
     for (const entry of entries) {
-      this.byId.set(entry.id, entry);
-      if (entry.aliases !== void 0) {
-        for (const alias of entry.aliases) {
+      const merged = { ...entry };
+      if (entry.pricing === void 0) {
+        const lower = this.byId.get(entry.id);
+        if (lower?.pricing !== void 0) {
+          merged.pricing = lower.pricing;
+          if (lower.pricingProvenance !== void 0) {
+            merged.pricingProvenance = lower.pricingProvenance;
+          }
+        }
+      } else {
+        merged.pricing = { ...entry.pricing };
+        pricingSources.set(merged.pricing, entry.source);
+      }
+      this.byId.set(entry.id, merged);
+      if (merged.aliases !== void 0) {
+        for (const alias of merged.aliases) {
           this.byAlias.set(alias, entry.id);
           if (alias !== entry.id) this.byId.delete(alias);
         }
@@ -20956,7 +21276,7 @@ function setDefaultRegistry(registry) {
 }
 async function reloadDefaultRegistry() {
   globalRegistry = buildDefaultRegistry();
-  const { resetGlobalRegistry } = await import("./unified-registry-KLNC24HA.js");
+  const { resetGlobalRegistry } = await import("./unified-registry-IEPJHJHO.js");
   resetGlobalRegistry();
   return globalRegistry;
 }
@@ -20978,12 +21298,12 @@ var VENDOR_TO_CLI_SLOT = {
 };
 function ownerOfEntry(entry) {
   if (isCliName2(entry.cliName)) return entry.cliName;
-  const owners = /* @__PURE__ */ new Set();
+  const owners2 = /* @__PURE__ */ new Set();
   for (const key of [entry.id, ...entry.aliases ?? []]) {
     const owner = inTreeOwner(key);
-    if (owner !== void 0) owners.add(owner);
+    if (owner !== void 0) owners2.add(owner);
   }
-  return owners.size === 1 ? [...owners][0] : void 0;
+  return owners2.size === 1 ? [...owners2][0] : void 0;
 }
 function slotOfEntry(entry) {
   return ownerOfEntry(entry) ?? VENDOR_TO_CLI_SLOT[entry.vendor] ?? "opencode";
@@ -21310,7 +21630,7 @@ export {
   isCliName,
   ApiArmIdSchema,
   apiArmId,
-  routingArmDisplaySlot,
+  routingArmCliSlot,
   isEndpointArmId,
   CLI_VERSION_REQUIREMENTS,
   DEFAULT_CAPABILITIES,
@@ -21413,20 +21733,17 @@ export {
   CircuitBreakerRegistry,
   mapCliErrorToCategory,
   mapModelErrorToCategory,
+  setGatewayCatalog,
+  createGatewayArmAdapter,
+  ModelToCliAdapter,
   createModelToCliAdapter,
+  gatewaySlotEndpointOf,
   gatewayServedSlotOf,
   cliBinaryAdapterOf,
   resolveGatewayServedSlot,
   decideSlotServing,
   isDisabledSlotUnserved,
   buildGatewaySlotRouterArm,
-  createOpenRouterModelsSource,
-  isDynamicModelsEnabled,
-  buildDefaultModelSources,
-  resolveOwnerCli,
-  resolveCliSlot,
-  getTokenEstimator,
-  estimateTokens,
   computeTokenCost,
   priceBasisOf,
   recordUsageEvent,
@@ -21437,12 +21754,19 @@ export {
   gatewayEndpointRejection,
   gatewayCostStatus,
   resolveGatewayCostDeclaration,
+  gatewayCostGap,
   describeGatewayCostDeclaration,
   warnIfGatewayCostUndeclared,
-  setGatewayCatalog,
-  clearGatewayCatalog,
+  budgetCostOfArm,
   gatewayCostDetail,
   servedCostDetail,
+  createOpenRouterModelsSource,
+  isDynamicModelsEnabled,
+  buildDefaultModelSources,
+  resolveOwnerCli,
+  resolveCliSlot,
+  getTokenEstimator,
+  estimateTokens,
   ModelRegistry,
   getDefaultRegistry,
   setDefaultRegistry,
@@ -21623,4 +21947,4 @@ export {
   AgentCapability,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-WKFPKPEM.js.map
+//# sourceMappingURL=chunk-EBOAFTOG.js.map