nexus-agents 4.23.0 → 4.26.3

package/dist/{chunk-OYFKB64X.js → chunk-7GWPLERY.js}

@@ -2174,14 +2174,14 @@ var ManifestSchema = z2.object({
   models: z2.array(z2.unknown())
 });
 function loadManifestOverlay(options) {
-  const logger15 = options?.logger ?? createLogger({ component: "manifest-overlay" });
+  const logger14 = options?.logger ?? createLogger({ component: "manifest-overlay" });
   if (options?.path !== void 0) {
-    return loadManifestFile(options.path, logger15);
+    return loadManifestFile(options.path, logger14);
   }
   const userPath = resolveUserManifestPath(options?.env);
   const operatorPath = resolveManifestPath(options?.env);
-  const user = loadManifestFile(userPath, logger15);
-  const operator = loadManifestFile(operatorPath, logger15);
+  const user = loadManifestFile(userPath, logger14);
+  const operator = loadManifestFile(operatorPath, logger14);
   return mergeOverlays(user, operator);
 }
 function mergeOverlays(lower, higher) {
@@ -2198,11 +2198,11 @@ function mergeOverlays(lower, higher) {
   return merged;
 }
 function loadUserManifestOverlay(options) {
-  const logger15 = options?.logger ?? createLogger({ component: "manifest-overlay" });
+  const logger14 = options?.logger ?? createLogger({ component: "manifest-overlay" });
   const path2 = options?.path ?? resolveUserManifestPath(options?.env);
-  return loadManifestFile(path2, logger15);
+  return loadManifestFile(path2, logger14);
 }
-function loadManifestFile(path2, logger15) {
+function loadManifestFile(path2, logger14) {
   let exists = false;
   try {
     exists = existsSync(path2);
@@ -2217,7 +2217,7 @@ function loadManifestFile(path2, logger15) {
     return { entries: [], rejections: [], path: path2, status: "empty" };
   }
   if (stat.size > MANIFEST_MAX_BYTES) {
-    logger15.warn("Manifest overlay too large; skipping", {
+    logger14.warn("Manifest overlay too large; skipping", {
       path: path2,
       size: stat.size,
       max: MANIFEST_MAX_BYTES
@@ -2225,9 +2225,9 @@ function loadManifestFile(path2, logger15) {
     return { entries: [], rejections: [], path: path2, status: "too-large" };
   }
   const raw = readFileSync(path2, "utf-8");
-  return parseManifest(raw, path2, logger15);
+  return parseManifest(raw, path2, logger14);
 }
-function parseManifest(raw, path2, logger15) {
+function parseManifest(raw, path2, logger14) {
   let parsed;
   try {
     if (path2.endsWith(".json")) {
@@ -2236,7 +2236,7 @@ function parseManifest(raw, path2, logger15) {
       parsed = parseYaml(raw);
     }
   } catch (e) {
-    logger15.warn("Manifest overlay parse failure; skipping", {
+    logger14.warn("Manifest overlay parse failure; skipping", {
       path: path2,
       error: e instanceof Error ? e.message : String(e)
     });
@@ -2244,7 +2244,7 @@ function parseManifest(raw, path2, logger15) {
   }
   const shape = ManifestSchema.safeParse(parsed);
   if (!shape.success) {
-    logger15.warn("Manifest overlay schema mismatch at root; skipping", {
+    logger14.warn("Manifest overlay schema mismatch at root; skipping", {
       path: path2,
       issues: shape.error.issues.slice(0, 5).map((i) => i.message)
     });
@@ -2319,7 +2319,7 @@ function defaultSnapshotPath() {
   return join(here, "models-dev-snapshot.json");
 }
 function loadModelsDevSnapshot(options) {
-  const logger15 = createLogger({ component: "models-dev-snapshot" });
+  const logger14 = createLogger({ component: "models-dev-snapshot" });
   const path2 = options?.path ?? defaultSnapshotPath();
   let exists = false;
   try {
@@ -2334,21 +2334,21 @@ function loadModelsDevSnapshot(options) {
   try {
     parsed = JSON.parse(readFileSync2(path2, "utf-8"));
   } catch (e) {
-    logger15.warn("models.dev snapshot parse failure; skipping", {
+    logger14.warn("models.dev snapshot parse failure; skipping", {
       path: path2,
       error: e instanceof Error ? e.message : String(e)
     });
     return { entries: [], path: path2, status: "malformed" };
   }
   if (parsed.version !== 1) {
-    logger15.warn("models.dev snapshot version unsupported; skipping", {
+    logger14.warn("models.dev snapshot version unsupported; skipping", {
       path: path2,
       version: parsed.version
     });
     return { entries: [], path: path2, status: "malformed" };
   }
   if (!Array.isArray(parsed.entries)) {
-    logger15.warn("models.dev snapshot missing entries array; skipping", { path: path2 });
+    logger14.warn("models.dev snapshot missing entries array; skipping", { path: path2 });
     return { entries: [], path: path2, status: "malformed" };
   }
   const entries = parsed.entries;
@@ -2395,7 +2395,7 @@ function toModelEntry(rec) {
   };
 }
 function loadGeneratedRegistryEntries(options) {
-  const logger15 = createLogger({ component: "models-generated" });
+  const logger14 = createLogger({ component: "models-generated" });
   const path2 = options?.path ?? defaultGeneratedPath();
   let exists = false;
   try {
@@ -2408,14 +2408,14 @@ function loadGeneratedRegistryEntries(options) {
   try {
     parsed = JSON.parse(readFileSync3(path2, "utf-8"));
   } catch (e) {
-    logger15.warn("generated registry parse failure; skipping", {
+    logger14.warn("generated registry parse failure; skipping", {
       path: path2,
       error: e instanceof Error ? e.message : String(e)
     });
     return { entries: [], path: path2, status: "malformed" };
   }
   if (!Array.isArray(parsed.entries)) {
-    logger15.warn("generated registry missing entries array; skipping", { path: path2 });
+    logger14.warn("generated registry missing entries array; skipping", { path: path2 });
     return { entries: [], path: path2, status: "malformed" };
   }
   const entries = [];
@@ -2623,7 +2623,7 @@ function setDefaultRegistry(registry) {
 }
 async function reloadDefaultRegistry() {
   globalRegistry = buildDefaultRegistry();
-  const { resetGlobalRegistry } = await import("./unified-registry-MUXCSSG5.js");
+  const { resetGlobalRegistry } = await import("./unified-registry-CLZZ46D5.js");
   resetGlobalRegistry();
   return globalRegistry;
 }
@@ -5477,6 +5477,60 @@ function estimateCost(model, inputTokens, outputTokens) {
   return inputCost + outputCost;
 }
 
+// src/cli-adapters/budget-router-types.ts
+import { z as z6 } from "zod";
+var BudgetConstraintSchema = z6.object({
+  maxTokens: z6.number().int().positive().optional(),
+  maxCostUSD: z6.number().positive().optional(),
+  maxLatencyMs: z6.number().positive().optional()
+});
+var SessionBudgetSchema = z6.object({
+  totalTokens: z6.number().int().positive(),
+  totalCostUSD: z6.number().positive(),
+  usedTokens: z6.number().int().min(0).default(0),
+  usedCostUSD: z6.number().min(0).default(0),
+  startTime: z6.number().int().positive(),
+  sessionId: z6.string().min(1)
+});
+var DEFAULT_COST_MODELS = {
+  claude: {
+    inputTokenCost: 0.015,
+    outputTokenCost: 0.075,
+    avgLatencyMs: 2e3,
+    qualityScore: 0.95
+  },
+  gemini: {
+    inputTokenCost: 125e-5,
+    outputTokenCost: 5e-3,
+    avgLatencyMs: 1500,
+    qualityScore: 0.85
+  },
+  codex: {
+    inputTokenCost: 3e-3,
+    outputTokenCost: 0.015,
+    avgLatencyMs: 1e3,
+    qualityScore: 0.8
+  },
+  opencode: {
+    inputTokenCost: 3e-3,
+    outputTokenCost: 0.012,
+    avgLatencyMs: 1500,
+    qualityScore: 0.82
+  }
+};
+var DEFAULT_LINUCB_CONFIG = {
+  numArms: 4,
+  featureDim: 6,
+  alpha: 1,
+  lambda: 1
+};
+var LinUCBConfigSchema = z6.object({
+  numArms: z6.number().int().positive().default(4),
+  featureDim: z6.number().int().positive().default(6),
+  alpha: z6.number().positive().default(1),
+  lambda: z6.number().positive().default(1)
+});
+
 // src/cli-adapters/budget-warnings.ts
 function getWarningLevel(utilization, thresholds) {
   if (utilization >= thresholds.critical) return "critical";
@@ -5539,6 +5593,20 @@ function generateBudgetWarnings(currentBudget, estimatedTokens, estimatedCostUsd
 }
 
 // src/cli-adapters/budget-errors.ts
+function fastestCandidateLatencyMs() {
+  const values = Object.values(DEFAULT_COST_MODELS).map((m) => m.avgLatencyMs);
+  return values.length === 0 ? 0 : Math.min(...values);
+}
+function latencyExceeded(budget, result) {
+  if (budget.maxLatencyMs === void 0) return void 0;
+  if (result.adapter !== null || result.estimatedLatencyMs !== void 0) return void 0;
+  return {
+    constraint: "latency",
+    limit: budget.maxLatencyMs,
+    current: fastestCandidateLatencyMs(),
+    suggestion: "Raise the latency budget or add a faster model"
+  };
+}
 function determineExceededConstraint(budget, result, currentBudget) {
   if (budget.maxTokens !== void 0 && result.estimatedTokens > budget.maxTokens) {
     return {
@@ -5556,6 +5624,8 @@ function determineExceededConstraint(budget, result, currentBudget) {
       suggestion: "Use a cheaper model or increase cost budget"
     };
   }
+  const latencyViolation = latencyExceeded(budget, result);
+  if (latencyViolation !== void 0) return latencyViolation;
   if (currentBudget.tokensRemaining < result.estimatedTokens) {
     return {
       constraint: "tokens",
@@ -5590,7 +5660,7 @@ function createBudgetExceededError(budget, result, currentBudget) {
 }
 
 // src/config/task-specialization-types.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var TASK_CATEGORIES = [
   "architecture",
   "code_generation",
@@ -5603,8 +5673,8 @@ var TASK_CATEGORIES = [
   "devops",
   "exploration"
 ];
-var TaskCategorySchema = z6.enum(TASK_CATEGORIES);
-var TaskSpecializationSchema = z6.object({
+var TaskCategorySchema = z7.enum(TASK_CATEGORIES);
+var TaskSpecializationSchema = z7.object({
   /** Task category identifier */
   category: TaskCategorySchema,
   /** Primary CLI recommendation */
@@ -5612,11 +5682,11 @@ var TaskSpecializationSchema = z6.object({
   /** Secondary CLI fallback */
   secondaryCli: CliNameSchema,
   /** Why this CLI is preferred for this task type */
-  reasoning: z6.string(),
+  reasoning: z7.string(),
   /** Keywords that trigger this category detection */
-  keywords: z6.array(z6.string()).min(1),
+  keywords: z7.array(z7.string()).min(1),
   /** Bonus score applied when this category matches (0-20) */
-  bonus: z6.number().min(0).max(20)
+  bonus: z7.number().min(0).max(20)
 });
 
 // src/config/task-specialization.ts
@@ -5809,6 +5879,9 @@ function estimateRegistryCostUsd(slot, inputTokens, outputTokens) {
   if (pricing === void 0) return void 0;
   return inputTokens / 1e6 * pricing.inputPer1M + outputTokens / 1e6 * pricing.outputPer1M;
 }
+function latencyOf(slot) {
+  return DEFAULT_COST_MODELS[slot]?.avgLatencyMs;
+}
 var BudgetRouter = class {
   adapters;
   options;
@@ -5892,8 +5965,9 @@ var BudgetRouter = class {
     const estimatedTokens = estimatedInputTokens + estimatedOutputTokens;
     const adapter = this.selectAdapterWithinBudget(budget, estimatedTokens);
     const estimatedCostUsd = adapter ? estimateCost(adapter.name, estimatedInputTokens, estimatedOutputTokens) : 0;
+    const estimatedLatencyMs = adapter === null ? void 0 : latencyOf(routingArmDisplaySlot(adapter.name));
     const currentBudget = this.getSessionBudget();
-    const withinBudget = this.checkConstraints(budget, estimatedTokens, estimatedCostUsd);
+    const withinBudget = adapter !== null && this.checkConstraints(budget, estimatedTokens, estimatedCostUsd);
     const warnings = generateBudgetWarnings(
       currentBudget,
       estimatedTokens,
@@ -5906,6 +5980,7 @@ var BudgetRouter = class {
       withinBudget,
       estimatedCostUsd,
       estimatedTokens,
+      ...estimatedLatencyMs !== void 0 ? { estimatedLatencyMs } : {},
       warnings,
       projectedBudget
     };
@@ -6060,7 +6135,8 @@ var BudgetRouter = class {
       const withinTokenBudget = budget.maxTokens === void 0 || estimatedTokens <= budget.maxTokens;
       const withinCostBudget = budget.maxCostUsd === void 0 || estimatedCost <= budget.maxCostUsd;
       const withinContextWindow = estimatedTokens <= caps.contextWindow;
-      if (withinTokenBudget && withinCostBudget && withinContextWindow) {
+      const withinLatencyBudget = budget.maxLatencyMs === void 0 || latencyOf(slot) === void 0 || latencyOf(slot) <= budget.maxLatencyMs;
+      if (withinTokenBudget && withinCostBudget && withinContextWindow && withinLatencyBudget) {
         return adapter;
       }
     }
@@ -6269,9 +6345,9 @@ var DEFAULT_OUTPUT_TOKENS = 500;
 var TopsisRouter = class {
   config;
   logger;
-  constructor(config = {}, logger15) {
+  constructor(config = {}, logger14) {
     this.config = { ...DEFAULT_TOPSIS_CONFIG, ...config };
-    this.logger = logger15 ?? createLogger({ component: "TopsisRouter" });
+    this.logger = logger14 ?? createLogger({ component: "TopsisRouter" });
     this.validateWeights();
   }
   /**
@@ -6451,34 +6527,6 @@ var TopsisRouter = class {
   }
 };
 
-// src/cli-adapters/budget-router-types.ts
-import { z as z7 } from "zod";
-var BudgetConstraintSchema = z7.object({
-  maxTokens: z7.number().int().positive().optional(),
-  maxCostUSD: z7.number().positive().optional(),
-  maxLatencyMs: z7.number().positive().optional()
-});
-var SessionBudgetSchema = z7.object({
-  totalTokens: z7.number().int().positive(),
-  totalCostUSD: z7.number().positive(),
-  usedTokens: z7.number().int().min(0).default(0),
-  usedCostUSD: z7.number().min(0).default(0),
-  startTime: z7.number().int().positive(),
-  sessionId: z7.string().min(1)
-});
-var DEFAULT_LINUCB_CONFIG = {
-  numArms: 4,
-  featureDim: 6,
-  alpha: 1,
-  lambda: 1
-};
-var LinUCBConfigSchema = z7.object({
-  numArms: z7.number().int().positive().default(4),
-  featureDim: z7.number().int().positive().default(6),
-  alpha: z7.number().positive().default(1),
-  lambda: z7.number().positive().default(1)
-});
-
 // src/cli-adapters/warm-start-skips.ts
 var UNATTRIBUTED_ARM = "unknown";
 function partitionWarmStartSkips(skipped) {
@@ -7827,9 +7875,9 @@ var ZeroRouter = class {
   logger;
   outcomes = [];
   calibrationBias = 0;
-  constructor(config, logger15) {
+  constructor(config, logger14) {
     this.config = ZeroRouterConfigSchema.parse(config ?? {});
-    this.logger = logger15 ?? createLogger({ component: "ZeroRouter" });
+    this.logger = logger14 ?? createLogger({ component: "ZeroRouter" });
     this.logger.debug("ZeroRouter initialized", {
       thresholds: this.config.thresholds,
       enableCalibration: this.config.enableCalibration
@@ -8340,9 +8388,9 @@ var ConfidenceCascadeStage = class {
   routingsCount = 0;
   escalationCount = 0;
   complexityDistribution = { simple: 0, moderate: 0, complex: 0 };
-  constructor(config = {}, logger15) {
+  constructor(config = {}, logger14) {
     this.config = { ...DEFAULT_CONFIG, ...config };
-    this.logger = logger15 ?? createLogger({ component: "ConfidenceCascadeStage" });
+    this.logger = logger14 ?? createLogger({ component: "ConfidenceCascadeStage" });
   }
   canHandle(ctx) {
     return getRemainingCandidates(ctx).length > 0;
@@ -8504,9 +8552,9 @@ var CapabilityMatchStage = class {
     creative: 0,
     general: 0
   };
-  constructor(config = {}, logger15) {
+  constructor(config = {}, logger14) {
     this.config = { ...DEFAULT_CONFIG2, ...config };
-    this.logger = logger15 ?? createLogger({ component: "CapabilityMatchStage" });
+    this.logger = logger14 ?? createLogger({ component: "CapabilityMatchStage" });
   }
   canHandle(ctx) {
     return getRemainingCandidates(ctx).length > 0;
@@ -8662,9 +8710,9 @@ var QualityConstraintStage = class {
   filteredCount = 0;
   fallbackCount = 0;
   constraintViolations = { quality: 0, cost: 0, latency: 0 };
-  constructor(config = {}, logger15) {
+  constructor(config = {}, logger14) {
     this.config = { ...DEFAULT_CONFIG3, ...config };
-    this.logger = logger15 ?? createLogger({ component: "QualityConstraintStage" });
+    this.logger = logger14 ?? createLogger({ component: "QualityConstraintStage" });
   }
   canHandle(ctx) {
     return getRemainingCandidates(ctx).length > 0;
@@ -8862,9 +8910,9 @@ var ResourceStrategyStage = class {
   logger;
   routingsCount = 0;
   tierHistory = [];
-  constructor(config = {}, logger15) {
+  constructor(config = {}, logger14) {
     this.config = { ...DEFAULT_CONFIG4, ...config };
-    this.logger = logger15 ?? createLogger({ component: "ResourceStrategyStage" });
+    this.logger = logger14 ?? createLogger({ component: "ResourceStrategyStage" });
   }
   canHandle(ctx) {
     return getRemainingCandidates(ctx).length > 1;
@@ -8973,10 +9021,10 @@ var DistilledRuleStage = class {
   config;
   logger;
   rulesAppliedCount = 0;
-  constructor(distiller, config, logger15) {
+  constructor(distiller, config, logger14) {
     this.distiller = distiller;
     this.config = { ...DEFAULT_CONFIG5, ...config };
-    this.logger = logger15 ?? createLogger({ component: "DistilledRuleStage" });
+    this.logger = logger14 ?? createLogger({ component: "DistilledRuleStage" });
   }
   canHandle(ctx) {
     const candidates = getRemainingCandidates(ctx);
@@ -9019,15 +9067,23 @@ var DistilledRuleStage = class {
     let applied = 0;
     for (const cli of candidates) {
       const matchingRules = this.findMatchingRules(activeRules, cli, category);
+      if (matchingRules.length === 0) continue;
+      const raw = matchingRules.reduce((sum, rule) => sum + this.computeDelta(rule), 0);
+      const capped = Math.min(this.config.boostDelta, Math.max(this.config.avoidDelta, raw));
+      updated = updateScore(updated, cli, capped);
       for (const rule of matchingRules) {
-        const delta = this.computeDelta(rule);
-        updated = updateScore(updated, cli, delta);
         updated = {
           ...updated,
           signals: [...updated.signals, `distilled-rule:applied=${rule.id}`]
         };
         applied++;
       }
+      if (capped !== raw) {
+        updated = {
+          ...updated,
+          signals: [...updated.signals, `distilled-rule:capped=${cli}`]
+        };
+      }
     }
     this.rulesAppliedCount += applied;
     const elapsed = getTimeProvider().now() - start;
@@ -9111,10 +9167,10 @@ var KnnRoutingStage = class {
   memory;
   routingsCount = 0;
   matchCount = 0;
-  constructor(memory, config = {}, logger15) {
+  constructor(memory, config = {}, logger14) {
     this.config = { ...DEFAULT_CONFIG6, ...config };
     this.memory = memory;
-    this.logger = logger15 ?? createLogger({ component: "KnnRoutingStage" });
+    this.logger = logger14 ?? createLogger({ component: "KnnRoutingStage" });
   }
   canHandle(ctx) {
     return getRemainingCandidates(ctx).length > 0;
@@ -9248,10 +9304,10 @@ var CapacityFilterStage = class {
   unmeasuredCount = 0;
   /** Candidates whose own rolling window was full (#4456). Never excluded. */
   throttledCount = 0;
-  constructor(adapters, config = {}, logger15) {
+  constructor(adapters, config = {}, logger14) {
     this.adapters = adapters;
     this.config = { ...DEFAULT_CONFIG7, ...config };
-    this.logger = logger15 ?? createLogger({ component: "CapacityFilterStage" });
+    this.logger = logger14 ?? createLogger({ component: "CapacityFilterStage" });
   }
   canHandle(ctx) {
     return getRemainingCandidates(ctx).length > 0;
@@ -9289,6 +9345,10 @@ var CapacityFilterStage = class {
   }
   getStats() {
     return {
+      // #4658: `excludedCount` can only be zero while enforcement is off, so
+      // reporting it alone presents a default as a measurement. `enforced`
+      // says which of the two a zero is.
+      enforced: this.config.enforceHardLimits,
       excludedCount: this.excludedCount,
       unmeasuredCount: this.unmeasuredCount,
       throttledCount: this.throttledCount
@@ -9580,10 +9640,10 @@ var StrategyDistiller = class {
   rules = /* @__PURE__ */ new Map();
   outcomeCounter = 0;
   lastDistillAt;
-  constructor(outcomeStore, logger15, config) {
+  constructor(outcomeStore, logger14, config) {
     this.outcomeStore = outcomeStore;
     this.config = { ...DEFAULT_DISTILLER_CONFIG, ...config };
-    this.logger = logger15 ?? createLogger({ component: "StrategyDistiller" });
+    this.logger = logger14 ?? createLogger({ component: "StrategyDistiller" });
   }
   /** Called for each processed outcome. Triggers distillation at threshold. */
   onOutcome() {
@@ -9749,18 +9809,18 @@ var StrategyDistiller = class {
     };
   }
 };
-function createStrategyDistiller(outcomeStore, logger15, config) {
-  return new StrategyDistiller(outcomeStore, logger15, config);
+function createStrategyDistiller(outcomeStore, logger14, config) {
+  return new StrategyDistiller(outcomeStore, logger14, config);
 }
 var persistentDistillerFactory;
 function registerPersistentDistillerFactory(factory) {
   persistentDistillerFactory = factory;
 }
-function createPersistentDistillerOrFallback(outcomeStore, logger15) {
+function createPersistentDistillerOrFallback(outcomeStore, logger14) {
   if (persistentDistillerFactory !== void 0) {
-    return persistentDistillerFactory(outcomeStore, logger15);
+    return persistentDistillerFactory(outcomeStore, logger14);
   }
-  return new StrategyDistiller(outcomeStore, logger15);
+  return new StrategyDistiller(outcomeStore, logger14);
 }
 
 // src/orchestration/outcomes/outcome-types.ts
@@ -10444,8 +10504,8 @@ function generateSyntheticPriors() {
   }
   return priors;
 }
-function runWarmUp(logger15) {
-  const log = logger15 ?? createLogger({ component: "warm-up" });
+function runWarmUp(logger14) {
+  const log = logger14 ?? createLogger({ component: "warm-up" });
   const store = getOutcomeStore();
   const existing = store.query();
   const hasSynthetic = existing.some((o) => o.qualitySignals?.includes(SYNTHETIC_MARKER) === true);
@@ -14424,7 +14484,7 @@ function parseCatalog(text) {
     (m) => m.supported_parameters === void 0 ? { id: m.id } : { id: m.id, supportedParameters: m.supported_parameters }
   );
 }
-async function fetchCatalog(url, timeoutMs, doFetch) {
+async function fetchCatalogOrThrow(url, timeoutMs, doFetch) {
   const controller = new AbortController();
   const timer = setTimeout(() => {
     controller.abort();
@@ -14435,26 +14495,15 @@ async function fetchCatalog(url, timeoutMs, doFetch) {
       headers: { accept: "application/json" }
     });
     if (!res.ok) {
-      logger12.warn("OpenRouter catalog fetch returned non-OK; treating as empty", {
-        status: res.status
-      });
-      return [];
+      throw new Error(`OpenRouter catalog fetch returned HTTP ${String(res.status)}`);
     }
     const declaredLen = res.headers.get("content-length");
     if (declaredLen !== null && Number(declaredLen) > MAX_BYTES) {
-      logger12.warn("OpenRouter catalog Content-Length exceeds byte cap; ignoring", {
-        bytes: declaredLen
-      });
-      return [];
+      throw new Error(`OpenRouter catalog Content-Length ${declaredLen} exceeds the byte cap`);
     }
     const ids = parseCatalog(await res.text());
     logger12.debug("OpenRouter catalog loaded", { count: ids.length });
     return ids;
-  } catch (error) {
-    logger12.warn("OpenRouter catalog fetch failed; treating as empty", {
-      error: error instanceof Error ? error.message : String(error)
-    });
-    return [];
   } finally {
     clearTimeout(timer);
   }
@@ -14466,12 +14515,13 @@ function createOpenRouterModelsSource(opts = {}) {
   return {
     name: "openrouter",
     providerHint: "openrouter",
-    listModels: () => fetchCatalog(url, timeoutMs, doFetch)
+    // Throws on probe failure so the cache can tell it apart from an empty
+    // catalog (#5059).
+    listModels: () => fetchCatalogOrThrow(url, timeoutMs, doFetch)
   };
 }
 
 // src/config/register-model-sources.ts
-var logger13 = createLogger({ component: "register-model-sources" });
 function isDynamicModelsEnabled() {
   return process.env["NEXUS_DYNAMIC_MODELS"] === "true";
 }
@@ -14481,13 +14531,7 @@ function hasListModels(adapter) {
 function adapterSource(cliName, adapter) {
   return {
     name: cliName,
-    listModels: () => adapter.listModels().then((models) => models.map((m) => ({ id: m.id }))).catch((error) => {
-      logger13.debug("adapter listModels failed; treating as empty", {
-        cli: cliName,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return [];
-    })
+    listModels: () => adapter.listModels().then((models) => models.map((m) => ({ id: m.id })))
   };
 }
 function buildDefaultModelSources(adapters, opts = {}) {
@@ -14681,14 +14725,14 @@ function evaluateModelSelectionReadiness(records, config = DEFAULT_MODEL_SELECTI
   return { ready: blockers.length === 0, criteria, blockers };
 }
 var readinessLogged = false;
-function logModelSelectionReadinessOnce(logger15) {
+function logModelSelectionReadinessOnce(logger14) {
   if (readinessLogged) return;
   readinessLogged = true;
   try {
     const records = readModelSelectionShadowRecords();
     const summary = summarizeModelSelectionShadow(records);
     const verdict = evaluateModelSelectionReadiness(records);
-    logger15.info("route-model-selection shadow readiness", {
+    logger14.info("route-model-selection shadow readiness", {
       ready: verdict.ready,
       blockers: verdict.blockers,
       total: summary.total,
@@ -14700,7 +14744,7 @@ function logModelSelectionReadinessOnce(logger15) {
       meanCostUsd: summary.meanCostUsd
     });
   } catch (err2) {
-    logger15.warn("route-model-selection readiness signal failed (non-fatal)", {
+    logger14.warn("route-model-selection readiness signal failed (non-fatal)", {
       error: getErrorMessage(err2)
     });
   }
@@ -14931,7 +14975,7 @@ var CompositeRouter = class _CompositeRouter {
    * The task content itself is never persisted.
    */
   pendingModelShadow;
-  constructor(adapters, config, logger15) {
+  constructor(adapters, config, logger14) {
     const {
       preferenceRouterConfig,
       zeroRouterConfig,
@@ -14942,22 +14986,17 @@ var CompositeRouter = class _CompositeRouter {
       qualityConstraintConfig,
       resourceStrategyConfig,
       distilledRuleStageConfig,
+      capacityStageConfig,
       metricsCollector,
       orchestrationObserver,
       availableModelsCache,
       ...baseConfig
     } = config ?? {};
     this.config = CompositeRouterConfigSchema.parse(baseConfig);
-    this.logger = logger15 ?? createLogger({ component: "CompositeRouter" });
+    this.logger = logger14 ?? createLogger({ component: "CompositeRouter" });
     this.adapters = adapters;
     this.cliNames = Array.from(adapters.keys());
-    if (metricsCollector !== void 0) {
-      this.metricsCollector = metricsCollector;
-    }
-    if (orchestrationObserver !== void 0) {
-      this.orchestrationObserver = orchestrationObserver;
-      this.logger.debug("OrchestrationObserver wired to CompositeRouter");
-    }
+    this.assignOptionalCollaborators(metricsCollector, orchestrationObserver);
     if (availableModelsCache !== void 0) {
       this.availableModelsCache = availableModelsCache;
       this.logger.debug("AvailableModelsCache wired to CompositeRouter");
@@ -14973,10 +15012,25 @@ var CompositeRouter = class _CompositeRouter {
       capabilityMatch: capabilityMatchConfig,
       qualityConstraint: qualityConstraintConfig,
       resourceStrategy: resourceStrategyConfig,
-      distilledRule: distilledRuleStageConfig
+      distilledRule: distilledRuleStageConfig,
+      capacity: capacityStageConfig
     });
     this.logInitialization(adapters.size);
   }
+  /**
+   * Optional collaborators, assigned only when supplied so an absent one stays
+   * `undefined` rather than being stored as a null-ish value. Extracted from
+   * the constructor to keep it under the function-length bar (#4658).
+   */
+  assignOptionalCollaborators(metricsCollector, orchestrationObserver) {
+    if (metricsCollector !== void 0) {
+      this.metricsCollector = metricsCollector;
+    }
+    if (orchestrationObserver !== void 0) {
+      this.orchestrationObserver = orchestrationObserver;
+      this.logger.debug("OrchestrationObserver wired to CompositeRouter");
+    }
+  }
   initializeCoreRouters(adapters, preferenceConfig, zeroConfig, latencyConfig) {
     if (this.config.enableBudgetFilter && adapters.size > 0) {
       this.budgetRouter = this.buildBudgetRouter(adapters);
@@ -15023,7 +15077,11 @@ var CompositeRouter = class _CompositeRouter {
       this.resourceStrategyStage = new ResourceStrategyStage(stageConfigs.resourceStrategy);
     }
     if (this.config.enableCapacityBalancing) {
-      this.capacityFilterStage = new CapacityFilterStage(this.adapters, {}, this.logger);
+      this.capacityFilterStage = new CapacityFilterStage(
+        this.adapters,
+        stageConfigs.capacity ?? {},
+        this.logger
+      );
     }
     if (this.config.enableStrategyDistillation) {
       this.strategyDistiller = isPersistenceEnabled() ? createPersistentDistillerOrFallback(getOutcomeStore(), this.logger) : new StrategyDistiller(getOutcomeStore(), this.logger);
@@ -15118,7 +15176,7 @@ var CompositeRouter = class _CompositeRouter {
    */
   async consultUnifiedContext(task) {
     try {
-      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-L2LTCKV6.js");
+      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-G3UORDWI.js");
       const ctx = await getContextForTask({
         task: task.content,
         category: inferTaskCategory(task.content),
@@ -15544,7 +15602,8 @@ var CompositeRouter = class _CompositeRouter {
       budgetRejectionRate: this.totalDecisions > 0 ? this.budgetRejections / this.totalDecisions : 0,
       banditStats: this.linucbBandit?.getStats() ?? [],
       latencyStats,
-      routingMemoryStats
+      routingMemoryStats,
+      ...capacityStatsOf(this.capacityFilterStage)
     };
     if (preferenceStats !== void 0) {
       return { ...baseStats, preferenceStats };
@@ -15556,14 +15615,24 @@ var CompositeRouter = class _CompositeRouter {
     return this.routingMemory;
   }
 };
-function createCompositeRouter(adapters, config, logger15) {
+function createCompositeRouter(adapters, config, logger14) {
   let resolved = config;
   if (isDynamicModelsEnabled() && config?.availableModelsCache === void 0) {
     const cache = getDefaultAvailableModelsCache();
     registerDefaultModelSources(cache, adapters);
     resolved = { ...config, availableModelsCache: cache };
   }
-  return new CompositeRouter(adapters, resolved, logger15);
+  return new CompositeRouter(adapters, resolved, logger14);
+}
+function capacityStatsOf(stage) {
+  if (stage === void 0) return {};
+  const stats = stage.getStats();
+  return {
+    capacityStats: {
+      enforced: stats["enforced"] === true,
+      excludedCount: typeof stats["excludedCount"] === "number" ? stats["excludedCount"] : 0
+    }
+  };
 }
 
 // src/core/types/model.ts
@@ -16093,7 +16162,7 @@ var ActionCacheImpl = class {
 };
 
 // src/context/mobimem.ts
-var logger14 = createLogger({ component: "MobiMem" });
+var logger13 = createLogger({ component: "MobiMem" });
 var MobiMem = class {
   profile;
   experience;
@@ -16114,7 +16183,7 @@ var MobiMem = class {
     this.profile = new ProfileMemoryImpl(this.config, this.db);
     this.experience = new ExperienceMemoryImpl(this.config, this.db);
     this.action = new ActionCacheImpl(this.config, this.db);
-    logger14.info("MobiMem initialized", {
+    logger13.info("MobiMem initialized", {
       dbPath: validated.dbPath,
       persisted: this.db !== null,
       maxProfileEntries: this.config.maxProfileEntries,
@@ -16147,13 +16216,13 @@ var MobiMem = class {
     if (this.config.autoEviction) {
       const evicted = this.action.evictExpired();
       if (evicted > 0) {
-        logger14.debug("Evicted expired action cache entries", { count: evicted });
+        logger13.debug("Evicted expired action cache entries", { count: evicted });
       }
     }
   }
   close() {
     if (this.db !== null) this.db.close();
-    logger14.info("MobiMem closed");
+    logger13.info("MobiMem closed");
   }
 };
 var sharedInstance = null;
@@ -16711,4 +16780,4 @@ export {
   AgentCapability,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-OYFKB64X.js.map
+//# sourceMappingURL=chunk-7GWPLERY.js.map