nexus-agents 3.7.0 → 3.8.0

package/dist/{chunk-7KHCQPHO.js → chunk-YSE3VQ4A.js}

@@ -2623,7 +2623,7 @@ function setDefaultRegistry(registry) {
 }
 async function reloadDefaultRegistry() {
   globalRegistry = buildDefaultRegistry();
-  const { resetGlobalRegistry } = await import("./unified-registry-L2T5UJHQ.js");
+  const { resetGlobalRegistry } = await import("./unified-registry-N2BQJSLK.js");
   resetGlobalRegistry();
   return globalRegistry;
 }
@@ -2828,6 +2828,10 @@ function modelSupportsAll(modelId, requirements) {
   return meetsContext && includesAll(model.outputModalities, requirements.outputModalities) && includesAll(model.inputModalities, requirements.inputModalities) && includesAll(model.toolCapabilities, requirements.toolCapabilities) && includesAll(model.specialFeatures, requirements.specialFeatures);
 }
 
+// src/core/price-basis.ts
+import { z as z3 } from "zod";
+var PriceBasisSchema = z3.enum(["list", "unknown"]);
+
 // src/core/trace-pricing.ts
 function toPricing(pricing) {
   if (pricing === void 0) return void 0;
@@ -3328,7 +3332,7 @@ function formatPercentage(value, decimals = 0) {
 
 // src/core/artifact.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var ArtifactType = {
   /** Planning documents and task breakdowns */
   PLAN: "plan",
@@ -3341,30 +3345,30 @@ var ArtifactType = {
   /** Intent declarations for policy authorization */
   INTENT: "intent"
 };
-var ArtifactTypeSchema = z3.enum([
+var ArtifactTypeSchema = z4.enum([
   ArtifactType.PLAN,
   ArtifactType.ANALYSIS,
   ArtifactType.DECISION,
   ArtifactType.RESULT,
   ArtifactType.INTENT
 ]);
-var ArtifactMetadataSchema = z3.object({
-  createdAt: z3.iso.datetime({ message: "createdAt must be ISO 8601 format" }),
-  createdBy: z3.string().min(1, "createdBy is required"),
-  parentId: z3.uuid().optional(),
-  taskId: z3.string().min(1, "taskId is required"),
-  traceId: z3.string().optional()
+var ArtifactMetadataSchema = z4.object({
+  createdAt: z4.iso.datetime({ message: "createdAt must be ISO 8601 format" }),
+  createdBy: z4.string().min(1, "createdBy is required"),
+  parentId: z4.uuid().optional(),
+  taskId: z4.string().min(1, "taskId is required"),
+  traceId: z4.string().optional()
 });
 function createArtifactSchema(dataSchema) {
-  return z3.object({
-    id: z3.uuid(),
+  return z4.object({
+    id: z4.uuid(),
     type: ArtifactTypeSchema,
-    schemaVersion: z3.string().regex(/^\d+\.\d+\.\d+$/, "schemaVersion must be semver"),
+    schemaVersion: z4.string().regex(/^\d+\.\d+\.\d+$/, "schemaVersion must be semver"),
     data: dataSchema,
     metadata: ArtifactMetadataSchema
   });
 }
-var BaseArtifactSchema = createArtifactSchema(z3.unknown());
+var BaseArtifactSchema = createArtifactSchema(z4.unknown());
 
 // src/core/metrics.ts
 var MAX_RECENT_ERRORS = 1e3;
@@ -5340,8 +5344,8 @@ function estimateTokens(text) {
 }
 
 // src/cli-adapters/types-core.ts
-import { z as z4 } from "zod";
-var ApiArmIdSchema = z4.enum([
+import { z as z5 } from "zod";
+var ApiArmIdSchema = z5.enum([
   "api:anthropic",
   "api:openai",
   "api:google",
@@ -5530,7 +5534,7 @@ function createBudgetExceededError(budget, result, currentBudget) {
 }
 
 // src/config/task-specialization-types.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var TASK_CATEGORIES = [
   "architecture",
   "code_generation",
@@ -5543,8 +5547,8 @@ var TASK_CATEGORIES = [
   "devops",
   "exploration"
 ];
-var TaskCategorySchema = z5.enum(TASK_CATEGORIES);
-var TaskSpecializationSchema = z5.object({
+var TaskCategorySchema = z6.enum(TASK_CATEGORIES);
+var TaskSpecializationSchema = z6.object({
   /** Task category identifier */
   category: TaskCategorySchema,
   /** Primary CLI recommendation */
@@ -5552,11 +5556,11 @@ var TaskSpecializationSchema = z5.object({
   /** Secondary CLI fallback */
   secondaryCli: CliNameSchema,
   /** Why this CLI is preferred for this task type */
-  reasoning: z5.string(),
+  reasoning: z6.string(),
   /** Keywords that trigger this category detection */
-  keywords: z5.array(z5.string()).min(1),
+  keywords: z6.array(z6.string()).min(1),
   /** Bonus score applied when this category matches (0-20) */
-  bonus: z5.number().min(0).max(20)
+  bonus: z6.number().min(0).max(20)
 });
 
 // src/config/task-specialization.ts
@@ -6392,19 +6396,19 @@ var TopsisRouter = class {
 };
 
 // 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()
+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 = 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 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,
@@ -6412,11 +6416,11 @@ var DEFAULT_LINUCB_CONFIG = {
   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)
+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/linucb-math.ts
@@ -6816,7 +6820,7 @@ var LinUCBBandit = class {
 import { randomUUID as randomUUID4 } from "crypto";
 
 // src/cli-adapters/preference-router-types.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var DEFAULT_PREFERENCE_ROUTER_CONFIG = {
   strongModel: {
     tier: "strong",
@@ -6837,24 +6841,24 @@ var DEFAULT_PREFERENCE_ROUTER_CONFIG = {
   maxDataPoints: 1e4,
   enableOnlineLearning: true
 };
-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)
+var PreferenceRouterConfigSchema = z8.object({
+  strongModel: z8.object({
+    tier: z8.literal("strong"),
+    cli: z8.enum(["claude", "gemini", "codex", "opencode"]),
+    costPerMillionTokens: z8.number().positive(),
+    qualityBaseline: z8.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)
+  weakModel: z8.object({
+    tier: z8.literal("weak"),
+    cli: z8.enum(["claude", "gemini", "codex", "opencode"]),
+    costPerMillionTokens: z8.number().positive(),
+    qualityBaseline: z8.number().min(0).max(1)
   }),
-  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()
+  routingThreshold: z8.number().min(0).max(1).default(0.5),
+  minDataPoints: z8.number().int().positive().default(10),
+  maxDataPoints: z8.number().int().positive().default(1e4),
+  enableOnlineLearning: z8.boolean().default(true),
+  domainThresholds: z8.record(z8.string(), z8.number().min(0).max(1)).optional()
 });
 
 // src/cli-adapters/preference-router-store.ts
@@ -7196,7 +7200,7 @@ function createPreferenceRouter(config, dataStore) {
 }
 
 // src/cli-adapters/zero-router-types.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/cli-adapters/derive-tier-tables.ts
 var CLI_ORDER = CLI_NAMES;
@@ -7324,7 +7328,7 @@ function deriveWeakClis() {
 }
 
 // src/cli-adapters/zero-router-types.ts
-var DifficultyDimensionSchema = z8.enum([
+var DifficultyDimensionSchema = z9.enum([
   "reasoning",
   "knowledge",
   "creativity",
@@ -7338,17 +7342,17 @@ var DIFFICULTY_DIMENSIONS = [
   "precision",
   "context_length"
 ];
-var DifficultySpaceSchema = z8.object({
+var DifficultySpaceSchema = z9.object({
   /** Reasoning difficulty: logical complexity, multi-step inference (0-1) */
-  reasoning: z8.number().min(0).max(1),
+  reasoning: z9.number().min(0).max(1),
   /** Knowledge difficulty: domain expertise required (0-1) */
-  knowledge: z8.number().min(0).max(1),
+  knowledge: z9.number().min(0).max(1),
   /** Creativity difficulty: novel generation, open-endedness (0-1) */
-  creativity: z8.number().min(0).max(1),
+  creativity: z9.number().min(0).max(1),
   /** Precision difficulty: accuracy requirements, error tolerance (0-1) */
-  precision: z8.number().min(0).max(1),
+  precision: z9.number().min(0).max(1),
   /** Context length difficulty: amount of context to process (0-1) */
-  context_length: z8.number().min(0).max(1)
+  context_length: z9.number().min(0).max(1)
 });
 var DEFAULT_DIFFICULTY_THRESHOLDS = {
   easyUpperBound: 0.3,
@@ -7360,12 +7364,12 @@ var DEFAULT_DIFFICULTY_TO_TIER = {
   hard: "powerful"
 };
 var DEFAULT_TIER_TO_CLIS = deriveTierToClis();
-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 DifficultyWeightsSchema = z9.object({
+  reasoning: z9.number().min(0).max(1),
+  knowledge: z9.number().min(0).max(1),
+  creativity: z9.number().min(0).max(1),
+  precision: z9.number().min(0).max(1),
+  context_length: z9.number().min(0).max(1)
 });
 var DEFAULT_DIFFICULTY_WEIGHTS = {
   reasoning: 0.3,
@@ -7374,29 +7378,29 @@ var DEFAULT_DIFFICULTY_WEIGHTS = {
   precision: 0.25,
   context_length: 0.15
 };
-var ZeroRouterConfigSchema = z8.object({
+var ZeroRouterConfigSchema = z9.object({
   /** Difficulty thresholds for level classification */
-  thresholds: z8.object({
-    easyUpperBound: z8.number().min(0).max(1),
-    hardLowerBound: z8.number().min(0).max(1)
+  thresholds: z9.object({
+    easyUpperBound: z9.number().min(0).max(1),
+    hardLowerBound: z9.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: z8.record(z8.enum(["easy", "medium", "hard"]), z8.enum(["fast", "balanced", "powerful"])).default(DEFAULT_DIFFICULTY_TO_TIER),
+  difficultyToTier: z9.record(z9.enum(["easy", "medium", "hard"]), z9.enum(["fast", "balanced", "powerful"])).default(DEFAULT_DIFFICULTY_TO_TIER),
   /** Mapping from model tier to CLI preference order */
-  tierToClis: z8.record(
-    z8.enum(["fast", "balanced", "powerful"]),
-    z8.array(z8.enum(["claude", "gemini", "codex", "opencode"]))
+  tierToClis: z9.record(
+    z9.enum(["fast", "balanced", "powerful"]),
+    z9.array(z9.enum(["claude", "gemini", "codex", "opencode"]))
   ).default(DEFAULT_TIER_TO_CLIS),
   /** Enable adaptive calibration from outcomes */
-  enableCalibration: z8.boolean().default(true),
+  enableCalibration: z9.boolean().default(true),
   /** Maximum outcomes to store for calibration */
-  maxCalibrationOutcomes: z8.number().int().positive().default(1e3),
+  maxCalibrationOutcomes: z9.number().int().positive().default(1e3),
   /** Minimum outcomes before applying calibration adjustments */
-  minCalibrationOutcomes: z8.number().int().positive().default(50),
+  minCalibrationOutcomes: z9.number().int().positive().default(50),
   /** Verbose logging */
-  verbose: z8.boolean().default(false)
+  verbose: z9.boolean().default(false)
 });
 var DEFAULT_ZERO_ROUTER_CONFIG = {
   thresholds: DEFAULT_DIFFICULTY_THRESHOLDS,
@@ -7920,16 +7924,16 @@ var ZeroRouter = class {
 };
 
 // src/cli-adapters/latency-tracker-types.ts
-import { z as z9 } from "zod";
-var LatencyTrackerConfigSchema = z9.object({
+import { z as z10 } from "zod";
+var LatencyTrackerConfigSchema = z10.object({
   /** Maximum number of samples to keep per CLI (default: 100) */
-  windowSize: z9.number().int().positive().default(100),
+  windowSize: z10.number().int().positive().default(100),
   /** Time-weighted decay factor (0-1, higher = more weight to recent) (default: 0.95) */
-  decayFactor: z9.number().min(0).max(1).default(0.95),
+  decayFactor: z10.number().min(0).max(1).default(0.95),
   /** Maximum age of samples in milliseconds before forced eviction (default: 3600000 = 1 hour) */
-  maxSampleAgeMs: z9.number().int().positive().default(36e5),
+  maxSampleAgeMs: z10.number().int().positive().default(36e5),
   /** Percentiles to calculate (default: [50, 95, 99]) */
-  percentiles: z9.array(z9.number().min(0).max(100)).default([50, 95, 99])
+  percentiles: z10.array(z10.number().min(0).max(100)).default([50, 95, 99])
 });
 var EMPTY_LATENCY_STATS = {
   count: 0,
@@ -8164,19 +8168,19 @@ var LatencyTracker = class {
 };
 
 // src/cli-adapters/routing/router-stage.ts
-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()
+import { z as z11 } from "zod";
+var StageConfigSchema = z11.object({
+  enabled: z11.boolean().default(true),
+  priority: z11.number().int().min(0).max(100).default(50),
+  options: z11.record(z11.string(), z11.unknown()).optional()
 });
-var RoutingOutcomeSchema = z10.object({
+var RoutingOutcomeSchema = z11.object({
   selectedCli: CliNameSchema,
-  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()
+  task: z11.string(),
+  success: z11.boolean(),
+  qualityScore: z11.number().min(0).max(1).optional(),
+  latencyMs: z11.number().int().positive().optional(),
+  tokensUsed: z11.number().int().positive().optional()
 });
 function createRoutingContext(task, availableClis = ["claude", "gemini", "codex", "opencode"], metadata) {
   return {
@@ -9675,10 +9679,10 @@ function createPersistentDistillerOrFallback(outcomeStore, logger15) {
 }
 
 // src/orchestration/outcomes/outcome-types.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var logger7 = createLogger({ component: "outcome-error-taxonomy" });
-var OutcomeSourceSchema = z11.enum(["delegate", "consensus", "manual"]);
-var OutcomeFailureCategorySchema = z11.enum([
+var OutcomeSourceSchema = z12.enum(["delegate", "consensus", "manual"]);
+var OutcomeFailureCategorySchema = z12.enum([
   "timeout",
   "authentication",
   "rate_limit",
@@ -9691,37 +9695,37 @@ var OutcomeFailureCategorySchema = z11.enum([
   "generic",
   "unknown"
 ]);
-var OutcomeCliSchema = z11.union([CliNameSchema, ApiArmIdSchema, z11.literal("unknown")]);
-var TaskOutcomeSchema = z11.object({
-  id: z11.string().min(1),
+var OutcomeCliSchema = z12.union([CliNameSchema, ApiArmIdSchema, z12.literal("unknown")]);
+var TaskOutcomeSchema = z12.object({
+  id: z12.string().min(1),
   cli: OutcomeCliSchema,
   category: TaskCategorySchema,
-  model: z11.string().min(1),
-  success: z11.boolean(),
-  durationMs: z11.number().nonnegative(),
-  timestamp: z11.string().min(1),
-  qualitySignals: z11.array(z11.string()).optional(),
+  model: z12.string().min(1),
+  success: z12.boolean(),
+  durationMs: z12.number().nonnegative(),
+  timestamp: z12.string().min(1),
+  qualitySignals: z12.array(z12.string()).optional(),
   failureCategory: OutcomeFailureCategorySchema.optional(),
-  errorMessage: z11.string().max(500).optional(),
+  errorMessage: z12.string().max(500).optional(),
   source: OutcomeSourceSchema,
   /** Whether this outcome came from a triage-initiated retry (#1506). */
-  wasRetried: z11.boolean().optional(),
+  wasRetried: z12.boolean().optional(),
   /** Triage action taken on the failure (#1506). */
-  triageAction: z11.string().max(30).optional(),
+  triageAction: z12.string().max(30).optional(),
   /** Routing stage that selected this CLI (#1785). */
-  routingStage: z11.string().max(50).optional(),
+  routingStage: z12.string().max(50).optional(),
   /** Number of retry attempts before this outcome (#1785). */
-  retryCount: z11.number().int().nonnegative().optional(),
+  retryCount: z12.number().int().nonnegative().optional(),
   /** Vendor resolved from `model` via ModelRegistry at write time (#2548). */
-  vendor: z11.string().min(1).max(40).optional(),
+  vendor: z12.string().min(1).max(40).optional(),
   /** Family resolved from `model` via ModelRegistry at write time (#2548). */
-  family: z11.string().min(1).max(80).optional(),
+  family: z12.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: z11.string().min(1).max(40).optional(),
+  voterRole: z12.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
@@ -9730,27 +9734,27 @@ var TaskOutcomeSchema = z11.object({
    * cohort. Free-form string (caller-assigned); typically the parent
    * node's `executionId` or `taskId`.
    */
-  baselineId: z11.string().min(1).max(64).optional(),
+  baselineId: z12.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: z11.string().min(1).max(128).optional(),
+  traceId: z12.string().min(1).max(128).optional(),
   /** Request id correlating this outcome to its originating invocation (#3146). */
-  requestId: z11.string().min(1).max(128).optional()
+  requestId: z12.string().min(1).max(128).optional()
 });
-var OutcomeQuerySchema = z11.object({
+var OutcomeQuerySchema = z12.object({
   cli: OutcomeCliSchema.optional(),
   category: TaskCategorySchema.optional(),
   source: OutcomeSourceSchema.optional(),
-  success: z11.boolean().optional(),
+  success: z12.boolean().optional(),
   failureCategory: OutcomeFailureCategorySchema.optional(),
-  since: z11.string().optional(),
-  limit: z11.number().int().positive().optional(),
+  since: z12.string().optional(),
+  limit: z12.number().int().positive().optional(),
   /** Exclude outcomes with any of these quality signals (#1680). */
-  excludeQualitySignals: z11.array(z11.string()).optional(),
+  excludeQualitySignals: z12.array(z12.string()).optional(),
   /** Restrict to outcomes recorded against a specific baseline (#2697). */
-  baselineId: z11.string().min(1).max(64).optional()
+  baselineId: z12.string().min(1).max(64).optional()
 });
 var TIMEOUT_PATTERNS = ["timeout", "timed out", "deadline exceeded", "socket hang up", "aborted"];
 var AUTH_PATTERNS = [
@@ -10400,52 +10404,52 @@ function runWarmUp(logger15) {
 }
 
 // src/cli-adapters/composite-router-types.ts
-import { z as z12 } from "zod";
-var CompositeRouterConfigSchema = z12.object({
+import { z as z13 } from "zod";
+var CompositeRouterConfigSchema = z13.object({
   /** Enable confidence cascade stage (default: false) (Issue #755, ADR-0005) */
-  enableConfidenceCascade: z12.boolean().default(false),
+  enableConfidenceCascade: z13.boolean().default(false),
   /** Enable budget filtering stage (default: true) */
-  enableBudgetFilter: z12.boolean().default(true),
+  enableBudgetFilter: z13.boolean().default(true),
   /** Enable capability match stage (default: false) (Issue #755, ADR-0005) */
-  enableCapabilityMatch: z12.boolean().default(false),
+  enableCapabilityMatch: z13.boolean().default(false),
   /** Enable ZeroRouter difficulty-based routing stage (default: true) (Issue #473) */
-  enableZeroRouter: z12.boolean().default(true),
+  enableZeroRouter: z13.boolean().default(true),
   /** Enable preference-trained routing stage (default: false) */
-  enablePreferenceRouting: z12.boolean().default(false),
+  enablePreferenceRouting: z13.boolean().default(false),
   /** Enable TOPSIS ranking stage (default: true) */
-  enableTopsisRanking: z12.boolean().default(true),
+  enableTopsisRanking: z13.boolean().default(true),
   /** Enable LinUCB selection stage (default: true) */
-  enableLinUCBSelection: z12.boolean().default(true),
+  enableLinUCBSelection: z13.boolean().default(true),
   /** Enable quality constraint stage (default: false) (Issue #755, ADR-0005) */
-  enableQualityConstraint: z12.boolean().default(false),
+  enableQualityConstraint: z13.boolean().default(false),
   /** Enable resource strategy stage for budget-aware oscillation (default: true) (Issue #998) */
-  enableResourceStrategy: z12.boolean().default(true),
+  enableResourceStrategy: z13.boolean().default(true),
   /** Enable strategy distillation for learned routing rules (default: false) (Issue #999) */
-  enableStrategyDistillation: z12.boolean().default(false),
+  enableStrategyDistillation: z13.boolean().default(false),
   /** Enable latency tracking for routing decisions (default: true) (Issue #361) */
-  enableLatencyTracking: z12.boolean().default(true),
+  enableLatencyTracking: z13.boolean().default(true),
   /** Enable routing memory for learned routing (default: false) (Issue #463, #461) */
-  enableRoutingMemory: z12.boolean().default(false),
+  enableRoutingMemory: z13.boolean().default(false),
   /** Enable KNN experience-based routing (default: false) (arXiv:2505.12601) */
-  enableKnnRouting: z12.boolean().default(false),
+  enableKnnRouting: z13.boolean().default(false),
   /** Weight for latency score in final routing (0-1, default: 0.2) */
-  latencyScoreWeight: z12.number().min(0).max(1).default(0.2),
+  latencyScoreWeight: z13.number().min(0).max(1).default(0.2),
   /** Budget constraints (optional) */
-  budgetConstraints: z12.object({
-    maxTokens: z12.number().positive(),
-    maxCostUsd: z12.number().positive(),
-    maxLatencyMs: z12.number().positive(),
+  budgetConstraints: z13.object({
+    maxTokens: z13.number().positive(),
+    maxCostUsd: z13.number().positive(),
+    maxLatencyMs: z13.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: z12.partialRecord(TaskCategorySchema, z12.number().positive())
+    taskClassMaxCostUsd: z13.partialRecord(TaskCategorySchema, z13.number().positive())
   }).partial().optional(),
   /** LinUCB exploration parameter (default: 1.0) */
-  linucbAlpha: z12.number().positive().default(1),
+  linucbAlpha: z13.number().positive().default(1),
   /** Billing mode: 'plan' zeroes cost weight, 'api' preserves current behavior (default: 'plan') */
-  billingMode: z12.enum(["plan", "api"]).default("plan"),
+  billingMode: z13.enum(["plan", "api"]).default("plan"),
   /**
    * Enable capacity-aware routing exclusion — remove a candidate whose adapter
    * reports *measurably* exhausted capacity (default: true) (#807, #4373).
@@ -10457,11 +10461,11 @@ var CompositeRouterConfigSchema = z12.object({
    * to "exclude" to match #4351 criterion 3; nothing can depend on the former,
    * since no deprioritization was ever implemented.
    */
-  enableCapacityBalancing: z12.boolean().default(true),
+  enableCapacityBalancing: z13.boolean().default(true),
   /** Maximum routing decision time in ms (default: 50) */
-  maxDecisionTimeMs: z12.number().positive().default(50),
+  maxDecisionTimeMs: z13.number().positive().default(50),
   /** Minimum preference data points before using learned routing (default: 10) */
-  preferenceMinDataPoints: z12.number().int().positive().default(10)
+  preferenceMinDataPoints: z13.number().int().positive().default(10)
 });
 var DEFAULT_COMPOSITE_CONFIG = {
   enableConfidenceCascade: false,
@@ -10858,12 +10862,12 @@ All defaults can be overridden via environment variables using the NEXUS_ prefix
 }
 
 // src/mcp/tools/weather-report-types.ts
-import { z as z13 } from "zod";
-var WeatherReportInputSchema = z13.object({
+import { z as z14 } from "zod";
+var WeatherReportInputSchema = z14.object({
   /** Filter by CLI name. */
-  cli: z13.enum(CLI_NAMES).optional().describe("Filter by CLI"),
+  cli: z14.enum(CLI_NAMES).optional().describe("Filter by CLI"),
   /** Filter by task category. */
-  category: z13.enum([
+  category: z14.enum([
     "architecture",
     "code_generation",
     "code_review",
@@ -10876,22 +10880,22 @@ var WeatherReportInputSchema = z13.object({
     "exploration"
   ]).optional().describe("Filter by task category"),
   /** Include adaptive routing bonus data. */
-  includeAdaptive: z13.boolean().optional().default(true).describe("Include adaptive routing bonuses (default: true)")
+  includeAdaptive: z14.boolean().optional().default(true).describe("Include adaptive routing bonuses (default: true)")
 });
 var DEFAULT_OUTCOME_LOOKBACK_MS = 7 * 24 * 60 * 60 * 1e3;
-var WeatherReportConfigSchema = z13.object({
+var WeatherReportConfigSchema = z14.object({
   /** Minimum observations before adjusting bonuses (lowered for faster activation). */
-  coldStartThreshold: z13.number().int().min(1).max(1e3).default(3),
+  coldStartThreshold: z14.number().int().min(1).max(1e3).default(3),
   /** Exploration rate: fraction of random routing (0.0-1.0). */
-  explorationRate: z13.number().min(0).max(1).default(0.1),
+  explorationRate: z14.number().min(0).max(1).default(0.1),
   /** Max adaptive bonus adjustment (+/-). */
-  maxBonusAdjustment: z13.number().min(0).max(20).default(10),
+  maxBonusAdjustment: z14.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: z13.number().int().min(0).default(DEFAULT_OUTCOME_LOOKBACK_MS)
+  outcomeLookbackMs: z14.number().int().min(0).default(DEFAULT_OUTCOME_LOOKBACK_MS)
 });
 function createDefaultWeatherConfig() {
   return WeatherReportConfigSchema.parse({});
@@ -11307,47 +11311,47 @@ function createMetricsMiddleware() {
 import { randomBytes as randomBytes3 } from "crypto";
 
 // src/config/defaults-types.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 function isKnownCliName(cli) {
   return cli === "claude" || cli === "gemini" || cli === "codex" || cli === "opencode" || cli === "default";
 }
-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({
+var positiveInt = z15.number().int().positive();
+var nonNegativeInt = z15.number().int().nonnegative();
+var durationMs = z15.number().int().positive().describe("Duration in milliseconds");
+var TimeoutProfileSchema = z15.object({
   simple: durationMs.describe("Timeout for simple tasks"),
   standard: durationMs.describe("Timeout for standard tasks"),
   complex: durationMs.describe("Timeout for complex tasks")
 });
-var RetryDefaultsSchema = z14.object({
+var RetryDefaultsSchema = z15.object({
   maxRetries: nonNegativeInt.max(10).describe("Maximum retry attempts"),
   baseDelayMs: durationMs.describe("Base delay between retries"),
   maxDelayMs: durationMs.describe("Maximum delay between retries"),
-  jitterFactor: z14.number().min(0).max(1).describe("Jitter factor (0-1)")
+  jitterFactor: z15.number().min(0).max(1).describe("Jitter factor (0-1)")
 });
-var RateLimitDefaultsSchema = z14.object({
+var RateLimitDefaultsSchema = z15.object({
   requestsPerMinute: positiveInt.max(1e3).describe("Max requests per minute"),
-  enabled: z14.boolean().describe("Whether rate limiting is enabled"),
+  enabled: z15.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 = z14.object({
-  failureThreshold: z14.number().int().min(1).max(100).describe("Failures before opening"),
+var CircuitBreakerDefaultsSchema = z15.object({
+  failureThreshold: z15.number().int().min(1).max(100).describe("Failures before opening"),
   resetTimeoutMs: durationMs.describe("Time before attempting reset"),
-  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"),
+  halfOpenSuccessThreshold: z15.number().int().min(1).max(10).describe("Successes to close"),
+  countTimeoutsAsFailures: z15.boolean().describe("Count timeouts as failures"),
+  countAuthFailuresAsFailures: z15.boolean().describe("Count auth failures as failures"),
+  countRateLimitsAsFailures: z15.boolean().describe("Count rate limit errors as failures"),
   halfOpenMaxRequests: positiveInt.describe("Max requests in half-open state")
 });
-var ToolRateLimitConfigSchema = z14.object({
+var ToolRateLimitConfigSchema = z15.object({
   capacity: positiveInt.describe("Token bucket capacity"),
   refillRate: positiveInt.describe("Token refill rate"),
   refillIntervalMs: durationMs.describe("Token refill interval")
 });
-var TimeoutDefaultsSchema = z14.object({
+var TimeoutDefaultsSchema = z15.object({
   cliMs: durationMs.describe("Default CLI timeout"),
   // cliSimpleMs / cliComplexMs removed in #4180 — see config/defaults.ts.
   apiMs: durationMs.describe("Default API timeout"),
@@ -11960,7 +11964,7 @@ function aggregateDecisionCosts(records, windowMs) {
 }
 
 // src/observability/decision-cost-store.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // src/config/jsonl-store.ts
 import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
@@ -12095,38 +12099,40 @@ var JsonlStore = class {
 };
 
 // src/observability/decision-cost.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var UNKNOWN_MODEL = "unknown";
-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(),
-      cachedInputTokens: z15.number().optional(),
-      cacheCreationInputTokens: z15.number().optional(),
-      costUsd: z15.number(),
-      unmeasured: z15.boolean()
+var DecisionCostSummarySchema = z16.object({
+  billingMode: z16.enum(["plan", "api"]),
+  voterCount: z16.number(),
+  measuredVoters: z16.number(),
+  unmeasuredVoters: z16.number(),
+  totalInputTokens: z16.number(),
+  totalOutputTokens: z16.number(),
+  totalTokens: z16.number(),
+  totalCostUsd: z16.number(),
+  priceBasis: PriceBasisSchema.optional(),
+  perVoter: z16.array(
+    z16.object({
+      role: z16.string(),
+      model: z16.string(),
+      inputTokens: z16.number(),
+      outputTokens: z16.number(),
+      totalTokens: z16.number(),
+      cachedInputTokens: z16.number().optional(),
+      cacheCreationInputTokens: z16.number().optional(),
+      costUsd: z16.number(),
+      unmeasured: z16.boolean(),
+      priceBasis: PriceBasisSchema.optional()
     })
   ),
-  perModel: z15.array(
-    z15.object({
-      model: z15.string(),
-      voterCount: z15.number(),
-      inputTokens: z15.number(),
-      outputTokens: z15.number(),
-      totalTokens: z15.number(),
-      costUsd: z15.number()
+  perModel: z16.array(
+    z16.object({
+      model: z16.string(),
+      voterCount: z16.number(),
+      inputTokens: z16.number(),
+      outputTokens: z16.number(),
+      totalTokens: z16.number(),
+      costUsd: z16.number()
     })
   )
 });
@@ -12151,9 +12157,20 @@ function toVoterBreakdown(v, isPlan) {
     ...v.cachedInputTokens !== void 0 ? { cachedInputTokens: v.cachedInputTokens } : {},
     ...v.cacheCreationInputTokens !== void 0 ? { cacheCreationInputTokens: v.cacheCreationInputTokens } : {},
     costUsd,
-    unmeasured: !measured
+    unmeasured: !measured,
+    // Plan mode forced `costUsd` to 0, so this row's money figure rests on no
+    // price — the same reasoning the decision total applies (#4406 review).
+    // Echoing 'list' here would attribute a $0 to a rate that produced nothing,
+    // and since `plan` is the DEFAULT billing mode that fiction would be on
+    // most persisted rows. `billingMode` already explains the zero.
+    ...isPlan ? {} : basisField(v.priceBasis)
   };
 }
+function decisionPriceBasis(voters) {
+  const stated = voters.filter((v) => v.priceBasis !== void 0);
+  if (stated.length === 0) return void 0;
+  return stated.some((v) => v.priceBasis === "list") ? "list" : "unknown";
+}
 function rollupDecisionCost(voters, billingMode) {
   const isPlan = billingMode === "plan";
   const perVoter = [];
@@ -12186,10 +12203,16 @@ function rollupDecisionCost(voters, billingMode) {
     totalOutputTokens,
     totalTokens: totalInputTokens + totalOutputTokens,
     totalCostUsd: roundUsd2(totalCostUsd),
+    // Plan mode's $0 is pre-covered spend, not a priced figure — no basis to
+    // report, so the field stays off rather than crediting a rate.
+    ...isPlan ? {} : basisField(decisionPriceBasis(voters)),
     perVoter,
     perModel
   };
 }
+function basisField(basis) {
+  return basis === void 0 ? {} : { priceBasis: basis };
+}
 function buildPerModelBreakdowns(modelAcc) {
   return [...modelAcc.entries()].map(([model, a]) => ({
     model,
@@ -12204,47 +12227,53 @@ function buildPerModelBreakdowns(modelAcc) {
 }
 
 // src/observability/decision-cost-store.ts
-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(),
+var DecisionGateSchema = z17.enum(["consensus_vote", "pr_review"]);
+var VoterCostBreakdownSchema = z17.object({
+  role: z17.string().min(1).max(64),
+  model: z17.string().min(1).max(120),
+  inputTokens: z17.number().int().nonnegative(),
+  outputTokens: z17.number().int().nonnegative(),
+  totalTokens: z17.number().int().nonnegative(),
   // #4435 — optional: absent means the adapter reported no cache activity,
   // which is a different claim from "zero cache tokens were used".
-  cachedInputTokens: z16.number().int().nonnegative().optional(),
-  cacheCreationInputTokens: z16.number().int().nonnegative().optional(),
-  costUsd: z16.number().nonnegative(),
-  unmeasured: z16.boolean()
+  cachedInputTokens: z17.number().int().nonnegative().optional(),
+  cacheCreationInputTokens: z17.number().int().nonnegative().optional(),
+  costUsd: z17.number().nonnegative(),
+  unmeasured: z17.boolean(),
+  // #4406 — optional: records written before the basis existed carry no
+  // provenance at all, and absent must stay absent rather than becoming the
+  // positive claim 'unknown'.
+  priceBasis: PriceBasisSchema.optional()
 });
-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 ModelCostBreakdownSchema = z17.object({
+  model: z17.string().min(1).max(120),
+  voterCount: z17.number().int().nonnegative(),
+  inputTokens: z17.number().int().nonnegative(),
+  outputTokens: z17.number().int().nonnegative(),
+  totalTokens: z17.number().int().nonnegative(),
+  costUsd: z17.number().nonnegative()
 });
-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 DecisionCostSummarySchema2 = z17.object({
+  billingMode: z17.enum(["plan", "api"]),
+  voterCount: z17.number().int().nonnegative(),
+  measuredVoters: z17.number().int().nonnegative(),
+  unmeasuredVoters: z17.number().int().nonnegative(),
+  totalInputTokens: z17.number().int().nonnegative(),
+  totalOutputTokens: z17.number().int().nonnegative(),
+  totalTokens: z17.number().int().nonnegative(),
+  totalCostUsd: z17.number().nonnegative(),
+  // #4406 — optional for the same reason as the per-voter field above.
+  priceBasis: PriceBasisSchema.optional(),
+  perVoter: z17.array(VoterCostBreakdownSchema).readonly(),
+  perModel: z17.array(ModelCostBreakdownSchema).readonly()
 });
-var DecisionCostRecordSchema = z16.object({
+var DecisionCostRecordSchema = z17.object({
   /** Stable id for the decision (correlation id / jobId / minted decision id). */
-  decisionId: z16.string().min(1).max(160),
+  decisionId: z17.string().min(1).max(160),
   /** Which gate type incurred the cost. */
   gate: DecisionGateSchema,
   /** ISO 8601 timestamp the rollup was recorded. */
-  timestamp: z16.string().min(1).max(40),
+  timestamp: z17.string().min(1).max(40),
   /** The rolled-up cost summary. */
   summary: DecisionCostSummarySchema2
 });
@@ -12304,7 +12333,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 z17 } from "zod";
+import { z as z18 } from "zod";
 var STRATEGY_MANIFEST_SCHEMA_VERSION = 1;
 var EXECUTION_STRATEGY_NAMES = [
   "single-shot",
@@ -12316,41 +12345,41 @@ var EXECUTION_STRATEGY_NAMES = [
   "spec",
   "research"
 ];
-var StrategyNameSchema = z17.enum(EXECUTION_STRATEGY_NAMES);
-var AuthorityTierSchema = z17.enum(["observe", "suggest", "advisory", "enforce"]);
-var PromotionEvidenceSchema = z17.object({
+var StrategyNameSchema = z18.enum(EXECUTION_STRATEGY_NAMES);
+var AuthorityTierSchema = z18.enum(["observe", "suggest", "advisory", "enforce"]);
+var PromotionEvidenceSchema = z18.object({
   /** The loop/strategy being promoted (manifest `id`). */
-  loopId: z17.string().min(1),
+  loopId: z18.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: z17.number().int().nonnegative(),
+  evalN: z18.number().int().nonnegative(),
   /** Precision on judged output (0–1); required for advisory+ promotions. */
-  precision: z17.number().min(0).max(1).optional(),
+  precision: z18.number().min(0).max(1).optional(),
   /** Recall (0–1); required for enforce promotions (missed-action cost). */
-  recall: z17.number().min(0).max(1).optional(),
+  recall: z18.number().min(0).max(1).optional(),
   /** The loop-specific promotion metric: name, value, and CI bounds. */
-  primaryMetric: z17.object({
-    name: z17.string().min(1),
-    value: z17.number(),
-    ci: z17.tuple([z17.number(), z17.number()])
+  primaryMetric: z18.object({
+    name: z18.string().min(1),
+    value: z18.number(),
+    ci: z18.tuple([z18.number(), z18.number()])
   }).strict(),
   /** ISO-8601 duration of soak at the lower tier with no intervention. */
-  soakDuration: z17.string().regex(/^P/, "soakDuration must be an ISO-8601 duration (e.g. P30D)"),
+  soakDuration: z18.string().regex(/^P/, "soakDuration must be an ISO-8601 duration (e.g. P30D)"),
   /** Confounders the primaryMetric controls for. */
-  controlledFor: z17.array(z17.string()).optional(),
+  controlledFor: z18.array(z18.string()).optional(),
   /** The recorded consensus_vote ref that ratifies the promotion. */
-  ratificationVote: z17.string().min(1),
+  ratificationVote: z18.string().min(1),
   /** Link to the measurement surface / report that produced the numbers. */
-  evidenceUri: z17.string().min(1)
+  evidenceUri: z18.string().min(1)
 }).strict();
-var PromotionEvidenceLedgerSchema = z17.object({
-  version: z17.number().int().positive(),
-  evidence: z17.array(PromotionEvidenceSchema)
+var PromotionEvidenceLedgerSchema = z18.object({
+  version: z18.number().int().positive(),
+  evidence: z18.array(PromotionEvidenceSchema)
 }).strict();
-var LatencyClassSchema = z17.enum([
+var LatencyClassSchema = z18.enum([
   "interactive",
   "single-llm",
   "multi-llm-panel",
@@ -12358,9 +12387,9 @@ var LatencyClassSchema = z17.enum([
   "network-fetch",
   "async-job-body"
 ]);
-var MaturityTierSchema = z17.enum(["experimental", "beta", "stable"]);
-var CostProfileSchema = z17.enum(["low", "medium", "high", "variable"]);
-var WorkflowPatternSchema = z17.enum([
+var MaturityTierSchema = z18.enum(["experimental", "beta", "stable"]);
+var CostProfileSchema = z18.enum(["low", "medium", "high", "variable"]);
+var WorkflowPatternSchema = z18.enum([
   "sequential",
   "wave",
   "graph",
@@ -12368,34 +12397,34 @@ var WorkflowPatternSchema = z17.enum([
   "aflow",
   "puppeteer"
 ]);
-var PipelineTypeSchema = z17.enum(["dev", "research", "audit", "greenfield", "general"]);
-var ComplexityTierSchema = z17.enum(["simple", "moderate", "complex", "expert"]);
-var SelectionRuleSchema = z17.object({
+var PipelineTypeSchema = z18.enum(["dev", "research", "audit", "greenfield", "general"]);
+var ComplexityTierSchema = z18.enum(["simple", "moderate", "complex", "expert"]);
+var SelectionRuleSchema = z18.object({
   /** Higher wins. Distinctive templates outrank the structural-pattern fallback. */
-  priority: z17.number().int(),
+  priority: z18.number().int(),
   /** Matches only when the routed workflow pattern is one of these. */
-  patterns: z17.array(WorkflowPatternSchema).min(1).optional(),
+  patterns: z18.array(WorkflowPatternSchema).min(1).optional(),
   /** Matches only when the classified pipeline template is one of these. */
-  pipelineTypes: z17.array(PipelineTypeSchema).min(1).optional(),
+  pipelineTypes: z18.array(PipelineTypeSchema).min(1).optional(),
   /** Matches only when the analyzed complexity is one of these. */
-  complexities: z17.array(ComplexityTierSchema).min(1).optional()
+  complexities: z18.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 = z17.object({
+var StrategyManifestSchema = z18.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: z17.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case"),
+  id: z18.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: z17.literal(STRATEGY_MANIFEST_SCHEMA_VERSION),
+  schemaVersion: z18.literal(STRATEGY_MANIFEST_SCHEMA_VERSION),
   /** The execution strategy this manifest describes (router enum). */
   strategy: StrategyNameSchema,
   /**
@@ -12403,7 +12432,7 @@ var StrategyManifestSchema = z17.object({
    * force-strategy entry point (generalizes `STRATEGY_ENTRYPOINT_TOOL`,
    * run-tool.ts). Non-empty.
    */
-  entrypointTool: z17.string().min(1),
+  entrypointTool: z18.string().min(1),
   /**
    * Whether a wired executor exists for this strategy (run-tool.ts
    * `buildDefaultExecutors`). FAIL-CLOSED routing key: only 4/8 are `true`
@@ -12417,15 +12446,15 @@ var StrategyManifestSchema = z17.object({
    * (#3881), so declaring `true` for a strategy with no wired executor (silent
    * fail-OPEN) fails the build rather than mis-advertising routability.
    */
-  executorAvailable: z17.boolean(),
+  executorAvailable: z18.boolean(),
   /** One-line human description of what this strategy is for (#3838 docs). */
-  description: z17.string().min(1),
+  description: z18.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: z17.string().min(1).optional(),
+  whenToForce: z18.string().min(1).optional(),
   /** Maturity tier; defaults are not assumed — author states it explicitly. */
   maturityTier: MaturityTierSchema,
   /** Expected latency class (#3734 taxonomy). */
@@ -12449,11 +12478,11 @@ var StrategyManifestSchema = z17.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: z17.array(SelectionRuleSchema).min(1).optional()
+  selectionRules: z18.array(SelectionRuleSchema).min(1).optional()
 }).strict();
-var StrategyManifestRegistrySchema = z17.object({
-  version: z17.number().int().positive(),
-  manifests: z17.array(StrategyManifestSchema).min(1).superRefine((manifests, ctx) => {
+var StrategyManifestRegistrySchema = z18.object({
+  version: z18.number().int().positive(),
+  manifests: z18.array(StrategyManifestSchema).min(1).superRefine((manifests, ctx) => {
     const seenIds = /* @__PURE__ */ new Set();
     const seenStrategies = /* @__PURE__ */ new Set();
     for (const [i, m] of manifests.entries()) {
@@ -13271,9 +13300,9 @@ function convertBonusesToScoreMap(bonuses, taskCategory) {
 }
 
 // src/cli-adapters/fallback-chains.ts
-import { z as z18 } from "zod";
-var FallbackChainSchema = z18.array(z18.enum(["claude", "gemini", "codex", "opencode"])).min(1).readonly();
-var FallbackChainRegistrySchema = z18.object({
+import { z as z19 } from "zod";
+var FallbackChainSchema = z19.array(z19.enum(["claude", "gemini", "codex", "opencode"])).min(1).readonly();
+var FallbackChainRegistrySchema = z19.object({
   code: FallbackChainSchema,
   research: FallbackChainSchema,
   documentation: FallbackChainSchema,
@@ -14030,20 +14059,20 @@ function setDefaultAvailableModelsCache(cache) {
 }
 
 // src/config/openrouter-models-source.ts
-import { z as z19 } from "zod";
+import { z as z20 } 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 = z19.object({
-  id: z19.string().min(1).max(256),
+var OpenRouterModelSchema = z20.object({
+  id: z20.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: z19.array(z19.string().max(256)).max(MAX_SUPPORTED_PARAMETERS).optional()
+  supported_parameters: z20.array(z20.string().max(256)).max(MAX_SUPPORTED_PARAMETERS).optional()
 });
-var OpenRouterModelsResponseSchema = z19.object({ data: z19.array(OpenRouterModelSchema) });
+var OpenRouterModelsResponseSchema = z20.object({ data: z20.array(OpenRouterModelSchema) });
 var logger12 = createLogger({ component: "openrouter-models-source" });
 function parseCatalog(text) {
   if (text.length > MAX_BYTES) {
@@ -14182,32 +14211,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 z20 } from "zod";
+import { z as z21 } 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 = z20.enum(["fast", "balanced", "powerful"]);
-var ModelSelectionShadowRecordSchema = z20.object({
-  schema: z20.literal(MODEL_SELECTION_SHADOW_SCHEMA_VERSION),
+var ModelTierSchema = z21.enum(["fast", "balanced", "powerful"]);
+var ModelSelectionShadowRecordSchema = z21.object({
+  schema: z21.literal(MODEL_SELECTION_SHADOW_SCHEMA_VERSION),
   /** ISO timestamp of the outcome join. */
-  timestamp: z20.string().min(1),
+  timestamp: z21.string().min(1),
   /** Display slot of the routed CLI (api:* arms collapse to their slot). */
-  cli: z20.string().min(1).max(40),
+  cli: z21.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: z20.string().min(1).max(120),
+  actualModel: z21.string().min(1).max(120),
   /** Model `resolveModelForTier` WOULD have picked (never executed). */
-  shadowModel: z20.string().min(1).max(120),
+  shadowModel: z21.string().min(1).max(120),
   /** Whether shadow and actual agree. */
-  agree: z20.boolean(),
+  agree: z21.boolean(),
   /** Whether the actually-executed decision succeeded. */
-  success: z20.boolean(),
+  success: z21.boolean(),
   /** Measured cost of the actual execution, when available (unmeasured today on the routing path). */
-  costUsd: z20.number().nonnegative().optional()
+  costUsd: z21.number().nonnegative().optional()
 });
 function computeModelSelectionShadow(cli, tier, actualModel) {
   const shadowModel = resolveModelForTier(cli, tier);
@@ -14747,7 +14776,7 @@ var CompositeRouter = class _CompositeRouter {
    */
   async consultUnifiedContext(task) {
     try {
-      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-CCGMXTGJ.js");
+      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-DIKQ7QZA.js");
       const ctx = await getContextForTask({
         task: task.content,
         category: inferTaskCategory(task.content),
@@ -15245,7 +15274,7 @@ import { dirname as dirname5 } from "path";
 import { mkdirSync as mkdirSync3 } from "fs";
 
 // src/context/mobimem-types.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var DEFAULT_MOBIMEM_CONFIG = {
   dbPath: ":memory:",
   maxProfileEntries: 100,
@@ -15257,15 +15286,15 @@ var DEFAULT_MOBIMEM_CONFIG = {
   minExperienceSuccessRate: 0.7,
   autoEviction: 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)
+var MobiMemConfigSchema = z22.object({
+  dbPath: z22.string(),
+  maxProfileEntries: z22.number().int().positive().default(100),
+  maxExperiencePatterns: z22.number().int().positive().default(500),
+  maxActionCacheEntries: z22.number().int().positive().default(1e3),
+  actionCacheTtlMs: z22.number().int().positive().default(36e5),
+  minProfileConfidence: z22.number().min(0).max(1).default(0.6),
+  minExperienceSuccessRate: z22.number().min(0).max(1).default(0.7),
+  autoEviction: z22.boolean().default(true)
 });
 
 // src/context/mobimem-impl.ts
@@ -16333,4 +16362,4 @@ export {
   AgentCapability,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-7KHCQPHO.js.map
+//# sourceMappingURL=chunk-YSE3VQ4A.js.map