nexus-agents 2.174.0 → 2.174.2

package/dist/{chunk-25ZJ5TCC.js → chunk-Y5JA7XEO.js}

@@ -2170,14 +2170,14 @@ var ManifestSchema = z2.object({
   models: z2.array(z2.unknown())
 });
 function loadManifestOverlay(options) {
-  const logger14 = options?.logger ?? createLogger({ component: "manifest-overlay" });
+  const logger15 = options?.logger ?? createLogger({ component: "manifest-overlay" });
   if (options?.path !== void 0) {
-    return loadManifestFile(options.path, logger14);
+    return loadManifestFile(options.path, logger15);
   }
   const userPath = resolveUserManifestPath(options?.env);
   const operatorPath = resolveManifestPath(options?.env);
-  const user = loadManifestFile(userPath, logger14);
-  const operator = loadManifestFile(operatorPath, logger14);
+  const user = loadManifestFile(userPath, logger15);
+  const operator = loadManifestFile(operatorPath, logger15);
   return mergeOverlays(user, operator);
 }
 function mergeOverlays(lower, higher) {
@@ -2194,11 +2194,11 @@ function mergeOverlays(lower, higher) {
   return merged;
 }
 function loadUserManifestOverlay(options) {
-  const logger14 = options?.logger ?? createLogger({ component: "manifest-overlay" });
+  const logger15 = options?.logger ?? createLogger({ component: "manifest-overlay" });
   const path2 = options?.path ?? resolveUserManifestPath(options?.env);
-  return loadManifestFile(path2, logger14);
+  return loadManifestFile(path2, logger15);
 }
-function loadManifestFile(path2, logger14) {
+function loadManifestFile(path2, logger15) {
   let exists = false;
   try {
     exists = existsSync(path2);
@@ -2213,7 +2213,7 @@ function loadManifestFile(path2, logger14) {
     return { entries: [], rejections: [], path: path2, status: "empty" };
   }
   if (stat.size > MANIFEST_MAX_BYTES) {
-    logger14.warn("Manifest overlay too large; skipping", {
+    logger15.warn("Manifest overlay too large; skipping", {
       path: path2,
       size: stat.size,
       max: MANIFEST_MAX_BYTES
@@ -2221,9 +2221,9 @@ function loadManifestFile(path2, logger14) {
     return { entries: [], rejections: [], path: path2, status: "too-large" };
   }
   const raw = readFileSync(path2, "utf-8");
-  return parseManifest(raw, path2, logger14);
+  return parseManifest(raw, path2, logger15);
 }
-function parseManifest(raw, path2, logger14) {
+function parseManifest(raw, path2, logger15) {
   let parsed;
   try {
     if (path2.endsWith(".json")) {
@@ -2232,7 +2232,7 @@ function parseManifest(raw, path2, logger14) {
       parsed = parseYaml(raw);
     }
   } catch (e) {
-    logger14.warn("Manifest overlay parse failure; skipping", {
+    logger15.warn("Manifest overlay parse failure; skipping", {
       path: path2,
       error: e instanceof Error ? e.message : String(e)
     });
@@ -2240,7 +2240,7 @@ function parseManifest(raw, path2, logger14) {
   }
   const shape = ManifestSchema.safeParse(parsed);
   if (!shape.success) {
-    logger14.warn("Manifest overlay schema mismatch at root; skipping", {
+    logger15.warn("Manifest overlay schema mismatch at root; skipping", {
       path: path2,
       issues: shape.error.issues.slice(0, 5).map((i) => i.message)
     });
@@ -2315,7 +2315,7 @@ function defaultSnapshotPath() {
   return join(here, "models-dev-snapshot.json");
 }
 function loadModelsDevSnapshot(options) {
-  const logger14 = createLogger({ component: "models-dev-snapshot" });
+  const logger15 = createLogger({ component: "models-dev-snapshot" });
   const path2 = options?.path ?? defaultSnapshotPath();
   let exists = false;
   try {
@@ -2330,21 +2330,21 @@ function loadModelsDevSnapshot(options) {
   try {
     parsed = JSON.parse(readFileSync2(path2, "utf-8"));
   } catch (e) {
-    logger14.warn("models.dev snapshot parse failure; skipping", {
+    logger15.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) {
-    logger14.warn("models.dev snapshot version unsupported; skipping", {
+    logger15.warn("models.dev snapshot version unsupported; skipping", {
       path: path2,
       version: parsed.version
     });
     return { entries: [], path: path2, status: "malformed" };
   }
   if (!Array.isArray(parsed.entries)) {
-    logger14.warn("models.dev snapshot missing entries array; skipping", { path: path2 });
+    logger15.warn("models.dev snapshot missing entries array; skipping", { path: path2 });
     return { entries: [], path: path2, status: "malformed" };
   }
   const entries = parsed.entries;
@@ -2391,7 +2391,7 @@ function toModelEntry(rec) {
   };
 }
 function loadGeneratedRegistryEntries(options) {
-  const logger14 = createLogger({ component: "models-generated" });
+  const logger15 = createLogger({ component: "models-generated" });
   const path2 = options?.path ?? defaultGeneratedPath();
   let exists = false;
   try {
@@ -2404,14 +2404,14 @@ function loadGeneratedRegistryEntries(options) {
   try {
     parsed = JSON.parse(readFileSync3(path2, "utf-8"));
   } catch (e) {
-    logger14.warn("generated registry parse failure; skipping", {
+    logger15.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)) {
-    logger14.warn("generated registry missing entries array; skipping", { path: path2 });
+    logger15.warn("generated registry missing entries array; skipping", { path: path2 });
     return { entries: [], path: path2, status: "malformed" };
   }
   const entries = [];
@@ -2619,7 +2619,7 @@ function setDefaultRegistry(registry) {
 }
 async function reloadDefaultRegistry() {
   globalRegistry = buildDefaultRegistry();
-  const { resetGlobalRegistry } = await import("./unified-registry-35EIUQ2M.js");
+  const { resetGlobalRegistry } = await import("./unified-registry-JWPD2ES2.js");
   resetGlobalRegistry();
   return globalRegistry;
 }
@@ -2845,7 +2845,7 @@ function lookupCanonicalPricing(model) {
   for (const m of models) {
     if (m.pricing !== void 0 && isPrefixMatch(m, model)) return toPricing(m.pricing);
   }
-  return void 0;
+  return toPricing(getDefaultRegistry().getEntry(model).pricing);
 }
 function calculateCost(model, inputTokens, outputTokens) {
   const pricing = lookupCanonicalPricing(model);
@@ -5336,6 +5336,13 @@ function estimateTokens(text) {
 }
 
 // src/cli-adapters/types-core.ts
+import { z as z4 } from "zod";
+var ApiArmIdSchema = z4.enum([
+  "api:anthropic",
+  "api:openai",
+  "api:google",
+  "api:custom-openai"
+]);
 function apiArmId(vendor) {
   return `api:${vendor}`;
 }
@@ -5519,7 +5526,7 @@ function createBudgetExceededError(budget, result, currentBudget) {
 }
 
 // src/config/task-specialization-types.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var TASK_CATEGORIES = [
   "architecture",
   "code_generation",
@@ -5532,8 +5539,8 @@ var TASK_CATEGORIES = [
   "devops",
   "exploration"
 ];
-var TaskCategorySchema = z4.enum(TASK_CATEGORIES);
-var TaskSpecializationSchema = z4.object({
+var TaskCategorySchema = z5.enum(TASK_CATEGORIES);
+var TaskSpecializationSchema = z5.object({
   /** Task category identifier */
   category: TaskCategorySchema,
   /** Primary CLI recommendation */
@@ -5541,11 +5548,11 @@ var TaskSpecializationSchema = z4.object({
   /** Secondary CLI fallback */
   secondaryCli: CliNameSchema,
   /** Why this CLI is preferred for this task type */
-  reasoning: z4.string(),
+  reasoning: z5.string(),
   /** Keywords that trigger this category detection */
-  keywords: z4.array(z4.string()).min(1),
+  keywords: z5.array(z5.string()).min(1),
   /** Bonus score applied when this category matches (0-20) */
-  bonus: z4.number().min(0).max(20)
+  bonus: z5.number().min(0).max(20)
 });
 
 // src/config/task-specialization.ts
@@ -6198,9 +6205,9 @@ var DEFAULT_OUTPUT_TOKENS = 500;
 var TopsisRouter = class {
   config;
   logger;
-  constructor(config = {}, logger14) {
+  constructor(config = {}, logger15) {
     this.config = { ...DEFAULT_TOPSIS_CONFIG, ...config };
-    this.logger = logger14 ?? createLogger({ component: "TopsisRouter" });
+    this.logger = logger15 ?? createLogger({ component: "TopsisRouter" });
     this.validateWeights();
   }
   /**
@@ -6381,19 +6388,19 @@ var TopsisRouter = class {
 };
 
 // src/cli-adapters/budget-router-types.ts
-import { z as z5 } from "zod";
-var BudgetConstraintSchema = z5.object({
-  maxTokens: z5.number().int().positive().optional(),
-  maxCostUSD: z5.number().positive().optional(),
-  maxLatencyMs: z5.number().positive().optional()
+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 = z5.object({
-  totalTokens: z5.number().int().positive(),
-  totalCostUSD: z5.number().positive(),
-  usedTokens: z5.number().int().min(0).default(0),
-  usedCostUSD: z5.number().min(0).default(0),
-  startTime: z5.number().int().positive(),
-  sessionId: z5.string().min(1)
+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_LINUCB_CONFIG = {
   numArms: 4,
@@ -6401,11 +6408,11 @@ var DEFAULT_LINUCB_CONFIG = {
   alpha: 1,
   lambda: 1
 };
-var LinUCBConfigSchema = z5.object({
-  numArms: z5.number().int().positive().default(4),
-  featureDim: z5.number().int().positive().default(6),
-  alpha: z5.number().positive().default(1),
-  lambda: z5.number().positive().default(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/linucb-math.ts
@@ -6542,6 +6549,7 @@ function createIdentityMatrixInverse(dim, lambda) {
 }
 
 // src/cli-adapters/linucb-bandit.ts
+var logger5 = createLogger({ component: "linucb-bandit" });
 var SUCCESS_REWARD = 0.7;
 var FAILURE_REWARD = 0.1;
 var LinUCBBandit = class {
@@ -6722,6 +6730,13 @@ var LinUCBBandit = class {
    * from persisted data. Uses a neutral context (same as seedPriors) since
    * the original task context is not stored in TaskOutcome.
    *
+   * Outcomes whose arm is not among this bandit's arms are skipped. That skip
+   * used to be entirely silent, which hid a real defect: `api:*` arms could not
+   * be represented in `TaskOutcome.cli` at all (#4400), so every API arm
+   * discarded its whole history and began cold each process with nothing
+   * reported. The skip is now counted and logged — a warm-start that silently
+   * drops most of its input looks identical to one that worked.
+   *
    * @param outcomes - Persisted task outcomes to replay
    * @returns Number of outcomes successfully replayed
    */
@@ -6735,14 +6750,25 @@ var LinUCBBandit = class {
       timePressure: 0.5
     };
     let replayed = 0;
+    const skippedArms = /* @__PURE__ */ new Map();
     for (const outcome of outcomes) {
       const armIndex = this.armNames.indexOf(outcome.cli);
-      if (armIndex < 0) continue;
+      if (armIndex < 0) {
+        skippedArms.set(outcome.cli, (skippedArms.get(outcome.cli) ?? 0) + 1);
+        continue;
+      }
       const reward = outcome.success ? SUCCESS_REWARD : FAILURE_REWARD;
       this.update(armIndex, neutralContext, reward);
       this.recordWarmStartModelStat(outcome.cli, outcome.model, outcome.success);
       replayed++;
     }
+    if (skippedArms.size > 0) {
+      logger5.warn("Warm-start skipped outcomes for arms this bandit does not have", {
+        skippedByArm: Object.fromEntries(skippedArms),
+        replayed,
+        knownArms: this.armNames
+      });
+    }
     return replayed;
   }
   /** Accumulate the per-arm × per-model warm-start ledger (#4194). */
@@ -6786,7 +6812,7 @@ var LinUCBBandit = class {
 import { randomUUID as randomUUID4 } from "crypto";
 
 // src/cli-adapters/preference-router-types.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var DEFAULT_PREFERENCE_ROUTER_CONFIG = {
   strongModel: {
     tier: "strong",
@@ -6807,24 +6833,24 @@ var DEFAULT_PREFERENCE_ROUTER_CONFIG = {
   maxDataPoints: 1e4,
   enableOnlineLearning: true
 };
-var PreferenceRouterConfigSchema = z6.object({
-  strongModel: z6.object({
-    tier: z6.literal("strong"),
-    cli: z6.enum(["claude", "gemini", "codex", "opencode"]),
-    costPerMillionTokens: z6.number().positive(),
-    qualityBaseline: z6.number().min(0).max(1)
+var PreferenceRouterConfigSchema = z7.object({
+  strongModel: z7.object({
+    tier: z7.literal("strong"),
+    cli: z7.enum(["claude", "gemini", "codex", "opencode"]),
+    costPerMillionTokens: z7.number().positive(),
+    qualityBaseline: z7.number().min(0).max(1)
   }),
-  weakModel: z6.object({
-    tier: z6.literal("weak"),
-    cli: z6.enum(["claude", "gemini", "codex", "opencode"]),
-    costPerMillionTokens: z6.number().positive(),
-    qualityBaseline: z6.number().min(0).max(1)
+  weakModel: z7.object({
+    tier: z7.literal("weak"),
+    cli: z7.enum(["claude", "gemini", "codex", "opencode"]),
+    costPerMillionTokens: z7.number().positive(),
+    qualityBaseline: z7.number().min(0).max(1)
   }),
-  routingThreshold: z6.number().min(0).max(1).default(0.5),
-  minDataPoints: z6.number().int().positive().default(10),
-  maxDataPoints: z6.number().int().positive().default(1e4),
-  enableOnlineLearning: z6.boolean().default(true),
-  domainThresholds: z6.record(z6.string(), z6.number().min(0).max(1)).optional()
+  routingThreshold: z7.number().min(0).max(1).default(0.5),
+  minDataPoints: z7.number().int().positive().default(10),
+  maxDataPoints: z7.number().int().positive().default(1e4),
+  enableOnlineLearning: z7.boolean().default(true),
+  domainThresholds: z7.record(z7.string(), z7.number().min(0).max(1)).optional()
 });
 
 // src/cli-adapters/preference-router-store.ts
@@ -7019,7 +7045,7 @@ var QueryFeatureExtractor = class {
 };
 
 // src/cli-adapters/preference-router.ts
-var logger5 = createLogger({ component: "PreferenceRouter" });
+var logger6 = createLogger({ component: "PreferenceRouter" });
 var PreferenceRouter = class {
   config;
   dataStore;
@@ -7032,7 +7058,7 @@ var PreferenceRouter = class {
     this.config = validated;
     this.dataStore = dataStore ?? new InMemoryPreferenceStore(validated.maxDataPoints);
     this.featureExtractor = new QueryFeatureExtractor();
-    logger5.info("PreferenceRouter initialized", {
+    logger6.info("PreferenceRouter initialized", {
       strongModel: this.config.strongModel.cli,
       weakModel: this.config.weakModel.cli,
       threshold: this.config.routingThreshold
@@ -7058,7 +7084,7 @@ var PreferenceRouter = class {
       routingLatencyMs: getTimeProvider().now() - startTime,
       estimatedCostSavings: costSavings
     };
-    logger5.debug("Routing decision made", {
+    logger6.debug("Routing decision made", {
       tier: selectedTier,
       cli: selectedConfig.cli,
       probability: prediction.strongModelProbability,
@@ -7083,7 +7109,7 @@ var PreferenceRouter = class {
     };
     if (this.config.enableOnlineLearning) {
       this.dataStore.store(dataPoint);
-      logger5.debug("Preference recorded", {
+      logger6.debug("Preference recorded", {
         strongPreferred: strongModelPreferred,
         domain: features.domain
       });
@@ -7166,7 +7192,7 @@ function createPreferenceRouter(config, dataStore) {
 }
 
 // src/cli-adapters/zero-router-types.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/cli-adapters/derive-tier-tables.ts
 var CLI_ORDER = CLI_NAMES;
@@ -7294,7 +7320,7 @@ function deriveWeakClis() {
 }
 
 // src/cli-adapters/zero-router-types.ts
-var DifficultyDimensionSchema = z7.enum([
+var DifficultyDimensionSchema = z8.enum([
   "reasoning",
   "knowledge",
   "creativity",
@@ -7308,17 +7334,17 @@ var DIFFICULTY_DIMENSIONS = [
   "precision",
   "context_length"
 ];
-var DifficultySpaceSchema = z7.object({
+var DifficultySpaceSchema = z8.object({
   /** Reasoning difficulty: logical complexity, multi-step inference (0-1) */
-  reasoning: z7.number().min(0).max(1),
+  reasoning: z8.number().min(0).max(1),
   /** Knowledge difficulty: domain expertise required (0-1) */
-  knowledge: z7.number().min(0).max(1),
+  knowledge: z8.number().min(0).max(1),
   /** Creativity difficulty: novel generation, open-endedness (0-1) */
-  creativity: z7.number().min(0).max(1),
+  creativity: z8.number().min(0).max(1),
   /** Precision difficulty: accuracy requirements, error tolerance (0-1) */
-  precision: z7.number().min(0).max(1),
+  precision: z8.number().min(0).max(1),
   /** Context length difficulty: amount of context to process (0-1) */
-  context_length: z7.number().min(0).max(1)
+  context_length: z8.number().min(0).max(1)
 });
 var DEFAULT_DIFFICULTY_THRESHOLDS = {
   easyUpperBound: 0.3,
@@ -7330,12 +7356,12 @@ var DEFAULT_DIFFICULTY_TO_TIER = {
   hard: "powerful"
 };
 var DEFAULT_TIER_TO_CLIS = deriveTierToClis();
-var DifficultyWeightsSchema = z7.object({
-  reasoning: z7.number().min(0).max(1),
-  knowledge: z7.number().min(0).max(1),
-  creativity: z7.number().min(0).max(1),
-  precision: z7.number().min(0).max(1),
-  context_length: z7.number().min(0).max(1)
+var DifficultyWeightsSchema = z8.object({
+  reasoning: z8.number().min(0).max(1),
+  knowledge: z8.number().min(0).max(1),
+  creativity: z8.number().min(0).max(1),
+  precision: z8.number().min(0).max(1),
+  context_length: z8.number().min(0).max(1)
 });
 var DEFAULT_DIFFICULTY_WEIGHTS = {
   reasoning: 0.3,
@@ -7344,29 +7370,29 @@ var DEFAULT_DIFFICULTY_WEIGHTS = {
   precision: 0.25,
   context_length: 0.15
 };
-var ZeroRouterConfigSchema = z7.object({
+var ZeroRouterConfigSchema = z8.object({
   /** Difficulty thresholds for level classification */
-  thresholds: z7.object({
-    easyUpperBound: z7.number().min(0).max(1),
-    hardLowerBound: z7.number().min(0).max(1)
+  thresholds: z8.object({
+    easyUpperBound: z8.number().min(0).max(1),
+    hardLowerBound: z8.number().min(0).max(1)
   }).default(DEFAULT_DIFFICULTY_THRESHOLDS),
   /** Weights for difficulty aggregation */
   weights: DifficultyWeightsSchema.default(DEFAULT_DIFFICULTY_WEIGHTS),
   /** Mapping from difficulty level to model tier */
-  difficultyToTier: z7.record(z7.enum(["easy", "medium", "hard"]), z7.enum(["fast", "balanced", "powerful"])).default(DEFAULT_DIFFICULTY_TO_TIER),
+  difficultyToTier: z8.record(z8.enum(["easy", "medium", "hard"]), z8.enum(["fast", "balanced", "powerful"])).default(DEFAULT_DIFFICULTY_TO_TIER),
   /** Mapping from model tier to CLI preference order */
-  tierToClis: z7.record(
-    z7.enum(["fast", "balanced", "powerful"]),
-    z7.array(z7.enum(["claude", "gemini", "codex", "opencode"]))
+  tierToClis: z8.record(
+    z8.enum(["fast", "balanced", "powerful"]),
+    z8.array(z8.enum(["claude", "gemini", "codex", "opencode"]))
   ).default(DEFAULT_TIER_TO_CLIS),
   /** Enable adaptive calibration from outcomes */
-  enableCalibration: z7.boolean().default(true),
+  enableCalibration: z8.boolean().default(true),
   /** Maximum outcomes to store for calibration */
-  maxCalibrationOutcomes: z7.number().int().positive().default(1e3),
+  maxCalibrationOutcomes: z8.number().int().positive().default(1e3),
   /** Minimum outcomes before applying calibration adjustments */
-  minCalibrationOutcomes: z7.number().int().positive().default(50),
+  minCalibrationOutcomes: z8.number().int().positive().default(50),
   /** Verbose logging */
-  verbose: z7.boolean().default(false)
+  verbose: z8.boolean().default(false)
 });
 var DEFAULT_ZERO_ROUTER_CONFIG = {
   thresholds: DEFAULT_DIFFICULTY_THRESHOLDS,
@@ -7706,9 +7732,9 @@ var ZeroRouter = class {
   logger;
   outcomes = [];
   calibrationBias = 0;
-  constructor(config, logger14) {
+  constructor(config, logger15) {
     this.config = ZeroRouterConfigSchema.parse(config ?? {});
-    this.logger = logger14 ?? createLogger({ component: "ZeroRouter" });
+    this.logger = logger15 ?? createLogger({ component: "ZeroRouter" });
     this.logger.debug("ZeroRouter initialized", {
       thresholds: this.config.thresholds,
       enableCalibration: this.config.enableCalibration
@@ -7890,16 +7916,16 @@ var ZeroRouter = class {
 };
 
 // src/cli-adapters/latency-tracker-types.ts
-import { z as z8 } from "zod";
-var LatencyTrackerConfigSchema = z8.object({
+import { z as z9 } from "zod";
+var LatencyTrackerConfigSchema = z9.object({
   /** Maximum number of samples to keep per CLI (default: 100) */
-  windowSize: z8.number().int().positive().default(100),
+  windowSize: z9.number().int().positive().default(100),
   /** Time-weighted decay factor (0-1, higher = more weight to recent) (default: 0.95) */
-  decayFactor: z8.number().min(0).max(1).default(0.95),
+  decayFactor: z9.number().min(0).max(1).default(0.95),
   /** Maximum age of samples in milliseconds before forced eviction (default: 3600000 = 1 hour) */
-  maxSampleAgeMs: z8.number().int().positive().default(36e5),
+  maxSampleAgeMs: z9.number().int().positive().default(36e5),
   /** Percentiles to calculate (default: [50, 95, 99]) */
-  percentiles: z8.array(z8.number().min(0).max(100)).default([50, 95, 99])
+  percentiles: z9.array(z9.number().min(0).max(100)).default([50, 95, 99])
 });
 var EMPTY_LATENCY_STATS = {
   count: 0,
@@ -8134,19 +8160,19 @@ var LatencyTracker = class {
 };
 
 // src/cli-adapters/routing/router-stage.ts
-import { z as z9 } from "zod";
-var StageConfigSchema = z9.object({
-  enabled: z9.boolean().default(true),
-  priority: z9.number().int().min(0).max(100).default(50),
-  options: z9.record(z9.string(), z9.unknown()).optional()
+import { z as z10 } from "zod";
+var StageConfigSchema = z10.object({
+  enabled: z10.boolean().default(true),
+  priority: z10.number().int().min(0).max(100).default(50),
+  options: z10.record(z10.string(), z10.unknown()).optional()
 });
-var RoutingOutcomeSchema = z9.object({
+var RoutingOutcomeSchema = z10.object({
   selectedCli: CliNameSchema,
-  task: z9.string(),
-  success: z9.boolean(),
-  qualityScore: z9.number().min(0).max(1).optional(),
-  latencyMs: z9.number().int().positive().optional(),
-  tokensUsed: z9.number().int().positive().optional()
+  task: z10.string(),
+  success: z10.boolean(),
+  qualityScore: z10.number().min(0).max(1).optional(),
+  latencyMs: z10.number().int().positive().optional(),
+  tokensUsed: z10.number().int().positive().optional()
 });
 function createRoutingContext(task, availableClis = ["claude", "gemini", "codex", "opencode"], metadata) {
   return {
@@ -8219,9 +8245,9 @@ var ConfidenceCascadeStage = class {
   routingsCount = 0;
   escalationCount = 0;
   complexityDistribution = { simple: 0, moderate: 0, complex: 0 };
-  constructor(config = {}, logger14) {
+  constructor(config = {}, logger15) {
     this.config = { ...DEFAULT_CONFIG, ...config };
-    this.logger = logger14 ?? createLogger({ component: "ConfidenceCascadeStage" });
+    this.logger = logger15 ?? createLogger({ component: "ConfidenceCascadeStage" });
   }
   canHandle(ctx) {
     return getRemainingCandidates(ctx).length > 0;
@@ -8370,9 +8396,9 @@ var CapabilityMatchStage = class {
     creative: 0,
     general: 0
   };
-  constructor(config = {}, logger14) {
+  constructor(config = {}, logger15) {
     this.config = { ...DEFAULT_CONFIG2, ...config };
-    this.logger = logger14 ?? createLogger({ component: "CapabilityMatchStage" });
+    this.logger = logger15 ?? createLogger({ component: "CapabilityMatchStage" });
   }
   canHandle(ctx) {
     return getRemainingCandidates(ctx).length > 0;
@@ -8528,9 +8554,9 @@ var QualityConstraintStage = class {
   filteredCount = 0;
   fallbackCount = 0;
   constraintViolations = { quality: 0, cost: 0, latency: 0 };
-  constructor(config = {}, logger14) {
+  constructor(config = {}, logger15) {
     this.config = { ...DEFAULT_CONFIG3, ...config };
-    this.logger = logger14 ?? createLogger({ component: "QualityConstraintStage" });
+    this.logger = logger15 ?? createLogger({ component: "QualityConstraintStage" });
   }
   canHandle(ctx) {
     return getRemainingCandidates(ctx).length > 0;
@@ -8728,9 +8754,9 @@ var ResourceStrategyStage = class {
   logger;
   routingsCount = 0;
   tierHistory = [];
-  constructor(config = {}, logger14) {
+  constructor(config = {}, logger15) {
     this.config = { ...DEFAULT_CONFIG4, ...config };
-    this.logger = logger14 ?? createLogger({ component: "ResourceStrategyStage" });
+    this.logger = logger15 ?? createLogger({ component: "ResourceStrategyStage" });
   }
   canHandle(ctx) {
     return getRemainingCandidates(ctx).length > 1;
@@ -8839,10 +8865,10 @@ var DistilledRuleStage = class {
   config;
   logger;
   rulesAppliedCount = 0;
-  constructor(distiller, config, logger14) {
+  constructor(distiller, config, logger15) {
     this.distiller = distiller;
     this.config = { ...DEFAULT_CONFIG5, ...config };
-    this.logger = logger14 ?? createLogger({ component: "DistilledRuleStage" });
+    this.logger = logger15 ?? createLogger({ component: "DistilledRuleStage" });
   }
   canHandle(ctx) {
     const candidates = getRemainingCandidates(ctx);
@@ -8981,10 +9007,10 @@ var KnnRoutingStage = class {
   memory;
   routingsCount = 0;
   matchCount = 0;
-  constructor(memory, config = {}, logger14) {
+  constructor(memory, config = {}, logger15) {
     this.config = { ...DEFAULT_CONFIG6, ...config };
     this.memory = memory;
-    this.logger = logger14 ?? createLogger({ component: "KnnRoutingStage" });
+    this.logger = logger15 ?? createLogger({ component: "KnnRoutingStage" });
   }
   canHandle(ctx) {
     return getRemainingCandidates(ctx).length > 0;
@@ -9199,10 +9225,10 @@ var StrategyDistiller = class {
   rules = /* @__PURE__ */ new Map();
   outcomeCounter = 0;
   lastDistillAt;
-  constructor(outcomeStore, logger14, config) {
+  constructor(outcomeStore, logger15, config) {
     this.outcomeStore = outcomeStore;
     this.config = { ...DEFAULT_DISTILLER_CONFIG, ...config };
-    this.logger = logger14 ?? createLogger({ component: "StrategyDistiller" });
+    this.logger = logger15 ?? createLogger({ component: "StrategyDistiller" });
   }
   /** Called for each processed outcome. Triggers distillation at threshold. */
   onOutcome() {
@@ -9366,25 +9392,25 @@ var StrategyDistiller = class {
     };
   }
 };
-function createStrategyDistiller(outcomeStore, logger14, config) {
-  return new StrategyDistiller(outcomeStore, logger14, config);
+function createStrategyDistiller(outcomeStore, logger15, config) {
+  return new StrategyDistiller(outcomeStore, logger15, config);
 }
 var persistentDistillerFactory;
 function registerPersistentDistillerFactory(factory) {
   persistentDistillerFactory = factory;
 }
-function createPersistentDistillerOrFallback(outcomeStore, logger14) {
+function createPersistentDistillerOrFallback(outcomeStore, logger15) {
   if (persistentDistillerFactory !== void 0) {
-    return persistentDistillerFactory(outcomeStore, logger14);
+    return persistentDistillerFactory(outcomeStore, logger15);
   }
-  return new StrategyDistiller(outcomeStore, logger14);
+  return new StrategyDistiller(outcomeStore, logger15);
 }
 
 // src/orchestration/outcomes/outcome-types.ts
-import { z as z10 } from "zod";
-var logger6 = createLogger({ component: "outcome-error-taxonomy" });
-var OutcomeSourceSchema = z10.enum(["delegate", "consensus", "manual"]);
-var OutcomeFailureCategorySchema = z10.enum([
+import { z as z11 } from "zod";
+var logger7 = createLogger({ component: "outcome-error-taxonomy" });
+var OutcomeSourceSchema = z11.enum(["delegate", "consensus", "manual"]);
+var OutcomeFailureCategorySchema = z11.enum([
   "timeout",
   "authentication",
   "rate_limit",
@@ -9397,37 +9423,37 @@ var OutcomeFailureCategorySchema = z10.enum([
   "generic",
   "unknown"
 ]);
-var OutcomeCliSchema = z10.union([CliNameSchema, z10.literal("unknown")]);
-var TaskOutcomeSchema = z10.object({
-  id: z10.string().min(1),
+var OutcomeCliSchema = z11.union([CliNameSchema, ApiArmIdSchema, z11.literal("unknown")]);
+var TaskOutcomeSchema = z11.object({
+  id: z11.string().min(1),
   cli: OutcomeCliSchema,
   category: TaskCategorySchema,
-  model: z10.string().min(1),
-  success: z10.boolean(),
-  durationMs: z10.number().nonnegative(),
-  timestamp: z10.string().min(1),
-  qualitySignals: z10.array(z10.string()).optional(),
+  model: z11.string().min(1),
+  success: z11.boolean(),
+  durationMs: z11.number().nonnegative(),
+  timestamp: z11.string().min(1),
+  qualitySignals: z11.array(z11.string()).optional(),
   failureCategory: OutcomeFailureCategorySchema.optional(),
-  errorMessage: z10.string().max(500).optional(),
+  errorMessage: z11.string().max(500).optional(),
   source: OutcomeSourceSchema,
   /** Whether this outcome came from a triage-initiated retry (#1506). */
-  wasRetried: z10.boolean().optional(),
+  wasRetried: z11.boolean().optional(),
   /** Triage action taken on the failure (#1506). */
-  triageAction: z10.string().max(30).optional(),
+  triageAction: z11.string().max(30).optional(),
   /** Routing stage that selected this CLI (#1785). */
-  routingStage: z10.string().max(50).optional(),
+  routingStage: z11.string().max(50).optional(),
   /** Number of retry attempts before this outcome (#1785). */
-  retryCount: z10.number().int().nonnegative().optional(),
+  retryCount: z11.number().int().nonnegative().optional(),
   /** Vendor resolved from `model` via ModelRegistry at write time (#2548). */
-  vendor: z10.string().min(1).max(40).optional(),
+  vendor: z11.string().min(1).max(40).optional(),
   /** Family resolved from `model` via ModelRegistry at write time (#2548). */
-  family: z10.string().min(1).max(80).optional(),
+  family: z11.string().min(1).max(80).optional(),
   /**
    * Voter role for `source: 'consensus'` outcomes (#2662) — `architect`,
    * `security`, etc. Absent on non-consensus outcomes. Lets the
    * stratified outcome report break results down by voter role.
    */
-  voterRole: z10.string().min(1).max(40).optional(),
+  voterRole: z11.string().min(1).max(40).optional(),
   /**
    * Baseline this outcome forked from (#2697 / Epic F follow-up to #2665).
    * Set on outcomes recorded inside a fork-then-merge graph branch so
@@ -9436,27 +9462,27 @@ var TaskOutcomeSchema = z10.object({
    * cohort. Free-form string (caller-assigned); typically the parent
    * node's `executionId` or `taskId`.
    */
-  baselineId: z10.string().min(1).max(64).optional(),
+  baselineId: z11.string().min(1).max(64).optional(),
   /**
    * Distributed trace id correlating this outcome across the pipeline (#3146).
    * Optional + backward-compatible: older JSONL records without it hydrate fine.
    */
-  traceId: z10.string().min(1).max(128).optional(),
+  traceId: z11.string().min(1).max(128).optional(),
   /** Request id correlating this outcome to its originating invocation (#3146). */
-  requestId: z10.string().min(1).max(128).optional()
+  requestId: z11.string().min(1).max(128).optional()
 });
-var OutcomeQuerySchema = z10.object({
+var OutcomeQuerySchema = z11.object({
   cli: OutcomeCliSchema.optional(),
   category: TaskCategorySchema.optional(),
   source: OutcomeSourceSchema.optional(),
-  success: z10.boolean().optional(),
+  success: z11.boolean().optional(),
   failureCategory: OutcomeFailureCategorySchema.optional(),
-  since: z10.string().optional(),
-  limit: z10.number().int().positive().optional(),
+  since: z11.string().optional(),
+  limit: z11.number().int().positive().optional(),
   /** Exclude outcomes with any of these quality signals (#1680). */
-  excludeQualitySignals: z10.array(z10.string()).optional(),
+  excludeQualitySignals: z11.array(z11.string()).optional(),
   /** Restrict to outcomes recorded against a specific baseline (#2697). */
-  baselineId: z10.string().min(1).max(64).optional()
+  baselineId: z11.string().min(1).max(64).optional()
 });
 var TIMEOUT_PATTERNS = ["timeout", "timed out", "deadline exceeded", "socket hang up", "aborted"];
 var AUTH_PATTERNS = [
@@ -9601,7 +9627,7 @@ function matchesAny(text, patterns) {
 function classifyExecutionOrGeneric(text) {
   if (matchesAny(text, EXECUTION_PATTERNS)) return "execution";
   if (matchesAny(text, GENERIC_PATTERNS)) return "generic";
-  logger6.debug("Unclassified error string", { sample: text.slice(0, 200) });
+  logger7.debug("Unclassified error string", { sample: text.slice(0, 200) });
   return "unknown";
 }
 function classifyText(text) {
@@ -9943,7 +9969,7 @@ function groupBy(outcomes, keyFn) {
 }
 
 // src/pipeline/event-bus.ts
-var logger7 = createLogger({ component: "EventBus" });
+var logger8 = createLogger({ component: "EventBus" });
 var DEFAULT_MAX_BUFFER = 1e4;
 var EventBus = class {
   buffer;
@@ -9997,7 +10023,7 @@ var EventBus = class {
         sub.handler(event);
       } catch (error) {
         const msg = getErrorMessage(error);
-        logger7.warn("Event handler error", { eventType: event.type, error: msg });
+        logger8.warn("Event handler error", { eventType: event.type, error: msg });
       }
     }
   }
@@ -10061,8 +10087,8 @@ function generateSyntheticPriors() {
   }
   return priors;
 }
-function runWarmUp(logger14) {
-  const log = logger14 ?? createLogger({ component: "warm-up" });
+function runWarmUp(logger15) {
+  const log = logger15 ?? createLogger({ component: "warm-up" });
   const store = getOutcomeStore();
   const existing = store.query();
   const hasSynthetic = existing.some((o) => o.qualitySignals?.includes(SYNTHETIC_MARKER) === true);
@@ -10106,58 +10132,58 @@ function runWarmUp(logger14) {
 }
 
 // src/cli-adapters/composite-router-types.ts
-import { z as z11 } from "zod";
-var CompositeRouterConfigSchema = z11.object({
+import { z as z12 } from "zod";
+var CompositeRouterConfigSchema = z12.object({
   /** Enable confidence cascade stage (default: false) (Issue #755, ADR-0005) */
-  enableConfidenceCascade: z11.boolean().default(false),
+  enableConfidenceCascade: z12.boolean().default(false),
   /** Enable budget filtering stage (default: true) */
-  enableBudgetFilter: z11.boolean().default(true),
+  enableBudgetFilter: z12.boolean().default(true),
   /** Enable capability match stage (default: false) (Issue #755, ADR-0005) */
-  enableCapabilityMatch: z11.boolean().default(false),
+  enableCapabilityMatch: z12.boolean().default(false),
   /** Enable ZeroRouter difficulty-based routing stage (default: true) (Issue #473) */
-  enableZeroRouter: z11.boolean().default(true),
+  enableZeroRouter: z12.boolean().default(true),
   /** Enable preference-trained routing stage (default: false) */
-  enablePreferenceRouting: z11.boolean().default(false),
+  enablePreferenceRouting: z12.boolean().default(false),
   /** Enable TOPSIS ranking stage (default: true) */
-  enableTopsisRanking: z11.boolean().default(true),
+  enableTopsisRanking: z12.boolean().default(true),
   /** Enable LinUCB selection stage (default: true) */
-  enableLinUCBSelection: z11.boolean().default(true),
+  enableLinUCBSelection: z12.boolean().default(true),
   /** Enable quality constraint stage (default: false) (Issue #755, ADR-0005) */
-  enableQualityConstraint: z11.boolean().default(false),
+  enableQualityConstraint: z12.boolean().default(false),
   /** Enable resource strategy stage for budget-aware oscillation (default: true) (Issue #998) */
-  enableResourceStrategy: z11.boolean().default(true),
+  enableResourceStrategy: z12.boolean().default(true),
   /** Enable strategy distillation for learned routing rules (default: false) (Issue #999) */
-  enableStrategyDistillation: z11.boolean().default(false),
+  enableStrategyDistillation: z12.boolean().default(false),
   /** Enable latency tracking for routing decisions (default: true) (Issue #361) */
-  enableLatencyTracking: z11.boolean().default(true),
+  enableLatencyTracking: z12.boolean().default(true),
   /** Enable routing memory for learned routing (default: false) (Issue #463, #461) */
-  enableRoutingMemory: z11.boolean().default(false),
+  enableRoutingMemory: z12.boolean().default(false),
   /** Enable KNN experience-based routing (default: false) (arXiv:2505.12601) */
-  enableKnnRouting: z11.boolean().default(false),
+  enableKnnRouting: z12.boolean().default(false),
   /** Weight for latency score in final routing (0-1, default: 0.2) */
-  latencyScoreWeight: z11.number().min(0).max(1).default(0.2),
+  latencyScoreWeight: z12.number().min(0).max(1).default(0.2),
   /** Budget constraints (optional) */
-  budgetConstraints: z11.object({
-    maxTokens: z11.number().positive(),
-    maxCostUsd: z11.number().positive(),
-    maxLatencyMs: z11.number().positive(),
+  budgetConstraints: z12.object({
+    maxTokens: z12.number().positive(),
+    maxCostUsd: z12.number().positive(),
+    maxLatencyMs: z12.number().positive(),
     /** Per-task-class cost ceilings in USD, keyed by TaskCategory (#4196).
      * Keys are validated against the TaskCategory enum (#4214) so a typo'd
      * class fails config parsing instead of silently configuring nothing.
      * Default: absent → no ceiling (OFF/unlimited). Enforced only under
      * billingMode 'api'; missing candidate pricing fails CLOSED. */
-    taskClassMaxCostUsd: z11.partialRecord(TaskCategorySchema, z11.number().positive())
+    taskClassMaxCostUsd: z12.partialRecord(TaskCategorySchema, z12.number().positive())
   }).partial().optional(),
   /** LinUCB exploration parameter (default: 1.0) */
-  linucbAlpha: z11.number().positive().default(1),
+  linucbAlpha: z12.number().positive().default(1),
   /** Billing mode: 'plan' zeroes cost weight, 'api' preserves current behavior (default: 'plan') */
-  billingMode: z11.enum(["plan", "api"]).default("plan"),
+  billingMode: z12.enum(["plan", "api"]).default("plan"),
   /** Enable capacity-aware load balancing (deprioritize exhausted CLIs) (default: true) (Issue #807) */
-  enableCapacityBalancing: z11.boolean().default(true),
+  enableCapacityBalancing: z12.boolean().default(true),
   /** Maximum routing decision time in ms (default: 50) */
-  maxDecisionTimeMs: z11.number().positive().default(50),
+  maxDecisionTimeMs: z12.number().positive().default(50),
   /** Minimum preference data points before using learned routing (default: 10) */
-  preferenceMinDataPoints: z11.number().int().positive().default(10)
+  preferenceMinDataPoints: z12.number().int().positive().default(10)
 });
 var DEFAULT_COMPOSITE_CONFIG = {
   enableConfidenceCascade: false,
@@ -10566,12 +10592,12 @@ All defaults can be overridden via environment variables using the NEXUS_ prefix
 }
 
 // src/mcp/tools/weather-report-types.ts
-import { z as z12 } from "zod";
-var WeatherReportInputSchema = z12.object({
+import { z as z13 } from "zod";
+var WeatherReportInputSchema = z13.object({
   /** Filter by CLI name. */
-  cli: z12.enum(CLI_NAMES).optional().describe("Filter by CLI"),
+  cli: z13.enum(CLI_NAMES).optional().describe("Filter by CLI"),
   /** Filter by task category. */
-  category: z12.enum([
+  category: z13.enum([
     "architecture",
     "code_generation",
     "code_review",
@@ -10584,22 +10610,22 @@ var WeatherReportInputSchema = z12.object({
     "exploration"
   ]).optional().describe("Filter by task category"),
   /** Include adaptive routing bonus data. */
-  includeAdaptive: z12.boolean().optional().default(true).describe("Include adaptive routing bonuses (default: true)")
+  includeAdaptive: z13.boolean().optional().default(true).describe("Include adaptive routing bonuses (default: true)")
 });
 var DEFAULT_OUTCOME_LOOKBACK_MS = 7 * 24 * 60 * 60 * 1e3;
-var WeatherReportConfigSchema = z12.object({
+var WeatherReportConfigSchema = z13.object({
   /** Minimum observations before adjusting bonuses (lowered for faster activation). */
-  coldStartThreshold: z12.number().int().min(1).max(1e3).default(3),
+  coldStartThreshold: z13.number().int().min(1).max(1e3).default(3),
   /** Exploration rate: fraction of random routing (0.0-1.0). */
-  explorationRate: z12.number().min(0).max(1).default(0.1),
+  explorationRate: z13.number().min(0).max(1).default(0.1),
   /** Max adaptive bonus adjustment (+/-). */
-  maxBonusAdjustment: z12.number().min(0).max(20).default(10),
+  maxBonusAdjustment: z13.number().min(0).max(20).default(10),
   /**
    * Lookback window for outcome queries (ms). Only outcomes within this
    * window are used for adaptive bonuses. Falls back to all history if
    * the window has fewer samples than coldStartThreshold. Default: 7 days.
    */
-  outcomeLookbackMs: z12.number().int().min(0).default(DEFAULT_OUTCOME_LOOKBACK_MS)
+  outcomeLookbackMs: z13.number().int().min(0).default(DEFAULT_OUTCOME_LOOKBACK_MS)
 });
 function createDefaultWeatherConfig() {
   return WeatherReportConfigSchema.parse({});
@@ -10985,47 +11011,47 @@ function createMetricsMiddleware() {
 import { randomBytes as randomBytes3 } from "crypto";
 
 // src/config/defaults-types.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 function isKnownCliName(cli) {
   return cli === "claude" || cli === "gemini" || cli === "codex" || cli === "opencode" || cli === "default";
 }
-var positiveInt = z13.number().int().positive();
-var nonNegativeInt = z13.number().int().nonnegative();
-var durationMs = z13.number().int().positive().describe("Duration in milliseconds");
-var TimeoutProfileSchema = z13.object({
+var positiveInt = z14.number().int().positive();
+var nonNegativeInt = z14.number().int().nonnegative();
+var durationMs = z14.number().int().positive().describe("Duration in milliseconds");
+var TimeoutProfileSchema = z14.object({
   simple: durationMs.describe("Timeout for simple tasks"),
   standard: durationMs.describe("Timeout for standard tasks"),
   complex: durationMs.describe("Timeout for complex tasks")
 });
-var RetryDefaultsSchema = z13.object({
+var RetryDefaultsSchema = z14.object({
   maxRetries: nonNegativeInt.max(10).describe("Maximum retry attempts"),
   baseDelayMs: durationMs.describe("Base delay between retries"),
   maxDelayMs: durationMs.describe("Maximum delay between retries"),
-  jitterFactor: z13.number().min(0).max(1).describe("Jitter factor (0-1)")
+  jitterFactor: z14.number().min(0).max(1).describe("Jitter factor (0-1)")
 });
-var RateLimitDefaultsSchema = z13.object({
+var RateLimitDefaultsSchema = z14.object({
   requestsPerMinute: positiveInt.max(1e3).describe("Max requests per minute"),
-  enabled: z13.boolean().describe("Whether rate limiting is enabled"),
+  enabled: z14.boolean().describe("Whether rate limiting is enabled"),
   maxConcurrent: positiveInt.max(100).describe("Max concurrent requests"),
   capacity: positiveInt.describe("Token bucket capacity"),
   refillRate: positiveInt.describe("Token refill rate"),
   refillIntervalMs: durationMs.describe("Token refill interval")
 });
-var CircuitBreakerDefaultsSchema = z13.object({
-  failureThreshold: z13.number().int().min(1).max(100).describe("Failures before opening"),
+var CircuitBreakerDefaultsSchema = z14.object({
+  failureThreshold: z14.number().int().min(1).max(100).describe("Failures before opening"),
   resetTimeoutMs: durationMs.describe("Time before attempting reset"),
-  halfOpenSuccessThreshold: z13.number().int().min(1).max(10).describe("Successes to close"),
-  countTimeoutsAsFailures: z13.boolean().describe("Count timeouts as failures"),
-  countAuthFailuresAsFailures: z13.boolean().describe("Count auth failures as failures"),
-  countRateLimitsAsFailures: z13.boolean().describe("Count rate limit errors as failures"),
+  halfOpenSuccessThreshold: z14.number().int().min(1).max(10).describe("Successes to close"),
+  countTimeoutsAsFailures: z14.boolean().describe("Count timeouts as failures"),
+  countAuthFailuresAsFailures: z14.boolean().describe("Count auth failures as failures"),
+  countRateLimitsAsFailures: z14.boolean().describe("Count rate limit errors as failures"),
   halfOpenMaxRequests: positiveInt.describe("Max requests in half-open state")
 });
-var ToolRateLimitConfigSchema = z13.object({
+var ToolRateLimitConfigSchema = z14.object({
   capacity: positiveInt.describe("Token bucket capacity"),
   refillRate: positiveInt.describe("Token refill rate"),
   refillIntervalMs: durationMs.describe("Token refill interval")
 });
-var TimeoutDefaultsSchema = z13.object({
+var TimeoutDefaultsSchema = z14.object({
   cliMs: durationMs.describe("Default CLI timeout"),
   // cliSimpleMs / cliComplexMs removed in #4180 — see config/defaults.ts.
   apiMs: durationMs.describe("Default API timeout"),
@@ -11638,7 +11664,7 @@ function aggregateDecisionCosts(records, windowMs) {
 }
 
 // src/observability/decision-cost-store.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // src/config/jsonl-store.ts
 import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
@@ -11773,36 +11799,36 @@ var JsonlStore = class {
 };
 
 // src/observability/decision-cost.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var UNKNOWN_MODEL = "unknown";
-var DecisionCostSummarySchema = z14.object({
-  billingMode: z14.enum(["plan", "api"]),
-  voterCount: z14.number(),
-  measuredVoters: z14.number(),
-  unmeasuredVoters: z14.number(),
-  totalInputTokens: z14.number(),
-  totalOutputTokens: z14.number(),
-  totalTokens: z14.number(),
-  totalCostUsd: z14.number(),
-  perVoter: z14.array(
-    z14.object({
-      role: z14.string(),
-      model: z14.string(),
-      inputTokens: z14.number(),
-      outputTokens: z14.number(),
-      totalTokens: z14.number(),
-      costUsd: z14.number(),
-      unmeasured: z14.boolean()
+var DecisionCostSummarySchema = z15.object({
+  billingMode: z15.enum(["plan", "api"]),
+  voterCount: z15.number(),
+  measuredVoters: z15.number(),
+  unmeasuredVoters: z15.number(),
+  totalInputTokens: z15.number(),
+  totalOutputTokens: z15.number(),
+  totalTokens: z15.number(),
+  totalCostUsd: z15.number(),
+  perVoter: z15.array(
+    z15.object({
+      role: z15.string(),
+      model: z15.string(),
+      inputTokens: z15.number(),
+      outputTokens: z15.number(),
+      totalTokens: z15.number(),
+      costUsd: z15.number(),
+      unmeasured: z15.boolean()
     })
   ),
-  perModel: z14.array(
-    z14.object({
-      model: z14.string(),
-      voterCount: z14.number(),
-      inputTokens: z14.number(),
-      outputTokens: z14.number(),
-      totalTokens: z14.number(),
-      costUsd: z14.number()
+  perModel: z15.array(
+    z15.object({
+      model: z15.string(),
+      voterCount: z15.number(),
+      inputTokens: z15.number(),
+      outputTokens: z15.number(),
+      totalTokens: z15.number(),
+      costUsd: z15.number()
     })
   )
 });
@@ -11877,43 +11903,43 @@ function buildPerModelBreakdowns(modelAcc) {
 }
 
 // src/observability/decision-cost-store.ts
-var DecisionGateSchema = z15.enum(["consensus_vote", "pr_review"]);
-var VoterCostBreakdownSchema = z15.object({
-  role: z15.string().min(1).max(64),
-  model: z15.string().min(1).max(120),
-  inputTokens: z15.number().int().nonnegative(),
-  outputTokens: z15.number().int().nonnegative(),
-  totalTokens: z15.number().int().nonnegative(),
-  costUsd: z15.number().nonnegative(),
-  unmeasured: z15.boolean()
+var DecisionGateSchema = z16.enum(["consensus_vote", "pr_review"]);
+var VoterCostBreakdownSchema = z16.object({
+  role: z16.string().min(1).max(64),
+  model: z16.string().min(1).max(120),
+  inputTokens: z16.number().int().nonnegative(),
+  outputTokens: z16.number().int().nonnegative(),
+  totalTokens: z16.number().int().nonnegative(),
+  costUsd: z16.number().nonnegative(),
+  unmeasured: z16.boolean()
 });
-var ModelCostBreakdownSchema = z15.object({
-  model: z15.string().min(1).max(120),
-  voterCount: z15.number().int().nonnegative(),
-  inputTokens: z15.number().int().nonnegative(),
-  outputTokens: z15.number().int().nonnegative(),
-  totalTokens: z15.number().int().nonnegative(),
-  costUsd: z15.number().nonnegative()
+var ModelCostBreakdownSchema = z16.object({
+  model: z16.string().min(1).max(120),
+  voterCount: z16.number().int().nonnegative(),
+  inputTokens: z16.number().int().nonnegative(),
+  outputTokens: z16.number().int().nonnegative(),
+  totalTokens: z16.number().int().nonnegative(),
+  costUsd: z16.number().nonnegative()
 });
-var DecisionCostSummarySchema2 = z15.object({
-  billingMode: z15.enum(["plan", "api"]),
-  voterCount: z15.number().int().nonnegative(),
-  measuredVoters: z15.number().int().nonnegative(),
-  unmeasuredVoters: z15.number().int().nonnegative(),
-  totalInputTokens: z15.number().int().nonnegative(),
-  totalOutputTokens: z15.number().int().nonnegative(),
-  totalTokens: z15.number().int().nonnegative(),
-  totalCostUsd: z15.number().nonnegative(),
-  perVoter: z15.array(VoterCostBreakdownSchema).readonly(),
-  perModel: z15.array(ModelCostBreakdownSchema).readonly()
+var DecisionCostSummarySchema2 = z16.object({
+  billingMode: z16.enum(["plan", "api"]),
+  voterCount: z16.number().int().nonnegative(),
+  measuredVoters: z16.number().int().nonnegative(),
+  unmeasuredVoters: z16.number().int().nonnegative(),
+  totalInputTokens: z16.number().int().nonnegative(),
+  totalOutputTokens: z16.number().int().nonnegative(),
+  totalTokens: z16.number().int().nonnegative(),
+  totalCostUsd: z16.number().nonnegative(),
+  perVoter: z16.array(VoterCostBreakdownSchema).readonly(),
+  perModel: z16.array(ModelCostBreakdownSchema).readonly()
 });
-var DecisionCostRecordSchema = z15.object({
+var DecisionCostRecordSchema = z16.object({
   /** Stable id for the decision (correlation id / jobId / minted decision id). */
-  decisionId: z15.string().min(1).max(160),
+  decisionId: z16.string().min(1).max(160),
   /** Which gate type incurred the cost. */
   gate: DecisionGateSchema,
   /** ISO 8601 timestamp the rollup was recorded. */
-  timestamp: z15.string().min(1).max(40),
+  timestamp: z16.string().min(1).max(40),
   /** The rolled-up cost summary. */
   summary: DecisionCostSummarySchema2
 });
@@ -11973,7 +11999,7 @@ var DecisionCostStore = class {
 // src/orchestration/strategy-manifest.ts
 import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
 import { parse as parseYaml2 } from "yaml";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var STRATEGY_MANIFEST_SCHEMA_VERSION = 1;
 var EXECUTION_STRATEGY_NAMES = [
   "single-shot",
@@ -11985,41 +12011,41 @@ var EXECUTION_STRATEGY_NAMES = [
   "spec",
   "research"
 ];
-var StrategyNameSchema = z16.enum(EXECUTION_STRATEGY_NAMES);
-var AuthorityTierSchema = z16.enum(["observe", "suggest", "advisory", "enforce"]);
-var PromotionEvidenceSchema = z16.object({
+var StrategyNameSchema = z17.enum(EXECUTION_STRATEGY_NAMES);
+var AuthorityTierSchema = z17.enum(["observe", "suggest", "advisory", "enforce"]);
+var PromotionEvidenceSchema = z17.object({
   /** The loop/strategy being promoted (manifest `id`). */
-  loopId: z16.string().min(1),
+  loopId: z17.string().min(1),
   /** Current tier before promotion. */
   fromTier: AuthorityTierSchema,
   /** Target tier; must be exactly one step up (checked by the gate). */
   toTier: AuthorityTierSchema,
   /** Number of independent, judged evaluations behind the metric. */
-  evalN: z16.number().int().nonnegative(),
+  evalN: z17.number().int().nonnegative(),
   /** Precision on judged output (0–1); required for advisory+ promotions. */
-  precision: z16.number().min(0).max(1).optional(),
+  precision: z17.number().min(0).max(1).optional(),
   /** Recall (0–1); required for enforce promotions (missed-action cost). */
-  recall: z16.number().min(0).max(1).optional(),
+  recall: z17.number().min(0).max(1).optional(),
   /** The loop-specific promotion metric: name, value, and CI bounds. */
-  primaryMetric: z16.object({
-    name: z16.string().min(1),
-    value: z16.number(),
-    ci: z16.tuple([z16.number(), z16.number()])
+  primaryMetric: z17.object({
+    name: z17.string().min(1),
+    value: z17.number(),
+    ci: z17.tuple([z17.number(), z17.number()])
   }).strict(),
   /** ISO-8601 duration of soak at the lower tier with no intervention. */
-  soakDuration: z16.string().regex(/^P/, "soakDuration must be an ISO-8601 duration (e.g. P30D)"),
+  soakDuration: z17.string().regex(/^P/, "soakDuration must be an ISO-8601 duration (e.g. P30D)"),
   /** Confounders the primaryMetric controls for. */
-  controlledFor: z16.array(z16.string()).optional(),
+  controlledFor: z17.array(z17.string()).optional(),
   /** The recorded consensus_vote ref that ratifies the promotion. */
-  ratificationVote: z16.string().min(1),
+  ratificationVote: z17.string().min(1),
   /** Link to the measurement surface / report that produced the numbers. */
-  evidenceUri: z16.string().min(1)
+  evidenceUri: z17.string().min(1)
 }).strict();
-var PromotionEvidenceLedgerSchema = z16.object({
-  version: z16.number().int().positive(),
-  evidence: z16.array(PromotionEvidenceSchema)
+var PromotionEvidenceLedgerSchema = z17.object({
+  version: z17.number().int().positive(),
+  evidence: z17.array(PromotionEvidenceSchema)
 }).strict();
-var LatencyClassSchema = z16.enum([
+var LatencyClassSchema = z17.enum([
   "interactive",
   "single-llm",
   "multi-llm-panel",
@@ -12027,9 +12053,9 @@ var LatencyClassSchema = z16.enum([
   "network-fetch",
   "async-job-body"
 ]);
-var MaturityTierSchema = z16.enum(["experimental", "beta", "stable"]);
-var CostProfileSchema = z16.enum(["low", "medium", "high", "variable"]);
-var WorkflowPatternSchema = z16.enum([
+var MaturityTierSchema = z17.enum(["experimental", "beta", "stable"]);
+var CostProfileSchema = z17.enum(["low", "medium", "high", "variable"]);
+var WorkflowPatternSchema = z17.enum([
   "sequential",
   "wave",
   "graph",
@@ -12037,34 +12063,34 @@ var WorkflowPatternSchema = z16.enum([
   "aflow",
   "puppeteer"
 ]);
-var PipelineTypeSchema = z16.enum(["dev", "research", "audit", "greenfield", "general"]);
-var ComplexityTierSchema = z16.enum(["simple", "moderate", "complex", "expert"]);
-var SelectionRuleSchema = z16.object({
+var PipelineTypeSchema = z17.enum(["dev", "research", "audit", "greenfield", "general"]);
+var ComplexityTierSchema = z17.enum(["simple", "moderate", "complex", "expert"]);
+var SelectionRuleSchema = z17.object({
   /** Higher wins. Distinctive templates outrank the structural-pattern fallback. */
-  priority: z16.number().int(),
+  priority: z17.number().int(),
   /** Matches only when the routed workflow pattern is one of these. */
-  patterns: z16.array(WorkflowPatternSchema).min(1).optional(),
+  patterns: z17.array(WorkflowPatternSchema).min(1).optional(),
   /** Matches only when the classified pipeline template is one of these. */
-  pipelineTypes: z16.array(PipelineTypeSchema).min(1).optional(),
+  pipelineTypes: z17.array(PipelineTypeSchema).min(1).optional(),
   /** Matches only when the analyzed complexity is one of these. */
-  complexities: z16.array(ComplexityTierSchema).min(1).optional()
+  complexities: z17.array(ComplexityTierSchema).min(1).optional()
 }).strict().refine((r) => r.patterns !== void 0 || r.pipelineTypes !== void 0, {
   message: "a selection rule must constrain at least patterns or pipelineTypes"
 });
-var StrategyManifestSchema = z16.object({
+var StrategyManifestSchema = z17.object({
   /**
    * Stable kebab-case identifier; never reused. For the initial 8 this equals
    * the strategy name, but `id` is a distinct field so future strategies can
    * carry a more specific id without colliding with the {@link StrategyName}
    * enum.
    */
-  id: z16.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case"),
+  id: z17.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case"),
   /**
    * The manifest-shape version this entry was authored against. Must equal
    * {@link STRATEGY_MANIFEST_SCHEMA_VERSION}; a mismatch fails closed so a
    * manifest written for a future shape is never misread.
    */
-  schemaVersion: z16.literal(STRATEGY_MANIFEST_SCHEMA_VERSION),
+  schemaVersion: z17.literal(STRATEGY_MANIFEST_SCHEMA_VERSION),
   /** The execution strategy this manifest describes (router enum). */
   strategy: StrategyNameSchema,
   /**
@@ -12072,7 +12098,7 @@ var StrategyManifestSchema = z16.object({
    * force-strategy entry point (generalizes `STRATEGY_ENTRYPOINT_TOOL`,
    * run-tool.ts). Non-empty.
    */
-  entrypointTool: z16.string().min(1),
+  entrypointTool: z17.string().min(1),
   /**
    * Whether a wired executor exists for this strategy (run-tool.ts
    * `buildDefaultExecutors`). FAIL-CLOSED routing key: only 4/8 are `true`
@@ -12086,15 +12112,15 @@ var StrategyManifestSchema = z16.object({
    * (#3881), so declaring `true` for a strategy with no wired executor (silent
    * fail-OPEN) fails the build rather than mis-advertising routability.
    */
-  executorAvailable: z16.boolean(),
+  executorAvailable: z17.boolean(),
   /** One-line human description of what this strategy is for (#3838 docs). */
-  description: z16.string().min(1),
+  description: z17.string().min(1),
   /**
    * Guidance on when to FORCE this strategy via `run({ forceStrategy })` —
    * the escape-hatch docs surfaced in #3838. Optional: the router selects by
    * capability; this is operator guidance, not a routing input.
    */
-  whenToForce: z16.string().min(1).optional(),
+  whenToForce: z17.string().min(1).optional(),
   /** Maturity tier; defaults are not assumed — author states it explicitly. */
   maturityTier: MaturityTierSchema,
   /** Expected latency class (#3734 taxonomy). */
@@ -12118,11 +12144,11 @@ var StrategyManifestSchema = z16.object({
    * no claim on any signal). Each rule is a {@link SelectionRule}; the router
    * applies the highest-priority matching rule across the whole registry.
    */
-  selectionRules: z16.array(SelectionRuleSchema).min(1).optional()
+  selectionRules: z17.array(SelectionRuleSchema).min(1).optional()
 }).strict();
-var StrategyManifestRegistrySchema = z16.object({
-  version: z16.number().int().positive(),
-  manifests: z16.array(StrategyManifestSchema).min(1).superRefine((manifests, ctx) => {
+var StrategyManifestRegistrySchema = z17.object({
+  version: z17.number().int().positive(),
+  manifests: z17.array(StrategyManifestSchema).min(1).superRefine((manifests, ctx) => {
     const seenIds = /* @__PURE__ */ new Set();
     const seenStrategies = /* @__PURE__ */ new Set();
     for (const [i, m] of manifests.entries()) {
@@ -12911,14 +12937,14 @@ function buildTierRecommendations(summary) {
 }
 
 // src/cli-adapters/weather-bonus-stage.ts
-var logger8 = createLogger({ component: "weather-bonus-stage" });
+var logger9 = createLogger({ component: "weather-bonus-stage" });
 var MIN_SAMPLE_COUNT = 5;
 function getWeatherBonusScores(taskCategory) {
   try {
     const report = generateWeatherReport({ includeAdaptive: true });
     return convertBonusesToScoreMap(report.adaptiveBonuses, taskCategory);
   } catch {
-    logger8.debug("Weather bonus stage skipped (best-effort)");
+    logger9.debug("Weather bonus stage skipped (best-effort)");
     return /* @__PURE__ */ new Map();
   }
 }
@@ -12931,7 +12957,7 @@ function convertBonusesToScoreMap(bonuses, taskCategory) {
     scores.set(bonus.cli, bonus.adaptiveBonus);
   }
   if (scores.size > 0) {
-    logger8.debug("Weather bonus scores applied", {
+    logger9.debug("Weather bonus scores applied", {
       category: taskCategory,
       clis: [...scores.keys()]
     });
@@ -12940,9 +12966,9 @@ function convertBonusesToScoreMap(bonuses, taskCategory) {
 }
 
 // src/cli-adapters/fallback-chains.ts
-import { z as z17 } from "zod";
-var FallbackChainSchema = z17.array(z17.enum(["claude", "gemini", "codex", "opencode"])).min(1).readonly();
-var FallbackChainRegistrySchema = z17.object({
+import { z as z18 } from "zod";
+var FallbackChainSchema = z18.array(z18.enum(["claude", "gemini", "codex", "opencode"])).min(1).readonly();
+var FallbackChainRegistrySchema = z18.object({
   code: FallbackChainSchema,
   research: FallbackChainSchema,
   documentation: FallbackChainSchema,
@@ -12984,7 +13010,7 @@ function getFallbackChainForCategory(category, bucketType, registry = DEFAULT_FA
 }
 
 // src/cli-adapters/composite-router-stages.ts
-var logger9 = createLogger({ component: "composite-router-stages" });
+var logger10 = createLogger({ component: "composite-router-stages" });
 var sharedAnalyzer2 = createSharedTaskAnalyzer();
 function armsToSlots(candidates) {
   return [...new Set(candidates.map(routingArmDisplaySlot))];
@@ -13199,7 +13225,7 @@ function getPerformanceDataForCategory(taskContent) {
     }
     return result;
   } catch (error) {
-    logger9.debug("Performance-floor outcome-store read failed; skipping penalty", {
+    logger10.debug("Performance-floor outcome-store read failed; skipping penalty", {
       error: error instanceof Error ? error.message : String(error)
     });
     return /* @__PURE__ */ new Map();
@@ -13377,7 +13403,7 @@ function getWeatherBonusForTask(taskContent) {
     if (match === null) return /* @__PURE__ */ new Map();
     return getWeatherBonusScores(match.category);
   } catch (error) {
-    logger9.debug("Weather bonus outcome-store read failed; skipping bonus", {
+    logger10.debug("Weather bonus outcome-store read failed; skipping bonus", {
       error: error instanceof Error ? error.message : String(error)
     });
     return /* @__PURE__ */ new Map();
@@ -13403,7 +13429,7 @@ function applyCategoryOverride(task, candidates, stagesExecuted) {
   if (filtered.length === 0) {
     if (isCategoryFailClosed(match.category)) {
       stagesExecuted.push("category-override:fail-closed");
-      logger9.warn("Category override fail-closed \u2014 every override CLI unavailable", {
+      logger10.warn("Category override fail-closed \u2014 every override CLI unavailable", {
         category: match.category,
         override,
         availableCandidates: candidates
@@ -13528,7 +13554,7 @@ function selectWithMemoryInfluence(linucbSelection, memoryResult, deps) {
 }
 
 // src/config/available-models-cache.ts
-var logger10 = createLogger({ component: "available-models-cache" });
+var logger11 = createLogger({ component: "available-models-cache" });
 var DEFAULT_TTL_MS = 5 * 60 * 1e3;
 var DEFAULT_STALE_TTL_MS = 25 * 60 * 1e3;
 var AvailableModelsCache = class {
@@ -13636,7 +13662,7 @@ var AvailableModelsCache = class {
       state.fetchedAt = this.now();
       return value;
     } catch (e) {
-      logger10.warn("AvailableModelsCache source probe failed", {
+      logger11.warn("AvailableModelsCache source probe failed", {
         source: source.name,
         error: e instanceof Error ? e.message : String(e)
       });
@@ -13671,29 +13697,29 @@ function setDefaultAvailableModelsCache(cache) {
 }
 
 // src/config/openrouter-models-source.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
 var DEFAULT_TIMEOUT_MS = 8e3;
 var MAX_MODELS = 5e3;
 var MAX_BYTES = 8e6;
 var MAX_SUPPORTED_PARAMETERS = 256;
-var OpenRouterModelSchema = z18.object({
-  id: z18.string().min(1).max(256),
+var OpenRouterModelSchema = z19.object({
+  id: z19.string().min(1).max(256),
   // #4121: the provider's machine-readable capability list. Optional & additive —
   // older catalogs (and our older fixtures) omit it; consumers reading only `.id`
   // are unaffected. Bounded so a hostile payload can't blow memory.
-  supported_parameters: z18.array(z18.string().max(256)).max(MAX_SUPPORTED_PARAMETERS).optional()
+  supported_parameters: z19.array(z19.string().max(256)).max(MAX_SUPPORTED_PARAMETERS).optional()
 });
-var OpenRouterModelsResponseSchema = z18.object({ data: z18.array(OpenRouterModelSchema) });
-var logger11 = createLogger({ component: "openrouter-models-source" });
+var OpenRouterModelsResponseSchema = z19.object({ data: z19.array(OpenRouterModelSchema) });
+var logger12 = createLogger({ component: "openrouter-models-source" });
 function parseCatalog(text) {
   if (text.length > MAX_BYTES) {
-    logger11.warn("OpenRouter catalog exceeds byte cap; ignoring", { bytes: text.length });
+    logger12.warn("OpenRouter catalog exceeds byte cap; ignoring", { bytes: text.length });
     return [];
   }
   const parsed = OpenRouterModelsResponseSchema.safeParse(JSON.parse(text));
   if (!parsed.success) {
-    logger11.warn("OpenRouter catalog failed schema validation; treating as empty", {
+    logger12.warn("OpenRouter catalog failed schema validation; treating as empty", {
       error: parsed.error.message
     });
     return [];
@@ -13713,23 +13739,23 @@ async function fetchCatalog(url, timeoutMs, doFetch) {
       headers: { accept: "application/json" }
     });
     if (!res.ok) {
-      logger11.warn("OpenRouter catalog fetch returned non-OK; treating as empty", {
+      logger12.warn("OpenRouter catalog fetch returned non-OK; treating as empty", {
         status: res.status
       });
       return [];
     }
     const declaredLen = res.headers.get("content-length");
     if (declaredLen !== null && Number(declaredLen) > MAX_BYTES) {
-      logger11.warn("OpenRouter catalog Content-Length exceeds byte cap; ignoring", {
+      logger12.warn("OpenRouter catalog Content-Length exceeds byte cap; ignoring", {
         bytes: declaredLen
       });
       return [];
     }
     const ids = parseCatalog(await res.text());
-    logger11.debug("OpenRouter catalog loaded", { count: ids.length });
+    logger12.debug("OpenRouter catalog loaded", { count: ids.length });
     return ids;
   } catch (error) {
-    logger11.warn("OpenRouter catalog fetch failed; treating as empty", {
+    logger12.warn("OpenRouter catalog fetch failed; treating as empty", {
       error: error instanceof Error ? error.message : String(error)
     });
     return [];
@@ -13749,7 +13775,7 @@ function createOpenRouterModelsSource(opts = {}) {
 }
 
 // src/config/register-model-sources.ts
-var logger12 = createLogger({ component: "register-model-sources" });
+var logger13 = createLogger({ component: "register-model-sources" });
 function isDynamicModelsEnabled() {
   return process.env["NEXUS_DYNAMIC_MODELS"] === "true";
 }
@@ -13760,7 +13786,7 @@ function adapterSource(cliName, adapter) {
   return {
     name: cliName,
     listModels: () => adapter.listModels().then((models) => models.map((m) => ({ id: m.id }))).catch((error) => {
-      logger12.debug("adapter listModels failed; treating as empty", {
+      logger13.debug("adapter listModels failed; treating as empty", {
         cli: cliName,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -13823,32 +13849,32 @@ function resolveModelForTier(cliName, tier, opts = {}) {
 
 // src/cli-adapters/model-selection-shadow.ts
 import { appendFileSync as appendFileSync2, existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 function isRouteModelShadowEnabled() {
   return process.env["NEXUS_ROUTE_MODEL_SHADOW"] === "1" && isPersistenceEnabled();
 }
 var MODEL_SELECTION_SHADOW_SCHEMA_VERSION = 1;
 var READ_LOOKBACK_DAYS = 30;
 var READ_LOOKBACK_MS = READ_LOOKBACK_DAYS * 24 * 60 * 60 * 1e3;
-var ModelTierSchema = z19.enum(["fast", "balanced", "powerful"]);
-var ModelSelectionShadowRecordSchema = z19.object({
-  schema: z19.literal(MODEL_SELECTION_SHADOW_SCHEMA_VERSION),
+var ModelTierSchema = z20.enum(["fast", "balanced", "powerful"]);
+var ModelSelectionShadowRecordSchema = z20.object({
+  schema: z20.literal(MODEL_SELECTION_SHADOW_SCHEMA_VERSION),
   /** ISO timestamp of the outcome join. */
-  timestamp: z19.string().min(1),
+  timestamp: z20.string().min(1),
   /** Display slot of the routed CLI (api:* arms collapse to their slot). */
-  cli: z19.string().min(1).max(40),
+  cli: z20.string().min(1).max(40),
   /** Difficulty tier the ZeroRouter computed for the task. */
   tier: ModelTierSchema,
   /** Model the live decision actually used (or the CLI default when route-time selection is off). */
-  actualModel: z19.string().min(1).max(120),
+  actualModel: z20.string().min(1).max(120),
   /** Model `resolveModelForTier` WOULD have picked (never executed). */
-  shadowModel: z19.string().min(1).max(120),
+  shadowModel: z20.string().min(1).max(120),
   /** Whether shadow and actual agree. */
-  agree: z19.boolean(),
+  agree: z20.boolean(),
   /** Whether the actually-executed decision succeeded. */
-  success: z19.boolean(),
+  success: z20.boolean(),
   /** Measured cost of the actual execution, when available (unmeasured today on the routing path). */
-  costUsd: z19.number().nonnegative().optional()
+  costUsd: z20.number().nonnegative().optional()
 });
 function computeModelSelectionShadow(cli, tier, actualModel) {
   const shadowModel = resolveModelForTier(cli, tier);
@@ -13959,14 +13985,14 @@ function evaluateModelSelectionReadiness(records, config = DEFAULT_MODEL_SELECTI
   return { ready: blockers.length === 0, criteria, blockers };
 }
 var readinessLogged = false;
-function logModelSelectionReadinessOnce(logger14) {
+function logModelSelectionReadinessOnce(logger15) {
   if (readinessLogged) return;
   readinessLogged = true;
   try {
     const records = readModelSelectionShadowRecords();
     const summary = summarizeModelSelectionShadow(records);
     const verdict = evaluateModelSelectionReadiness(records);
-    logger14.info("route-model-selection shadow readiness", {
+    logger15.info("route-model-selection shadow readiness", {
       ready: verdict.ready,
       blockers: verdict.blockers,
       total: summary.total,
@@ -13978,7 +14004,7 @@ function logModelSelectionReadinessOnce(logger14) {
       meanCostUsd: summary.meanCostUsd
     });
   } catch (err2) {
-    logger14.warn("route-model-selection readiness signal failed (non-fatal)", {
+    logger15.warn("route-model-selection readiness signal failed (non-fatal)", {
       error: getErrorMessage(err2)
     });
   }
@@ -14199,7 +14225,7 @@ var CompositeRouter = class _CompositeRouter {
    * The task content itself is never persisted.
    */
   pendingModelShadow;
-  constructor(adapters, config, logger14) {
+  constructor(adapters, config, logger15) {
     const {
       preferenceRouterConfig,
       zeroRouterConfig,
@@ -14216,7 +14242,7 @@ var CompositeRouter = class _CompositeRouter {
       ...baseConfig
     } = config ?? {};
     this.config = CompositeRouterConfigSchema.parse(baseConfig);
-    this.logger = logger14 ?? createLogger({ component: "CompositeRouter" });
+    this.logger = logger15 ?? createLogger({ component: "CompositeRouter" });
     this.adapters = adapters;
     this.cliNames = Array.from(adapters.keys());
     if (metricsCollector !== void 0) {
@@ -14383,7 +14409,7 @@ var CompositeRouter = class _CompositeRouter {
    */
   async consultUnifiedContext(task) {
     try {
-      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-TAUTDY3F.js");
+      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-MTJR3AQM.js");
       const ctx = await getContextForTask({
         task: task.content,
         category: inferTaskCategory(task.content),
@@ -14825,14 +14851,14 @@ var CompositeRouter = class _CompositeRouter {
     return this.routingMemory;
   }
 };
-function createCompositeRouter(adapters, config, logger14) {
+function createCompositeRouter(adapters, config, logger15) {
   let resolved = config;
   if (isDynamicModelsEnabled() && config?.availableModelsCache === void 0) {
     const cache = getDefaultAvailableModelsCache();
     registerDefaultModelSources(cache, adapters);
     resolved = { ...config, availableModelsCache: cache };
   }
-  return new CompositeRouter(adapters, resolved, logger14);
+  return new CompositeRouter(adapters, resolved, logger15);
 }
 
 // src/core/types/model.ts
@@ -14887,7 +14913,7 @@ import { dirname as dirname5 } from "path";
 import { mkdirSync as mkdirSync3 } from "fs";
 
 // src/context/mobimem-types.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var DEFAULT_MOBIMEM_CONFIG = {
   dbPath: ":memory:",
   maxProfileEntries: 100,
@@ -14899,15 +14925,15 @@ var DEFAULT_MOBIMEM_CONFIG = {
   minExperienceSuccessRate: 0.7,
   autoEviction: true
 };
-var MobiMemConfigSchema = z20.object({
-  dbPath: z20.string(),
-  maxProfileEntries: z20.number().int().positive().default(100),
-  maxExperiencePatterns: z20.number().int().positive().default(500),
-  maxActionCacheEntries: z20.number().int().positive().default(1e3),
-  actionCacheTtlMs: z20.number().int().positive().default(36e5),
-  minProfileConfidence: z20.number().min(0).max(1).default(0.6),
-  minExperienceSuccessRate: z20.number().min(0).max(1).default(0.7),
-  autoEviction: z20.boolean().default(true)
+var MobiMemConfigSchema = z21.object({
+  dbPath: z21.string(),
+  maxProfileEntries: z21.number().int().positive().default(100),
+  maxExperiencePatterns: z21.number().int().positive().default(500),
+  maxActionCacheEntries: z21.number().int().positive().default(1e3),
+  actionCacheTtlMs: z21.number().int().positive().default(36e5),
+  minProfileConfidence: z21.number().min(0).max(1).default(0.6),
+  minExperienceSuccessRate: z21.number().min(0).max(1).default(0.7),
+  autoEviction: z21.boolean().default(true)
 });
 
 // src/context/mobimem-impl.ts
@@ -15362,7 +15388,7 @@ var ActionCacheImpl = class {
 };
 
 // src/context/mobimem.ts
-var logger13 = createLogger({ component: "MobiMem" });
+var logger14 = createLogger({ component: "MobiMem" });
 var MobiMem = class {
   profile;
   experience;
@@ -15383,7 +15409,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);
-    logger13.info("MobiMem initialized", {
+    logger14.info("MobiMem initialized", {
       dbPath: validated.dbPath,
       persisted: this.db !== null,
       maxProfileEntries: this.config.maxProfileEntries,
@@ -15416,13 +15442,13 @@ var MobiMem = class {
     if (this.config.autoEviction) {
       const evicted = this.action.evictExpired();
       if (evicted > 0) {
-        logger13.debug("Evicted expired action cache entries", { count: evicted });
+        logger14.debug("Evicted expired action cache entries", { count: evicted });
       }
     }
   }
   close() {
     if (this.db !== null) this.db.close();
-    logger13.info("MobiMem closed");
+    logger14.info("MobiMem closed");
   }
 };
 var sharedInstance = null;
@@ -15973,4 +15999,4 @@ export {
   AgentCapability,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-25ZJ5TCC.js.map
+//# sourceMappingURL=chunk-Y5JA7XEO.js.map