nexus-agents 2.161.1 → 2.162.0

package/dist/{chunk-X2K6JQXF.js → chunk-A4XTT4AG.js}

@@ -2612,7 +2612,7 @@ function setDefaultRegistry(registry) {
 }
 async function reloadDefaultRegistry() {
   globalRegistry = buildDefaultRegistry();
-  const { resetGlobalRegistry } = await import("./unified-registry-DAFMWYGI.js");
+  const { resetGlobalRegistry } = await import("./unified-registry-PBJ4ZVPL.js");
   resetGlobalRegistry();
   return globalRegistry;
 }
@@ -2628,6 +2628,9 @@ function lookupInTree(modelId) {
 function inTreeById() {
   return new Map(buildInTreeEntries().map((e) => [e.id, e]));
 }
+function getModelPricing(modelId) {
+  return lookupInTree(modelId)?.pricing;
+}
 function getModelContextWindow(modelId) {
   return lookupInTree(modelId)?.contextWindow ?? 8192;
 }
@@ -5481,6 +5484,198 @@ function createBudgetExceededError(budget, result, currentBudget) {
   };
 }
 
+// src/config/task-specialization-types.ts
+import { z as z4 } from "zod";
+var TASK_CATEGORIES = [
+  "architecture",
+  "code_generation",
+  "code_review",
+  "research",
+  "security_review",
+  "planning",
+  "documentation",
+  "testing",
+  "devops",
+  "exploration"
+];
+var TaskCategorySchema = z4.enum(TASK_CATEGORIES);
+var TaskSpecializationSchema = z4.object({
+  /** Task category identifier */
+  category: TaskCategorySchema,
+  /** Primary CLI recommendation */
+  primaryCli: CliNameSchema,
+  /** Secondary CLI fallback */
+  secondaryCli: CliNameSchema,
+  /** Why this CLI is preferred for this task type */
+  reasoning: z4.string(),
+  /** Keywords that trigger this category detection */
+  keywords: z4.array(z4.string()).min(1),
+  /** Bonus score applied when this category matches (0-20) */
+  bonus: z4.number().min(0).max(20)
+});
+
+// src/config/task-specialization.ts
+var TASK_SPECIALIZATION_MATRIX = [
+  {
+    category: "architecture",
+    primaryCli: "gemini",
+    secondaryCli: "claude",
+    reasoning: "Gemini primary (66.7%, n=24) for architecture. Claude secondary (43.6%, n=220). Weather data 2026-03-09.",
+    keywords: ["architect", "design", "system design", "trade-off", "adr"],
+    bonus: 10
+  },
+  {
+    category: "code_generation",
+    primaryCli: "codex",
+    secondaryCli: "claude",
+    reasoning: "Codex primary (91.9%, n=408) for code generation with sandboxed execution. Confirmed per weather data (#1454)",
+    keywords: ["implement", "generate code", "write function", "build feature"],
+    bonus: 15
+  },
+  {
+    category: "code_review",
+    primaryCli: "codex",
+    secondaryCli: "claude",
+    reasoning: "Codex primary (88.3%, n=94) for code review; Claude secondary. Bonus aligned per weather data (#1454)",
+    keywords: ["review code", "code review", "pull request", "pr review"],
+    bonus: 15
+  },
+  {
+    category: "research",
+    primaryCli: "gemini",
+    secondaryCli: "claude",
+    reasoning: "Gemini has deep_research feature and 1M token context for synthesis",
+    keywords: ["research", "investigate", "literature", "survey", "state of the art"],
+    bonus: 15
+  },
+  {
+    category: "security_review",
+    primaryCli: "codex",
+    secondaryCli: "claude",
+    reasoning: "Weather 2026-03-09: claude 44.9% (n=385, declining), codex 60% (n=5), gemini 50% (n=14). Codex primary, claude secondary. Low bonus \u2014 no CLI is clearly dominant.",
+    keywords: [
+      "security review",
+      "security analysis",
+      "security audit",
+      "security flaw",
+      "vulnerability assessment",
+      "threat model",
+      "cve",
+      "audit security",
+      "owasp",
+      "injection",
+      "xss",
+      "csrf",
+      "security",
+      "vulnerability"
+    ],
+    bonus: 5
+  },
+  {
+    category: "planning",
+    primaryCli: "claude",
+    secondaryCli: "codex",
+    reasoning: "Claude primary (92.0%, n=274) for planning and task decomposition. Confirmed per weather data (#1454)",
+    keywords: ["plan", "sprint", "roadmap", "decompose", "prioritize"],
+    bonus: 10
+  },
+  {
+    category: "documentation",
+    primaryCli: "gemini",
+    secondaryCli: "claude",
+    reasoning: "Gemini can process entire codebases (1M context) for comprehensive docs",
+    keywords: ["document", "documentation", "readme", "api docs", "write docs"],
+    bonus: 10
+  },
+  {
+    category: "testing",
+    primaryCli: "codex",
+    secondaryCli: "claude",
+    reasoning: "Codex primary (91.6%, n=143) for test writing with sandbox execution. Bonus aligned per weather data (#1454)",
+    keywords: ["test", "write tests", "test coverage", "unit test", "integration test"],
+    bonus: 15
+  },
+  {
+    category: "devops",
+    primaryCli: "claude",
+    secondaryCli: "gemini",
+    reasoning: "Claude excels at infrastructure reasoning and CI/CD configuration",
+    keywords: [
+      "devops",
+      "ci/cd",
+      "deploy",
+      "infrastructure",
+      "docker",
+      "kubernetes",
+      "pipeline",
+      "helm",
+      "terraform",
+      "ansible",
+      "makefile",
+      "dockerfile",
+      "github actions",
+      "workflow",
+      "concourse",
+      "jenkins",
+      "argocd",
+      "vulnerability scan",
+      "security scan",
+      "sast",
+      "dast",
+      "zap",
+      "semgrep",
+      "grype",
+      "fork",
+      "kind",
+      "cluster",
+      "namespace",
+      "ingress",
+      "monitoring"
+    ],
+    bonus: 10
+  },
+  {
+    category: "exploration",
+    primaryCli: "gemini",
+    secondaryCli: "codex",
+    reasoning: "Gemini primary (98.5%, n=202) for exploration with 1M context. Claude removed as secondary (63.5% vs 98.5%, n=340) per #1462",
+    keywords: ["explore", "navigate", "find", "discover", "scan codebase"],
+    bonus: 15
+  }
+];
+var CATEGORY_INDEX = new Map(
+  TASK_SPECIALIZATION_MATRIX.map((s) => [s.category, s])
+);
+function getSpecialization(category) {
+  const spec = CATEGORY_INDEX.get(category);
+  if (!spec) throw new Error(`Unknown category: ${category}`);
+  return spec;
+}
+function detectTaskCategory(task) {
+  const taskLower = task.toLowerCase();
+  let bestSpec;
+  let bestScore = 0;
+  for (const spec of TASK_SPECIALIZATION_MATRIX) {
+    let score = 0;
+    for (const kw of spec.keywords) {
+      if (taskLower.includes(kw)) {
+        score += kw.split(/\s+/).length;
+      }
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      bestSpec = spec;
+    }
+  }
+  if (bestSpec === void 0) return null;
+  return {
+    category: bestSpec.category,
+    primaryCli: bestSpec.primaryCli,
+    secondaryCli: bestSpec.secondaryCli,
+    bonus: bestSpec.bonus
+  };
+}
+
 // src/cli-adapters/budget-router.ts
 var logger4 = createLogger({ component: "budget-router" });
 var DEFAULT_OPTIONS = {
@@ -5500,8 +5695,15 @@ var DEFAULT_OPTIONS = {
     warning: 75,
     critical: 90
   },
-  enforceHardLimits: true
+  enforceHardLimits: true,
+  // #4196: per-task-class cost ceilings default OFF (no ceiling configured).
+  taskClassCostCeilings: {}
 };
+function estimateRegistryCostUsd(slot, inputTokens, outputTokens) {
+  const pricing = getModelPricing(getDefaultModelForCli(slot));
+  if (pricing === void 0) return void 0;
+  return inputTokens / 1e6 * pricing.inputPer1M + outputTokens / 1e6 * pricing.outputPer1M;
+}
 var BudgetRouter = class {
   adapters;
   options;
@@ -5603,6 +5805,47 @@ var BudgetRouter = class {
       projectedBudget
     };
   }
+  /**
+   * Per-task-class cost ceiling filter (#4196, epic #4175).
+   *
+   * Resolves the task's class via `detectTaskCategory`; when a ceiling is
+   * configured for that class, each candidate's cost is estimated with
+   * canonical registry pricing and candidates above the ceiling are dropped.
+   *
+   * BINDING fail direction: a candidate with MISSING registry pricing FAILS
+   * the check (fail-closed) — unknown cost must not slip under a configured
+   * ceiling. This is deliberately NOT the return-all-candidates fallback of
+   * `filterByPreferenceTier` (composite-router-helpers.ts).
+   *
+   * Billing-mode gating (api only) is the caller's responsibility
+   * (`applyBudgetFilter`); plan mode never invokes this.
+   */
+  filterByTaskClassCeiling(task, candidates) {
+    const ceiling = this.resolveTaskClassCeiling(task);
+    if (ceiling === void 0) return candidates;
+    const inputTokens = estimateTokens2(task.content);
+    const outputTokens = task.maxTokens ?? inputTokens * 2;
+    return candidates.filter((arm) => {
+      const cost = estimateRegistryCostUsd(routingArmDisplaySlot(arm), inputTokens, outputTokens);
+      if (cost === void 0) {
+        logger4.debug("Cost ceiling: missing registry pricing \u2014 failing closed", { arm, ceiling });
+        return false;
+      }
+      const within = cost <= ceiling;
+      if (!within) {
+        logger4.debug("Cost ceiling: candidate excluded", { arm, cost, ceiling });
+      }
+      return within;
+    });
+  }
+  /** Resolve the configured ceiling for the task's detected class, if any (#4196). */
+  resolveTaskClassCeiling(task) {
+    const ceilings = this.options.taskClassCostCeilings;
+    if (Object.keys(ceilings).length === 0) return void 0;
+    const match = detectTaskCategory(task.content);
+    if (match === null) return void 0;
+    return ceilings[match.category];
+  }
   /**
    * Route task with budget awareness.
    */
@@ -5825,6 +6068,24 @@ var TASK_CATEGORY_PLAN_CRITERIA = {
   ],
   general: PLAN_BILLING_TOPSIS_CRITERIA
 };
+var DIFFICULTY_QUALITY_HEAVY_THRESHOLD = 7;
+var DIFFICULTY_COST_HEAVY_THRESHOLD = 4;
+var DIFFICULTY_WEIGHT_SHIFT = 0.15;
+function applyDifficultyCostWeighting(criteria, reasoningComplexity) {
+  const direction = reasoningComplexity > DIFFICULTY_QUALITY_HEAVY_THRESHOLD ? 1 : reasoningComplexity < DIFFICULTY_COST_HEAVY_THRESHOLD ? -1 : 0;
+  if (direction === 0) return criteria;
+  const quality = criteria.find((c) => c.name === "quality");
+  const cost = criteria.find((c) => c.name === "cost");
+  if (quality === void 0 || cost === void 0) return criteria;
+  const donorWeight = direction === 1 ? cost.weight : quality.weight;
+  const shift = Math.min(DIFFICULTY_WEIGHT_SHIFT, donorWeight);
+  if (shift <= 0) return criteria;
+  return criteria.map((c) => {
+    if (c.name === "quality") return { ...c, weight: c.weight + direction * shift };
+    if (c.name === "cost") return { ...c, weight: c.weight - direction * shift };
+    return c;
+  });
+}
 function getCriteriaForTaskCategory(taskType, billingMode = "api") {
   const map2 = billingMode === "plan" ? TASK_CATEGORY_PLAN_CRITERIA : TASK_CATEGORY_TOPSIS_CRITERIA;
   return map2[taskType] ?? (billingMode === "plan" ? PLAN_BILLING_TOPSIS_CRITERIA : DEFAULT_TOPSIS_CRITERIA);
@@ -6086,19 +6347,19 @@ var TopsisRouter = class {
 };
 
 // src/cli-adapters/budget-router-types.ts
-import { z as z4 } from "zod";
-var BudgetConstraintSchema = z4.object({
-  maxTokens: z4.number().int().positive().optional(),
-  maxCostUSD: z4.number().positive().optional(),
-  maxLatencyMs: z4.number().positive().optional()
+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()
 });
-var SessionBudgetSchema = z4.object({
-  totalTokens: z4.number().int().positive(),
-  totalCostUSD: z4.number().positive(),
-  usedTokens: z4.number().int().min(0).default(0),
-  usedCostUSD: z4.number().min(0).default(0),
-  startTime: z4.number().int().positive(),
-  sessionId: z4.string().min(1)
+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 DEFAULT_LINUCB_CONFIG = {
   numArms: 4,
@@ -6106,11 +6367,11 @@ var DEFAULT_LINUCB_CONFIG = {
   alpha: 1,
   lambda: 1
 };
-var LinUCBConfigSchema = z4.object({
-  numArms: z4.number().int().positive().default(4),
-  featureDim: z4.number().int().positive().default(6),
-  alpha: z4.number().positive().default(1),
-  lambda: z4.number().positive().default(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)
 });
 
 // src/cli-adapters/linucb-math.ts
@@ -6491,7 +6752,7 @@ var LinUCBBandit = class {
 import { randomUUID as randomUUID4 } from "crypto";
 
 // src/cli-adapters/preference-router-types.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var DEFAULT_PREFERENCE_ROUTER_CONFIG = {
   strongModel: {
     tier: "strong",
@@ -6512,24 +6773,24 @@ var DEFAULT_PREFERENCE_ROUTER_CONFIG = {
   maxDataPoints: 1e4,
   enableOnlineLearning: true
 };
-var PreferenceRouterConfigSchema = z5.object({
-  strongModel: z5.object({
-    tier: z5.literal("strong"),
-    cli: z5.enum(["claude", "gemini", "codex", "opencode"]),
-    costPerMillionTokens: z5.number().positive(),
-    qualityBaseline: z5.number().min(0).max(1)
+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)
   }),
-  weakModel: z5.object({
-    tier: z5.literal("weak"),
-    cli: z5.enum(["claude", "gemini", "codex", "opencode"]),
-    costPerMillionTokens: z5.number().positive(),
-    qualityBaseline: z5.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)
   }),
-  routingThreshold: z5.number().min(0).max(1).default(0.5),
-  minDataPoints: z5.number().int().positive().default(10),
-  maxDataPoints: z5.number().int().positive().default(1e4),
-  enableOnlineLearning: z5.boolean().default(true),
-  domainThresholds: z5.record(z5.string(), z5.number().min(0).max(1)).optional()
+  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()
 });
 
 // src/cli-adapters/preference-router-store.ts
@@ -6871,8 +7132,8 @@ function createPreferenceRouter(config, dataStore) {
 }
 
 // src/cli-adapters/zero-router-types.ts
-import { z as z6 } from "zod";
-var DifficultyDimensionSchema = z6.enum([
+import { z as z7 } from "zod";
+var DifficultyDimensionSchema = z7.enum([
   "reasoning",
   "knowledge",
   "creativity",
@@ -6886,17 +7147,17 @@ var DIFFICULTY_DIMENSIONS = [
   "precision",
   "context_length"
 ];
-var DifficultySpaceSchema = z6.object({
+var DifficultySpaceSchema = z7.object({
   /** Reasoning difficulty: logical complexity, multi-step inference (0-1) */
-  reasoning: z6.number().min(0).max(1),
+  reasoning: z7.number().min(0).max(1),
   /** Knowledge difficulty: domain expertise required (0-1) */
-  knowledge: z6.number().min(0).max(1),
+  knowledge: z7.number().min(0).max(1),
   /** Creativity difficulty: novel generation, open-endedness (0-1) */
-  creativity: z6.number().min(0).max(1),
+  creativity: z7.number().min(0).max(1),
   /** Precision difficulty: accuracy requirements, error tolerance (0-1) */
-  precision: z6.number().min(0).max(1),
+  precision: z7.number().min(0).max(1),
   /** Context length difficulty: amount of context to process (0-1) */
-  context_length: z6.number().min(0).max(1)
+  context_length: z7.number().min(0).max(1)
 });
 var DEFAULT_DIFFICULTY_THRESHOLDS = {
   easyUpperBound: 0.3,
@@ -6912,12 +7173,12 @@ var DEFAULT_TIER_TO_CLIS = {
   balanced: ["codex", "opencode", "gemini", "claude"],
   powerful: ["claude", "codex", "opencode", "gemini"]
 };
-var DifficultyWeightsSchema = z6.object({
-  reasoning: z6.number().min(0).max(1),
-  knowledge: z6.number().min(0).max(1),
-  creativity: z6.number().min(0).max(1),
-  precision: z6.number().min(0).max(1),
-  context_length: z6.number().min(0).max(1)
+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 DEFAULT_DIFFICULTY_WEIGHTS = {
   reasoning: 0.3,
@@ -6926,29 +7187,29 @@ var DEFAULT_DIFFICULTY_WEIGHTS = {
   precision: 0.25,
   context_length: 0.15
 };
-var ZeroRouterConfigSchema = z6.object({
+var ZeroRouterConfigSchema = z7.object({
   /** Difficulty thresholds for level classification */
-  thresholds: z6.object({
-    easyUpperBound: z6.number().min(0).max(1),
-    hardLowerBound: z6.number().min(0).max(1)
+  thresholds: z7.object({
+    easyUpperBound: z7.number().min(0).max(1),
+    hardLowerBound: z7.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: z6.record(z6.enum(["easy", "medium", "hard"]), z6.enum(["fast", "balanced", "powerful"])).default(DEFAULT_DIFFICULTY_TO_TIER),
+  difficultyToTier: z7.record(z7.enum(["easy", "medium", "hard"]), z7.enum(["fast", "balanced", "powerful"])).default(DEFAULT_DIFFICULTY_TO_TIER),
   /** Mapping from model tier to CLI preference order */
-  tierToClis: z6.record(
-    z6.enum(["fast", "balanced", "powerful"]),
-    z6.array(z6.enum(["claude", "gemini", "codex", "opencode"]))
+  tierToClis: z7.record(
+    z7.enum(["fast", "balanced", "powerful"]),
+    z7.array(z7.enum(["claude", "gemini", "codex", "opencode"]))
   ).default(DEFAULT_TIER_TO_CLIS),
   /** Enable adaptive calibration from outcomes */
-  enableCalibration: z6.boolean().default(true),
+  enableCalibration: z7.boolean().default(true),
   /** Maximum outcomes to store for calibration */
-  maxCalibrationOutcomes: z6.number().int().positive().default(1e3),
+  maxCalibrationOutcomes: z7.number().int().positive().default(1e3),
   /** Minimum outcomes before applying calibration adjustments */
-  minCalibrationOutcomes: z6.number().int().positive().default(50),
+  minCalibrationOutcomes: z7.number().int().positive().default(50),
   /** Verbose logging */
-  verbose: z6.boolean().default(false)
+  verbose: z7.boolean().default(false)
 });
 var DEFAULT_ZERO_ROUTER_CONFIG = {
   thresholds: DEFAULT_DIFFICULTY_THRESHOLDS,
@@ -7472,16 +7733,16 @@ var ZeroRouter = class {
 };
 
 // src/cli-adapters/latency-tracker-types.ts
-import { z as z7 } from "zod";
-var LatencyTrackerConfigSchema = z7.object({
+import { z as z8 } from "zod";
+var LatencyTrackerConfigSchema = z8.object({
   /** Maximum number of samples to keep per CLI (default: 100) */
-  windowSize: z7.number().int().positive().default(100),
+  windowSize: z8.number().int().positive().default(100),
   /** Time-weighted decay factor (0-1, higher = more weight to recent) (default: 0.95) */
-  decayFactor: z7.number().min(0).max(1).default(0.95),
+  decayFactor: z8.number().min(0).max(1).default(0.95),
   /** Maximum age of samples in milliseconds before forced eviction (default: 3600000 = 1 hour) */
-  maxSampleAgeMs: z7.number().int().positive().default(36e5),
+  maxSampleAgeMs: z8.number().int().positive().default(36e5),
   /** Percentiles to calculate (default: [50, 95, 99]) */
-  percentiles: z7.array(z7.number().min(0).max(100)).default([50, 95, 99])
+  percentiles: z8.array(z8.number().min(0).max(100)).default([50, 95, 99])
 });
 var EMPTY_LATENCY_STATS = {
   count: 0,
@@ -7716,19 +7977,19 @@ var LatencyTracker = class {
 };
 
 // src/cli-adapters/routing/router-stage.ts
-import { z as z8 } from "zod";
-var StageConfigSchema = z8.object({
-  enabled: z8.boolean().default(true),
-  priority: z8.number().int().min(0).max(100).default(50),
-  options: z8.record(z8.string(), z8.unknown()).optional()
+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()
 });
-var RoutingOutcomeSchema = z8.object({
+var RoutingOutcomeSchema = z9.object({
   selectedCli: CliNameSchema,
-  task: z8.string(),
-  success: z8.boolean(),
-  qualityScore: z8.number().min(0).max(1).optional(),
-  latencyMs: z8.number().int().positive().optional(),
-  tokensUsed: z8.number().int().positive().optional()
+  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()
 });
 function createRoutingContext(task, availableClis = ["claude", "gemini", "codex", "opencode"], metadata) {
   return {
@@ -7924,198 +8185,6 @@ var ConfidenceCascadeStage = class {
   }
 };
 
-// src/config/task-specialization-types.ts
-import { z as z9 } from "zod";
-var TASK_CATEGORIES = [
-  "architecture",
-  "code_generation",
-  "code_review",
-  "research",
-  "security_review",
-  "planning",
-  "documentation",
-  "testing",
-  "devops",
-  "exploration"
-];
-var TaskCategorySchema = z9.enum(TASK_CATEGORIES);
-var TaskSpecializationSchema = z9.object({
-  /** Task category identifier */
-  category: TaskCategorySchema,
-  /** Primary CLI recommendation */
-  primaryCli: CliNameSchema,
-  /** Secondary CLI fallback */
-  secondaryCli: CliNameSchema,
-  /** Why this CLI is preferred for this task type */
-  reasoning: z9.string(),
-  /** Keywords that trigger this category detection */
-  keywords: z9.array(z9.string()).min(1),
-  /** Bonus score applied when this category matches (0-20) */
-  bonus: z9.number().min(0).max(20)
-});
-
-// src/config/task-specialization.ts
-var TASK_SPECIALIZATION_MATRIX = [
-  {
-    category: "architecture",
-    primaryCli: "gemini",
-    secondaryCli: "claude",
-    reasoning: "Gemini primary (66.7%, n=24) for architecture. Claude secondary (43.6%, n=220). Weather data 2026-03-09.",
-    keywords: ["architect", "design", "system design", "trade-off", "adr"],
-    bonus: 10
-  },
-  {
-    category: "code_generation",
-    primaryCli: "codex",
-    secondaryCli: "claude",
-    reasoning: "Codex primary (91.9%, n=408) for code generation with sandboxed execution. Confirmed per weather data (#1454)",
-    keywords: ["implement", "generate code", "write function", "build feature"],
-    bonus: 15
-  },
-  {
-    category: "code_review",
-    primaryCli: "codex",
-    secondaryCli: "claude",
-    reasoning: "Codex primary (88.3%, n=94) for code review; Claude secondary. Bonus aligned per weather data (#1454)",
-    keywords: ["review code", "code review", "pull request", "pr review"],
-    bonus: 15
-  },
-  {
-    category: "research",
-    primaryCli: "gemini",
-    secondaryCli: "claude",
-    reasoning: "Gemini has deep_research feature and 1M token context for synthesis",
-    keywords: ["research", "investigate", "literature", "survey", "state of the art"],
-    bonus: 15
-  },
-  {
-    category: "security_review",
-    primaryCli: "codex",
-    secondaryCli: "claude",
-    reasoning: "Weather 2026-03-09: claude 44.9% (n=385, declining), codex 60% (n=5), gemini 50% (n=14). Codex primary, claude secondary. Low bonus \u2014 no CLI is clearly dominant.",
-    keywords: [
-      "security review",
-      "security analysis",
-      "security audit",
-      "security flaw",
-      "vulnerability assessment",
-      "threat model",
-      "cve",
-      "audit security",
-      "owasp",
-      "injection",
-      "xss",
-      "csrf",
-      "security",
-      "vulnerability"
-    ],
-    bonus: 5
-  },
-  {
-    category: "planning",
-    primaryCli: "claude",
-    secondaryCli: "codex",
-    reasoning: "Claude primary (92.0%, n=274) for planning and task decomposition. Confirmed per weather data (#1454)",
-    keywords: ["plan", "sprint", "roadmap", "decompose", "prioritize"],
-    bonus: 10
-  },
-  {
-    category: "documentation",
-    primaryCli: "gemini",
-    secondaryCli: "claude",
-    reasoning: "Gemini can process entire codebases (1M context) for comprehensive docs",
-    keywords: ["document", "documentation", "readme", "api docs", "write docs"],
-    bonus: 10
-  },
-  {
-    category: "testing",
-    primaryCli: "codex",
-    secondaryCli: "claude",
-    reasoning: "Codex primary (91.6%, n=143) for test writing with sandbox execution. Bonus aligned per weather data (#1454)",
-    keywords: ["test", "write tests", "test coverage", "unit test", "integration test"],
-    bonus: 15
-  },
-  {
-    category: "devops",
-    primaryCli: "claude",
-    secondaryCli: "gemini",
-    reasoning: "Claude excels at infrastructure reasoning and CI/CD configuration",
-    keywords: [
-      "devops",
-      "ci/cd",
-      "deploy",
-      "infrastructure",
-      "docker",
-      "kubernetes",
-      "pipeline",
-      "helm",
-      "terraform",
-      "ansible",
-      "makefile",
-      "dockerfile",
-      "github actions",
-      "workflow",
-      "concourse",
-      "jenkins",
-      "argocd",
-      "vulnerability scan",
-      "security scan",
-      "sast",
-      "dast",
-      "zap",
-      "semgrep",
-      "grype",
-      "fork",
-      "kind",
-      "cluster",
-      "namespace",
-      "ingress",
-      "monitoring"
-    ],
-    bonus: 10
-  },
-  {
-    category: "exploration",
-    primaryCli: "gemini",
-    secondaryCli: "codex",
-    reasoning: "Gemini primary (98.5%, n=202) for exploration with 1M context. Claude removed as secondary (63.5% vs 98.5%, n=340) per #1462",
-    keywords: ["explore", "navigate", "find", "discover", "scan codebase"],
-    bonus: 15
-  }
-];
-var CATEGORY_INDEX = new Map(
-  TASK_SPECIALIZATION_MATRIX.map((s) => [s.category, s])
-);
-function getSpecialization(category) {
-  const spec = CATEGORY_INDEX.get(category);
-  if (!spec) throw new Error(`Unknown category: ${category}`);
-  return spec;
-}
-function detectTaskCategory(task) {
-  const taskLower = task.toLowerCase();
-  let bestSpec;
-  let bestScore = 0;
-  for (const spec of TASK_SPECIALIZATION_MATRIX) {
-    let score = 0;
-    for (const kw of spec.keywords) {
-      if (taskLower.includes(kw)) {
-        score += kw.split(/\s+/).length;
-      }
-    }
-    if (score > bestScore) {
-      bestScore = score;
-      bestSpec = spec;
-    }
-  }
-  if (bestSpec === void 0) return null;
-  return {
-    category: bestSpec.category,
-    primaryCli: bestSpec.primaryCli,
-    secondaryCli: bestSpec.secondaryCli,
-    bonus: bestSpec.bonus
-  };
-}
-
 // src/cli-adapters/routing/stages/capability-match-stage.ts
 var CLI_CAPABILITIES = {
   claude: { reasoning: 10, codeGeneration: 8, speed: 5, costEfficiency: 3 },
@@ -9933,7 +10002,11 @@ var CompositeRouterConfigSchema = z11.object({
   budgetConstraints: z11.object({
     maxTokens: z11.number().positive(),
     maxCostUsd: z11.number().positive(),
-    maxLatencyMs: z11.number().positive()
+    maxLatencyMs: z11.number().positive(),
+    /** Per-task-class cost ceilings in USD, keyed by TaskCategory (#4196).
+     * Default: absent → no ceiling (OFF/unlimited). Enforced only under
+     * billingMode 'api'; missing candidate pricing fails CLOSED. */
+    taskClassMaxCostUsd: z11.record(z11.string(), z11.number().positive())
   }).partial().optional(),
   /** LinUCB exploration parameter (default: 1.0) */
   linucbAlpha: z11.number().positive().default(1),
@@ -10013,6 +10086,7 @@ function calculateConfidence(topsisScore, ucbScore, candidateCount) {
   const avgScore = scores.reduce((a, b) => a + b, 0) / scores.length;
   return 0.3 * baseConfidence + 0.7 * avgScore;
 }
+var PLAN_MODE_COST_ANNOTATION = "cost weighting disabled: plan mode";
 function buildReason(options) {
   const { selectedCli, stages, topsisScore, ucbScore, preferenceScore, difficultyTier } = options;
   const difficultyScore = options.difficultyScore;
@@ -10024,6 +10098,7 @@ function buildReason(options) {
   if (preferenceScore !== void 0) parts.push("preference " + preferenceScore.toFixed(2));
   if (topsisScore !== void 0) parts.push("TOPSIS score " + topsisScore.toFixed(2));
   if (ucbScore !== void 0) parts.push("UCB score " + ucbScore.toFixed(2));
+  if (options.billingMode === "plan") parts.push(PLAN_MODE_COST_ANNOTATION);
   return parts.join(", ");
 }
 function filterByPreferenceTier(candidates, tier) {
@@ -10041,9 +10116,7 @@ function cliTaskToTask(cliTask) {
   };
 }
 function applyBudgetFilter(task, candidates, budgetRouter, config) {
-  if (budgetRouter === void 0) {
-    return { eligible: candidates, withinBudget: true };
-  }
+  if (budgetRouter === void 0) return { eligible: candidates, withinBudget: true };
   const rawConstraints = config.budgetConstraints;
   const constraint = {};
   if (rawConstraints?.maxTokens !== void 0) {
@@ -10056,21 +10129,18 @@ function applyBudgetFilter(task, candidates, budgetRouter, config) {
     constraint.maxLatencyMs = rawConstraints.maxLatencyMs;
   }
   const result = budgetRouter.checkBudget(task, constraint);
-  return { eligible: result.withinBudget ? candidates : [], withinBudget: result.withinBudget };
+  if (!result.withinBudget) return { eligible: [], withinBudget: false };
+  if (config.billingMode !== "api") return { eligible: candidates, withinBudget: true };
+  return { eligible: budgetRouter.filterByTaskClassCeiling(task, candidates), withinBudget: true };
 }
 var TOPSIS_TOLERANCE_BAND_PERCENT = 0.05;
-function selectTopsisRouter(router, billingMode, taskType) {
-  if (taskType !== void 0) {
-    const mode = billingMode === "plan" ? "plan" : "api";
-    const criteria = getCriteriaForTaskCategory(taskType, mode);
-    const defaultCriteria = mode === "plan" ? PLAN_BILLING_TOPSIS_CRITERIA : DEFAULT_TOPSIS_CRITERIA;
-    if (criteria !== defaultCriteria) {
-      return new TopsisRouter({ criteria });
-    }
-  }
-  if (billingMode === "plan") {
-    return new TopsisRouter({ criteria: PLAN_BILLING_TOPSIS_CRITERIA });
-  }
+function selectTopsisRouter(router, billingMode, taskType, reasoningComplexity) {
+  const mode = billingMode === "plan" ? "plan" : "api";
+  const defaultCriteria = mode === "plan" ? PLAN_BILLING_TOPSIS_CRITERIA : DEFAULT_TOPSIS_CRITERIA;
+  const base = taskType !== void 0 ? getCriteriaForTaskCategory(taskType, mode) : defaultCriteria;
+  const criteria = mode === "api" && reasoningComplexity !== void 0 ? applyDifficultyCostWeighting(base, reasoningComplexity) : base;
+  if (criteria !== defaultCriteria) return new TopsisRouter({ criteria });
+  if (mode === "plan") return new TopsisRouter({ criteria: PLAN_BILLING_TOPSIS_CRITERIA });
   return router;
 }
 var PERFORMANCE_FLOOR_THRESHOLD = 0.5;
@@ -10125,7 +10195,12 @@ function applyTopsisRanking(taskProfile, candidates, topsisRouter, options) {
     return { ranking: candidates, topScore: 1 };
   }
   const billingMode = options?.billingMode ?? "api";
-  const router = selectTopsisRouter(topsisRouter, billingMode, taskProfile.taskType);
+  const router = selectTopsisRouter(
+    topsisRouter,
+    billingMode,
+    taskProfile.taskType,
+    taskProfile.reasoningComplexity
+  );
   const adjustedProfiles = buildAdjustedProfiles(taskProfile, candidates, options);
   const result = router.selectModel({ profiles: adjustedProfiles });
   const scoreMap = new Map(result.scores.map((s) => [s.cliName, s.closenessScore]));
@@ -10196,6 +10271,7 @@ function buildDecisionFields(ctx) {
   const reason = buildReason({
     selectedCli: ctx.selectedCli,
     stages: ctx.stagesExecuted,
+    ...ctx.billingMode !== void 0 ? { billingMode: ctx.billingMode } : {},
     ...ctx.topsisScore !== void 0 ? { topsisScore: ctx.topsisScore } : {},
     ...ctx.ucbScore !== void 0 ? { ucbScore: ctx.ucbScore } : {},
     ...ctx.preferenceScore !== void 0 ? { preferenceScore: ctx.preferenceScore } : {},
@@ -13864,7 +13940,7 @@ var CompositeRouter = class _CompositeRouter {
   }
   initializeCoreRouters(adapters, preferenceConfig, zeroConfig, latencyConfig) {
     if (this.config.enableBudgetFilter && adapters.size > 0) {
-      this.budgetRouter = new BudgetRouter(adapters);
+      this.budgetRouter = this.buildBudgetRouter(adapters);
     }
     if (this.config.enableZeroRouter) this.zeroRouter = new ZeroRouter(zeroConfig, this.logger);
     if (this.config.enablePreferenceRouting)
@@ -13876,6 +13952,12 @@ var CompositeRouter = class _CompositeRouter {
     }
     if (this.config.enableLatencyTracking) this.latencyTracker = new LatencyTracker(latencyConfig);
   }
+  /** #4196: plumb per-task-class cost ceilings into the BudgetRouter.
+   * Absent → defaults (no ceiling configured). */
+  buildBudgetRouter(adapters) {
+    const ceilings = this.config.budgetConstraints?.taskClassMaxCostUsd;
+    return ceilings !== void 0 ? new BudgetRouter(adapters, { taskClassCostCeilings: ceilings }) : new BudgetRouter(adapters);
+  }
   initializeMemoryAndStages(routingMemoryConfig, stageConfigs) {
     if (this.config.enableRoutingMemory) {
       this.routingMemory = new RoutingMemory(routingMemoryConfig);
@@ -13994,7 +14076,7 @@ var CompositeRouter = class _CompositeRouter {
    */
   async consultUnifiedContext(task) {
     try {
-      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-CEVBKMKI.js");
+      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-ZQXEWMHS.js");
       const ctx = await getContextForTask({
         task: task.content,
         category: inferTaskCategory(task.content),
@@ -14218,7 +14300,11 @@ var CompositeRouter = class _CompositeRouter {
     }
     const decisionTimeMs = getTimeProvider().now() - params.startTime;
     this.updateStats(params.selectedCli, decisionTimeMs);
-    const { confidence, reason, alternatives } = buildDecisionFields({ ...params, decisionTimeMs });
+    const { confidence, reason, alternatives } = buildDecisionFields({
+      ...params,
+      decisionTimeMs,
+      billingMode: this.config.billingMode
+    });
     const model = isRouteModelSelectionEnabled() && params.difficultyTier !== void 0 ? resolveModelForTier(routingArmDisplaySlot(params.selectedCli), params.difficultyTier) : void 0;
     return ok({
       adapter: selectedAdapter,
@@ -15499,4 +15585,4 @@ export {
   AgentCapability,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-X2K6JQXF.js.map
+//# sourceMappingURL=chunk-A4XTT4AG.js.map