nexus-agents 2.58.0 → 2.59.0

package/dist/{chunk-7EYQBG3W.js → chunk-7USAZET2.js}

@@ -35,7 +35,7 @@ import {
 } from "./chunk-CLYZ7FWP.js";
 
 // src/version.ts
-var VERSION = true ? "2.58.0" : "dev";
+var VERSION = true ? "2.59.0" : "dev";
 
 // src/config/schemas-core.ts
 import { z } from "zod";
@@ -2024,7 +2024,7 @@ async function runDoctorFix(result) {
   writeLine2("\u2500".repeat(40));
   let fixCount = 0;
   if (!result.dataDirectory.rootExists || result.dataDirectory.subdirectories.some((d) => !d.exists || !d.writable)) {
-    const { runSetup } = await import("./setup-command-KSQEYBDA.js");
+    const { runSetup } = await import("./setup-command-QAGEWX7G.js");
     const setupResult = runSetup({
       skipMcp: true,
       skipRules: true,
@@ -2133,4 +2133,4 @@ export {
   startStdioServer,
   closeServer
 };
-//# sourceMappingURL=chunk-7EYQBG3W.js.map
+//# sourceMappingURL=chunk-7USAZET2.js.map

package/dist/{chunk-JLYJQ7OG.js → chunk-V2Z7EHSY.js}

@@ -65,7 +65,7 @@ import {
   clampTaskTtl,
   getAvailabilityCache,
   resolveFallback
-} from "./chunk-7EYQBG3W.js";
+} from "./chunk-7USAZET2.js";
 import {
   DEFAULTS
 } from "./chunk-H43PABG4.js";
@@ -23437,10 +23437,10 @@ function calculateZStatistic(params) {
 function calculateDifferenceCI(p1, p2, total1, total2, confidence) {
   const difference = p1 - p2;
   const seDiff = Math.sqrt(p1 * (1 - p1) / (total1 || 1) + p2 * (1 - p2) / (total2 || 1));
-  const z103 = getZScore(confidence);
+  const z104 = getZScore(confidence);
   return {
-    lower: difference - z103 * seDiff,
-    upper: difference + z103 * seDiff,
+    lower: difference - z104 * seDiff,
+    upper: difference + z104 * seDiff,
     estimate: difference,
     confidence,
     n: total1 + total2,
@@ -23463,11 +23463,11 @@ function proportionConfidenceInterval(successes, total, options = {}) {
       standardError: 0
     };
   }
-  const z103 = getZScore(opts.confidence);
-  const z210 = z103 * z103;
+  const z104 = getZScore(opts.confidence);
+  const z210 = z104 * z104;
   const denominator = 1 + z210 / n;
   const center = (p + z210 / (2 * n)) / denominator;
-  const margin = z103 / denominator * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
+  const margin = z104 / denominator * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
   const lower = Math.max(0, center - margin);
   const upper = Math.min(1, center + margin);
   const standardError = Math.sqrt(p * (1 - p) / n);
@@ -23497,8 +23497,8 @@ function meanConfidenceInterval(values, options = {}) {
   const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / (n - 1 || 1);
   const stdDev = Math.sqrt(variance);
   const standardError = stdDev / Math.sqrt(n);
-  const z103 = getZScore(opts.confidence);
-  const margin = z103 * standardError;
+  const z104 = getZScore(opts.confidence);
+  const margin = z104 * standardError;
   return {
     lower: mean - margin,
     upper: mean + margin,
@@ -43776,6 +43776,29 @@ function registerPipelineTool(server, _deps) {
   });
 }
 
+// src/mcp/tools/supply-chain-tradeoff-panel.ts
+import { z as z94 } from "zod";
+var DEFAULT_AXES = [
+  "build_time_determinism",
+  "supply_chain_risk",
+  "update_cadence"
+];
+var MAX_AXES = 6;
+var MAX_AXIS_NAME_LENGTH = 64;
+var MAX_PROPOSAL_LENGTH = 4e3;
+var MAX_CONTEXT_LENGTH = 4e3;
+var SupplyChainTradeoffPanelInputSchema = z94.object({
+  proposal: z94.string().min(1).max(MAX_PROPOSAL_LENGTH).describe('The proposal under tradeoff review (e.g. "Should aegis-boot adopt cargo-nextest?")'),
+  axes: z94.array(z94.string().min(1).max(MAX_AXIS_NAME_LENGTH)).min(1).max(MAX_AXES).optional().describe(
+    `Tradeoff axes to evaluate. Default: ${DEFAULT_AXES.join(", ")}. Custom axes accepted; max ${String(MAX_AXES)}.`
+  ),
+  context: z94.string().max(MAX_CONTEXT_LENGTH).optional().describe(
+    "Optional context: relevant repo state, dependency tree, vendor publishing patterns, etc."
+  ),
+  quickMode: z94.boolean().optional().default(false).describe("Use 3 voters (architect, security, scope_steward) instead of 7"),
+  simulate: z94.boolean().optional().default(false).describe("Use simulated voters (testing only)")
+});
+
 // src/mcp/tools/tool-annotations.ts
 var TOOL_ANNOTATIONS = {
   delegate_to_model: {
@@ -44194,7 +44217,8 @@ function registerTools(server, options) {
       "search_codebase",
       "run_dev_pipeline",
       "run_pipeline",
-      "pr_review"
+      "pr_review",
+      "supply_chain_tradeoff_panel"
     ],
     logger: logger56,
     rateLimiter
@@ -44322,40 +44346,40 @@ var RiskLevel = /* @__PURE__ */ ((RiskLevel2) => {
 })(RiskLevel || {});
 
 // src/mcp/safety/stpa-schemas.ts
-import { z as z94 } from "zod";
-var HazardCategorySchema = z94.enum(HazardCategory);
-var HazardSeveritySchema = z94.enum(HazardSeverity);
-var ConstraintPrioritySchema = z94.enum(ConstraintPriority);
-var RiskLevelSchema = z94.enum(RiskLevel);
-var TriggerPatternSchema = z94.object({
-  parameter: z94.string().min(1),
-  matchType: z94.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
-  pattern: z94.string(),
-  reason: z94.string()
+import { z as z95 } from "zod";
+var HazardCategorySchema = z95.enum(HazardCategory);
+var HazardSeveritySchema = z95.enum(HazardSeverity);
+var ConstraintPrioritySchema = z95.enum(ConstraintPriority);
+var RiskLevelSchema = z95.enum(RiskLevel);
+var TriggerPatternSchema = z95.object({
+  parameter: z95.string().min(1),
+  matchType: z95.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
+  pattern: z95.string(),
+  reason: z95.string()
 });
-var HazardSchema = z94.object({
-  id: z94.string().min(1),
-  description: z94.string(),
+var HazardSchema = z95.object({
+  id: z95.string().min(1),
+  description: z95.string(),
   category: HazardCategorySchema,
   severity: HazardSeveritySchema,
-  likelihood: z94.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
-  triggerConditions: z94.array(z94.string()),
-  consequences: z94.array(z94.string())
+  likelihood: z95.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
+  triggerConditions: z95.array(z95.string()),
+  consequences: z95.array(z95.string())
 });
-var UnsafeControlActionSchema = z94.object({
-  id: z94.string().min(1),
-  toolName: z94.string().min(1),
-  type: z94.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
-  description: z94.string(),
-  unsafeContext: z94.string(),
-  relatedHazards: z94.array(z94.string()),
-  triggerPatterns: z94.array(TriggerPatternSchema).optional()
+var UnsafeControlActionSchema = z95.object({
+  id: z95.string().min(1),
+  toolName: z95.string().min(1),
+  type: z95.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
+  description: z95.string(),
+  unsafeContext: z95.string(),
+  relatedHazards: z95.array(z95.string()),
+  triggerPatterns: z95.array(TriggerPatternSchema).optional()
 });
-var SafetyConstraintSchema = z94.object({
-  id: z94.string().min(1),
-  description: z94.string(),
-  mitigates: z94.array(z94.string()),
-  enforcement: z94.enum([
+var SafetyConstraintSchema = z95.object({
+  id: z95.string().min(1),
+  description: z95.string(),
+  mitigates: z95.array(z95.string()),
+  enforcement: z95.enum([
     "prevent",
     "require_confirmation",
     "alert",
@@ -44363,54 +44387,54 @@ var SafetyConstraintSchema = z94.object({
     "rate_limit",
     "require_privilege"
   ]),
-  validationFunction: z94.string().optional(),
+  validationFunction: z95.string().optional(),
   priority: ConstraintPrioritySchema
 });
-var PropertySchemaSchema = z94.object({
-  type: z94.string(),
-  description: z94.string().optional(),
-  enum: z94.array(z94.unknown()).optional(),
-  pattern: z94.string().optional(),
-  minimum: z94.number().optional(),
-  maximum: z94.number().optional()
+var PropertySchemaSchema = z95.object({
+  type: z95.string(),
+  description: z95.string().optional(),
+  enum: z95.array(z95.unknown()).optional(),
+  pattern: z95.string().optional(),
+  minimum: z95.number().optional(),
+  maximum: z95.number().optional()
 });
-var ToolInputSchemaSchema = z94.object({
-  type: z94.string(),
-  properties: z94.record(z94.string(), PropertySchemaSchema).optional(),
-  required: z94.array(z94.string()).optional(),
-  additionalProperties: z94.boolean().optional()
+var ToolInputSchemaSchema = z95.object({
+  type: z95.string(),
+  properties: z95.record(z95.string(), PropertySchemaSchema).optional(),
+  required: z95.array(z95.string()).optional(),
+  additionalProperties: z95.boolean().optional()
 });
-var ToolDefinitionSchema = z94.object({
-  name: z94.string().min(1),
-  description: z94.string(),
+var ToolDefinitionSchema = z95.object({
+  name: z95.string().min(1),
+  description: z95.string(),
   inputSchema: ToolInputSchemaSchema
 });
-var AnalysisConfigurationSchema = z94.object({
-  includeLowSeverity: z94.boolean().default(true),
-  generateAllConstraints: z94.boolean().default(true),
-  checkInteractions: z94.boolean().default(true),
-  maxHazardsPerTool: z94.number().int().min(1).max(100).default(50),
-  categories: z94.array(HazardCategorySchema).default([])
+var AnalysisConfigurationSchema = z95.object({
+  includeLowSeverity: z95.boolean().default(true),
+  generateAllConstraints: z95.boolean().default(true),
+  checkInteractions: z95.boolean().default(true),
+  maxHazardsPerTool: z95.number().int().min(1).max(100).default(50),
+  categories: z95.array(HazardCategorySchema).default([])
 });
-var ConstraintViolationSchema = z94.object({
-  constraintId: z94.string().min(1),
-  constraintDescription: z94.string(),
+var ConstraintViolationSchema = z95.object({
+  constraintId: z95.string().min(1),
+  constraintDescription: z95.string(),
   severity: HazardSeveritySchema,
-  details: z94.string(),
-  remediation: z94.string()
+  details: z95.string(),
+  remediation: z95.string()
 });
-var ValidationWarningSchema = z94.object({
-  code: z94.string().min(1),
-  message: z94.string(),
-  affected: z94.string()
+var ValidationWarningSchema = z95.object({
+  code: z95.string().min(1),
+  message: z95.string(),
+  affected: z95.string()
 });
-var ValidationResultSchema = z94.object({
-  valid: z94.boolean(),
-  toolName: z94.string().min(1),
-  violations: z94.array(ConstraintViolationSchema),
-  passed: z94.array(z94.string()),
-  warnings: z94.array(ValidationWarningSchema),
-  validatedAt: z94.date()
+var ValidationResultSchema = z95.object({
+  valid: z95.boolean(),
+  toolName: z95.string().min(1),
+  violations: z95.array(ConstraintViolationSchema),
+  passed: z95.array(z95.string()),
+  warnings: z95.array(ValidationWarningSchema),
+  validatedAt: z95.date()
 });
 
 // src/mcp/safety/stpa-types.ts
@@ -45495,22 +45519,22 @@ var GeminiResponseParser = class {
 };
 
 // src/cli-adapters/task-analyzer.ts
-import { z as z95 } from "zod";
-var TaskProfileSchema = z95.object({
+import { z as z96 } from "zod";
+var TaskProfileSchema = z96.object({
   /** Estimated input tokens required */
-  contextRequired: z95.number().min(0),
+  contextRequired: z96.number().min(0),
   /** Reasoning complexity on 0-10 scale */
-  reasoningComplexity: z95.number().min(0).max(10),
+  reasoningComplexity: z96.number().min(0).max(10),
   /** Whether task involves code generation */
-  codeGeneration: z95.boolean(),
+  codeGeneration: z96.boolean(),
   /** Whether task involves multimodal content (images, etc.) */
-  multimodal: z95.boolean(),
+  multimodal: z96.boolean(),
   /** Whether task can be split into parallel subtasks */
-  parallelizable: z95.boolean(),
+  parallelizable: z96.boolean(),
   /** Whether cost should be minimized */
-  budgetSensitive: z95.boolean(),
+  budgetSensitive: z96.boolean(),
   /** Primary task type classification */
-  taskType: z95.enum([
+  taskType: z96.enum([
     "architecture",
     "code_implementation",
     "code_review",
@@ -45524,53 +45548,53 @@ var TaskProfileSchema = z95.object({
 });
 
 // src/cli-adapters/router-types.ts
-import { z as z96 } from "zod";
-var RouterConfigSchema = z96.object({
-  minCapacityThreshold: z96.number().min(0).max(1).default(0.1),
-  preferCostEfficient: z96.boolean().default(false),
-  maxDecisionTimeMs: z96.number().min(1).max(1e3).default(100)
+import { z as z97 } from "zod";
+var RouterConfigSchema = z97.object({
+  minCapacityThreshold: z97.number().min(0).max(1).default(0.1),
+  preferCostEfficient: z97.boolean().default(false),
+  maxDecisionTimeMs: z97.number().min(1).max(1e3).default(100)
 });
 
 // src/cli-adapters/agreement-cascade-types.ts
-import { z as z97 } from "zod";
-var AgreementCascadeConfigSchema = z97.object({
-  agreementThreshold: z97.number().min(0.5).max(1).default(0.7),
-  maxStages: z97.number().int().min(1).max(5).default(3),
-  modelTimeoutMs: z97.number().int().min(1e3).max(3e5).default(6e4)
+import { z as z98 } from "zod";
+var AgreementCascadeConfigSchema = z98.object({
+  agreementThreshold: z98.number().min(0.5).max(1).default(0.7),
+  maxStages: z98.number().int().min(1).max(5).default(3),
+  modelTimeoutMs: z98.number().int().min(1e3).max(3e5).default(6e4)
 });
 
 // src/cli-adapters/agreement-cascade-router.ts
 var logger42 = createLogger({ component: "agreement-cascade-router" });
 
 // src/cli-adapters/daao-types.ts
-import { z as z98 } from "zod";
-var EncodedFeaturesSchema = z98.object({
+import { z as z99 } from "zod";
+var EncodedFeaturesSchema = z99.object({
   /** Lexical complexity score (vocabulary diversity, rare words) */
-  lexicalComplexity: z98.number().min(0).max(1),
+  lexicalComplexity: z99.number().min(0).max(1),
   /** Syntactic complexity score (sentence structure, nesting) */
-  syntacticComplexity: z98.number().min(0).max(1),
+  syntacticComplexity: z99.number().min(0).max(1),
   /** Semantic density score (concept density, abstraction level) */
-  semanticDensity: z98.number().min(0).max(1),
+  semanticDensity: z99.number().min(0).max(1),
   /** Technical specificity (domain-specific terminology) */
-  technicalSpecificity: z98.number().min(0).max(1),
+  technicalSpecificity: z99.number().min(0).max(1),
   /** Task scope (breadth of requirements) */
-  taskScope: z98.number().min(0).max(1),
+  taskScope: z99.number().min(0).max(1),
   /** Constraint complexity (constraints, edge cases, requirements) */
-  constraintComplexity: z98.number().min(0).max(1),
+  constraintComplexity: z99.number().min(0).max(1),
   /** Ambiguity level (inverse - higher means more clear/specific) */
-  clarity: z98.number().min(0).max(1),
+  clarity: z99.number().min(0).max(1),
   /** Output complexity expectation */
-  outputComplexity: z98.number().min(0).max(1)
+  outputComplexity: z99.number().min(0).max(1)
 });
-var FeatureWeightsSchema = z98.object({
-  lexicalComplexity: z98.number().min(0).max(1),
-  syntacticComplexity: z98.number().min(0).max(1),
-  semanticDensity: z98.number().min(0).max(1),
-  technicalSpecificity: z98.number().min(0).max(1),
-  taskScope: z98.number().min(0).max(1),
-  constraintComplexity: z98.number().min(0).max(1),
-  clarity: z98.number().min(0).max(1),
-  outputComplexity: z98.number().min(0).max(1)
+var FeatureWeightsSchema = z99.object({
+  lexicalComplexity: z99.number().min(0).max(1),
+  syntacticComplexity: z99.number().min(0).max(1),
+  semanticDensity: z99.number().min(0).max(1),
+  technicalSpecificity: z99.number().min(0).max(1),
+  taskScope: z99.number().min(0).max(1),
+  constraintComplexity: z99.number().min(0).max(1),
+  clarity: z99.number().min(0).max(1),
+  outputComplexity: z99.number().min(0).max(1)
 });
 var DEFAULT_FEATURE_WEIGHTS = {
   lexicalComplexity: 0.1,
@@ -45592,50 +45616,50 @@ var DEFAULT_DAAO_TIER_TO_CLIS = {
   balanced: ["codex", "opencode", "gemini", "claude"],
   powerful: ["claude", "codex", "opencode", "gemini"]
 };
-var DAAOConfigSchema = z98.object({
+var DAAOConfigSchema = z99.object({
   /** Difficulty thresholds for level classification */
-  thresholds: z98.object({
-    easyUpperBound: z98.number().min(0).max(1),
-    hardLowerBound: z98.number().min(0).max(1)
+  thresholds: z99.object({
+    easyUpperBound: z99.number().min(0).max(1),
+    hardLowerBound: z99.number().min(0).max(1)
   }).default(DEFAULT_DAAO_THRESHOLDS),
   /** Feature weights for difficulty aggregation */
   weights: FeatureWeightsSchema.default(DEFAULT_FEATURE_WEIGHTS),
   /** Mapping from model tier to CLI preference order */
-  tierToClis: z98.record(
-    z98.enum(["fast", "balanced", "powerful"]),
-    z98.array(z98.enum(["claude", "gemini", "codex", "opencode"]))
+  tierToClis: z99.record(
+    z99.enum(["fast", "balanced", "powerful"]),
+    z99.array(z99.enum(["claude", "gemini", "codex", "opencode"]))
   ).default(DEFAULT_DAAO_TIER_TO_CLIS),
   /** Enable adaptive calibration from outcomes */
-  enableCalibration: z98.boolean().default(true),
+  enableCalibration: z99.boolean().default(true),
   /** Maximum outcomes to store for calibration */
-  maxCalibrationOutcomes: z98.number().int().positive().default(1e3),
+  maxCalibrationOutcomes: z99.number().int().positive().default(1e3),
   /** Minimum outcomes before applying calibration adjustments */
-  minCalibrationOutcomes: z98.number().int().positive().default(50),
+  minCalibrationOutcomes: z99.number().int().positive().default(50),
   /** Reconstruction error threshold for typical patterns */
-  typicalPatternThreshold: z98.number().min(0).max(1).default(0.3),
+  typicalPatternThreshold: z99.number().min(0).max(1).default(0.3),
   /** Verbose logging */
-  verbose: z98.boolean().default(false)
+  verbose: z99.boolean().default(false)
 });
 
 // src/cli-adapters/task-classifier.ts
-import { z as z99 } from "zod";
-var ClassificationPatternsSchema = z99.object({
-  code: z99.array(z99.string()).readonly(),
-  research: z99.array(z99.string()).readonly(),
-  documentation: z99.array(z99.string()).readonly(),
-  analysis: z99.array(z99.string()).readonly()
+import { z as z100 } from "zod";
+var ClassificationPatternsSchema = z100.object({
+  code: z100.array(z100.string()).readonly(),
+  research: z100.array(z100.string()).readonly(),
+  documentation: z100.array(z100.string()).readonly(),
+  analysis: z100.array(z100.string()).readonly()
 });
 
 // src/cli-adapters/response-cache-types.ts
-import { z as z100 } from "zod";
-var ResponseCacheConfigSchema = z100.object({
-  defaultTTL: z100.number().min(1e3).max(36e5).default(3e5),
+import { z as z101 } from "zod";
+var ResponseCacheConfigSchema = z101.object({
+  defaultTTL: z101.number().min(1e3).max(36e5).default(3e5),
   // 5 minutes
-  maxEntries: z100.number().min(10).max(1e5).default(1e3),
-  maxMemoryMB: z100.number().min(1).max(1e3).default(50),
-  cleanupInterval: z100.number().min(1e3).max(6e5).default(6e4),
+  maxEntries: z101.number().min(10).max(1e5).default(1e3),
+  maxMemoryMB: z101.number().min(1).max(1e3).default(50),
+  cleanupInterval: z101.number().min(1e3).max(6e5).default(6e4),
   // 1 minute
-  enableLogging: z100.boolean().default(false)
+  enableLogging: z101.boolean().default(false)
 });
 
 // src/cli-adapters/response-cache-utils.ts
@@ -45643,12 +45667,12 @@ import { createHash as createHash4 } from "crypto";
 var logger43 = createLogger({ component: "ResponseCacheUtils" });
 
 // src/cli-adapters/unified-routing-types.ts
-import { z as z101 } from "zod";
-var UnifiedRoutingDecisionSchema = z101.object({
-  selectedCli: z101.string(),
-  confidence: z101.number().min(0).max(1),
-  reason: z101.string(),
-  strategy: z101.enum([
+import { z as z102 } from "zod";
+var UnifiedRoutingDecisionSchema = z102.object({
+  selectedCli: z102.string(),
+  confidence: z102.number().min(0).max(1),
+  reason: z102.string(),
+  strategy: z102.enum([
     "composite",
     "quality",
     "budget",
@@ -45660,57 +45684,57 @@ var UnifiedRoutingDecisionSchema = z101.object({
     "linucb",
     "direct"
   ]),
-  decisionTimeMs: z101.number().nonnegative(),
-  alternatives: z101.array(z101.string()).readonly(),
-  stagesExecuted: z101.array(z101.string()).readonly(),
-  withinBudget: z101.boolean().optional(),
-  estimatedComplexity: z101.enum(["simple", "moderate", "complex", "expert"]).optional(),
-  estimatedTokens: z101.number().int().positive().optional(),
-  topsisScore: z101.number().optional(),
-  ucbScore: z101.number().optional(),
-  resolvedAtStage: z101.number().int().nonnegative().optional(),
-  consensusReached: z101.boolean().optional(),
-  agreementScore: z101.number().min(0).max(1).optional(),
-  metadata: z101.record(z101.string(), z101.unknown()).optional()
+  decisionTimeMs: z102.number().nonnegative(),
+  alternatives: z102.array(z102.string()).readonly(),
+  stagesExecuted: z102.array(z102.string()).readonly(),
+  withinBudget: z102.boolean().optional(),
+  estimatedComplexity: z102.enum(["simple", "moderate", "complex", "expert"]).optional(),
+  estimatedTokens: z102.number().int().positive().optional(),
+  topsisScore: z102.number().optional(),
+  ucbScore: z102.number().optional(),
+  resolvedAtStage: z102.number().int().nonnegative().optional(),
+  consensusReached: z102.boolean().optional(),
+  agreementScore: z102.number().min(0).max(1).optional(),
+  metadata: z102.record(z102.string(), z102.unknown()).optional()
 });
 
 // src/learning/outcome-feedback-types.ts
-import { z as z102 } from "zod";
-var QualitySignalsSchema = z102.object({
-  testsPass: z102.boolean().optional(),
-  lintErrors: z102.number().int().min(0).optional(),
-  userApproved: z102.boolean().optional(),
-  retryCount: z102.number().int().min(0).default(0),
-  completionRatio: z102.number().min(0).max(1).default(1),
-  validStructure: z102.boolean().optional(),
-  coherenceScore: z102.number().min(0).max(1).optional()
+import { z as z103 } from "zod";
+var QualitySignalsSchema = z103.object({
+  testsPass: z103.boolean().optional(),
+  lintErrors: z103.number().int().min(0).optional(),
+  userApproved: z103.boolean().optional(),
+  retryCount: z103.number().int().min(0).default(0),
+  completionRatio: z103.number().min(0).max(1).default(1),
+  validStructure: z103.boolean().optional(),
+  coherenceScore: z103.number().min(0).max(1).optional()
 });
-var RoutingDecisionSchema = z102.object({
-  id: z102.uuid(),
-  timestamp: z102.iso.datetime(),
-  query: z102.string(),
-  routerType: z102.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
-  selectedModel: z102.string(),
-  selectedTier: z102.enum(["strong", "weak"]).optional(),
-  armIndex: z102.number().int().min(0).optional(),
-  banditContext: z102.record(z102.string(), z102.unknown()).optional(),
-  queryFeatures: z102.record(z102.string(), z102.unknown()).optional(),
-  ucbScore: z102.number().optional(),
-  confidence: z102.number().min(0).max(1).optional(),
-  traceId: z102.string(),
-  domain: z102.string().optional()
+var RoutingDecisionSchema = z103.object({
+  id: z103.uuid(),
+  timestamp: z103.iso.datetime(),
+  query: z103.string(),
+  routerType: z103.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
+  selectedModel: z103.string(),
+  selectedTier: z103.enum(["strong", "weak"]).optional(),
+  armIndex: z103.number().int().min(0).optional(),
+  banditContext: z103.record(z103.string(), z103.unknown()).optional(),
+  queryFeatures: z103.record(z103.string(), z103.unknown()).optional(),
+  ucbScore: z103.number().optional(),
+  confidence: z103.number().min(0).max(1).optional(),
+  traceId: z103.string(),
+  domain: z103.string().optional()
 });
-var TaskOutcomeSchema = z102.object({
-  routingDecisionId: z102.uuid(),
-  timestamp: z102.iso.datetime(),
-  outcomeClass: z102.enum(["success", "partial", "failure", "timeout", "error"]),
-  success: z102.boolean(),
-  qualityScore: z102.number().min(0).max(1),
-  durationMs: z102.number().min(0),
-  tokenUsage: z102.number().int().min(0),
-  errorMessage: z102.string().optional(),
+var TaskOutcomeSchema = z103.object({
+  routingDecisionId: z103.uuid(),
+  timestamp: z103.iso.datetime(),
+  outcomeClass: z103.enum(["success", "partial", "failure", "timeout", "error"]),
+  success: z103.boolean(),
+  qualityScore: z103.number().min(0).max(1),
+  durationMs: z103.number().min(0),
+  tokenUsage: z103.number().int().min(0),
+  errorMessage: z103.string().optional(),
   qualitySignals: QualitySignalsSchema,
-  traceId: z102.string()
+  traceId: z103.string()
 });
 var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   maxPendingDecisions: 1e3,
@@ -45725,17 +45749,17 @@ var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   targetTokenUsage: 2e3,
   maxHistorySize: 1e4
 };
-var FeedbackCollectorConfigSchema = z102.object({
-  maxPendingDecisions: z102.number().int().positive().default(1e3),
-  pendingTimeoutMs: z102.number().positive().default(3e5),
-  enableAutoReward: z102.boolean().default(true),
-  qualityWeight: z102.number().min(0).max(1).default(0.5),
-  speedWeight: z102.number().min(0).max(1).default(0.2),
-  efficiencyWeight: z102.number().min(0).max(1).default(0.2),
-  retryPenalty: z102.number().min(0).max(1).default(0.1),
-  targetDurationMs: z102.number().positive().default(5e3),
-  targetTokenUsage: z102.number().positive().default(2e3),
-  maxHistorySize: z102.number().int().positive().default(1e4)
+var FeedbackCollectorConfigSchema = z103.object({
+  maxPendingDecisions: z103.number().int().positive().default(1e3),
+  pendingTimeoutMs: z103.number().positive().default(3e5),
+  enableAutoReward: z103.boolean().default(true),
+  qualityWeight: z103.number().min(0).max(1).default(0.5),
+  speedWeight: z103.number().min(0).max(1).default(0.2),
+  efficiencyWeight: z103.number().min(0).max(1).default(0.2),
+  retryPenalty: z103.number().min(0).max(1).default(0.1),
+  targetDurationMs: z103.number().positive().default(5e3),
+  targetTokenUsage: z103.number().positive().default(2e3),
+  maxHistorySize: z103.number().int().positive().default(1e4)
 });
 
 // src/learning/outcome-feedback-helpers.ts
@@ -53643,4 +53667,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-JLYJQ7OG.js.map
+//# sourceMappingURL=chunk-V2Z7EHSY.js.map