nexus-agents 2.162.1 → 2.164.0

package/dist/{chunk-WGDZFYP3.js → chunk-N6WRMZYA.js}

@@ -1,8 +1,9 @@
 import {
   ensureLearningDir,
   getDecisionCostFile,
+  getModelSelectionShadowFile,
   isPersistenceEnabled
-} from "./chunk-NL7SZQPW.js";
+} from "./chunk-AXTD4TFK.js";
 import {
   nexusDataPath
 } from "./chunk-DHVMSIT5.js";
@@ -1499,6 +1500,12 @@ var DEFAULT_MODEL_PER_CLI = {
   codex: "gpt-5.5",
   opencode: "opencode-default"
 };
+var STATIC_CLI_COST_PER_1M = {
+  claude: { input: 3, output: 15 },
+  gemini: { input: 0.075, output: 0.3 },
+  codex: { input: 2.5, output: 10 },
+  opencode: { input: 2, output: 8 }
+};
 
 // src/config/model-derivation.ts
 var DEFAULT_ENTRY = {
@@ -2612,7 +2619,7 @@ function setDefaultRegistry(registry) {
 }
 async function reloadDefaultRegistry() {
   globalRegistry = buildDefaultRegistry();
-  const { resetGlobalRegistry } = await import("./unified-registry-XEA2GEOZ.js");
+  const { resetGlobalRegistry } = await import("./unified-registry-GLVZZGSC.js");
   resetGlobalRegistry();
   return globalRegistry;
 }
@@ -2642,6 +2649,14 @@ function getDefaultModelForCli(cli) {
   if (registry === void 0) return staticDefault;
   return registry.getEntry(staticDefault).id;
 }
+function resolveModelCostPer1M(modelId, fallback) {
+  const pricing = getModelPricing(modelId);
+  if (pricing === void 0) return fallback;
+  return { input: pricing.inputPer1M, output: pricing.outputPer1M };
+}
+function resolveCliCostPer1M(cli) {
+  return resolveModelCostPer1M(getDefaultModelForCli(cli), STATIC_CLI_COST_PER_1M[cli]);
+}
 function getCliModelName(modelId) {
   const entry = lookupInTree(modelId);
   return entry?.cliModelName ?? entry?.cliAlias ?? modelId;
@@ -2692,9 +2707,10 @@ function buildTopsisProfiles() {
   for (const [cli, modelId] of Object.entries(DEFAULT_MODEL_PER_CLI)) {
     const entry = byId.get(modelId);
     const q = entry?.qualityScores;
-    const p = entry?.pricing;
-    if (entry === void 0 || q === void 0 || p === void 0) continue;
+    if (entry === void 0 || q === void 0) continue;
     if (entry.contextWindow === void 0) continue;
+    const p = entry.pricing;
+    const price = p !== void 0 ? { input: p.inputPer1M, output: p.outputPer1M } : STATIC_CLI_COST_PER_1M[cli];
     profiles.push({
       cliName: cli,
       capabilities: {
@@ -2704,8 +2720,8 @@ function buildTopsisProfiles() {
         speed: q.speed,
         cost: q.cost
       },
-      costPerMillionInput: p.inputPer1M,
-      costPerMillionOutput: p.outputPer1M,
+      costPerMillionInput: price.input,
+      costPerMillionOutput: price.output,
       averageLatencyMs: cliAvgLatency()[cli],
       qualityScore: (q.reasoning + q.codeGeneration) / 2
     });
@@ -5356,17 +5372,11 @@ var RoutingMemoryError = class extends Error {
 };
 
 // src/cli-adapters/budget-utils.ts
-var TOKEN_COSTS = {
-  claude: { input: 3, output: 15 },
-  gemini: { input: 0.075, output: 0.3 },
-  codex: { input: 2.5, output: 10 },
-  opencode: { input: 2, output: 8 }
-};
 function estimateTokens2(content) {
   return Math.ceil(content.length / 4);
 }
 function estimateCost(model, inputTokens, outputTokens) {
-  const costs = TOKEN_COSTS[model];
+  const costs = resolveCliCostPer1M(model);
   const inputCost = inputTokens / 1e6 * costs.input;
   const outputCost = outputTokens / 1e6 * costs.output;
   return inputCost + outputCost;
@@ -9018,14 +9028,14 @@ function detectSuccessPatterns(groups, threshold) {
   const patterns = [];
   for (const g of groups) {
     const successCount = g.outcomes.filter((o) => o.success).length;
-    const successRate2 = successCount / g.outcomes.length;
-    if (successRate2 >= threshold) {
+    const successRate3 = successCount / g.outcomes.length;
+    if (successRate3 >= threshold) {
       patterns.push({
         cli: g.cli,
         category: g.category,
         patternType: "success-rate",
         action: "boost",
-        metric: successRate2,
+        metric: successRate3,
         observationCount: g.outcomes.length
       });
     }
@@ -9218,10 +9228,10 @@ var StrategyDistiller = class {
   }
   /** Convert rule metrics into ModelPerformance for RoutingMemory. */
   ruleToPerformance(rule) {
-    const successRate2 = rule.patternType === "success-rate" ? rule.metric : 1 - rule.metric;
+    const successRate3 = rule.patternType === "success-rate" ? rule.metric : 1 - rule.metric;
     return {
       avgQuality: rule.confidence,
-      successRate: Math.max(0, Math.min(1, successRate2)),
+      successRate: Math.max(0, Math.min(1, successRate3)),
       avgLatencyMs: 0,
       avgTokens: 0,
       observations: rule.observationCount
@@ -12419,9 +12429,9 @@ function getAdaptiveBonus(cli, category, config) {
   const cliName = cli;
   const outcomes = queryWithLookback(store, cliName, category, cfg);
   if (outcomes.length < cfg.coldStartThreshold) return 0;
-  const successRate2 = outcomes.filter((o) => o.success).length / outcomes.length;
+  const successRate3 = outcomes.filter((o) => o.success).length / outcomes.length;
   const FIXED_BASELINE = 0.7;
-  const delta = successRate2 - FIXED_BASELINE;
+  const delta = successRate3 - FIXED_BASELINE;
   const FULL_CONFIDENCE_SAMPLES2 = 50;
   const windowedConfidence = Math.min(1, outcomes.length / FULL_CONFIDENCE_SAMPLES2);
   const maxBonus = Math.min(cfg.maxBonusAdjustment * windowedConfidence, cfg.maxBonusAdjustment);
@@ -12696,17 +12706,17 @@ function buildExpertPerformance() {
     const successes = outcomes.filter((o) => o.success).length;
     const totalDuration = outcomes.reduce((s, o) => s + o.durationMs, 0);
     const dominantErrorPattern = findDominantError(outcomes.filter((o) => !o.success));
-    const successRate2 = successes / outcomes.length;
+    const successRate3 = successes / outcomes.length;
     const consecutiveFailures = countTrailingFailures(outcomes);
     const lastSuccess = [...outcomes].reverse().find((o) => o.success);
     const lastSuccessAt = lastSuccess !== void 0 ? new Date(lastSuccess.timestamp).toISOString() : void 0;
     entries.push({
       role,
       totalTasks: outcomes.length,
-      successRate: successRate2,
+      successRate: successRate3,
       avgDurationMs: Math.round(totalDuration / outcomes.length),
       consecutiveFailures,
-      degraded: successRate2 < 0.5,
+      degraded: successRate3 < 0.5,
       ...dominantErrorPattern !== void 0 ? { dominantErrorPattern } : {},
       ...lastSuccessAt !== void 0 ? { lastSuccessAt } : {}
     });
@@ -13686,6 +13696,169 @@ function resolveModelForTier(cliName, tier, opts = {}) {
   return scored[0]?.id ?? getDefaultModelForCli(cliName);
 }
 
+// src/cli-adapters/model-selection-shadow.ts
+import { appendFileSync as appendFileSync2, existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { z as z19 } from "zod";
+function isRouteModelShadowEnabled() {
+  return process.env["NEXUS_ROUTE_MODEL_SHADOW"] === "1" && isPersistenceEnabled();
+}
+var MODEL_SELECTION_SHADOW_SCHEMA_VERSION = 1;
+var READ_LOOKBACK_DAYS = 30;
+var READ_LOOKBACK_MS = READ_LOOKBACK_DAYS * 24 * 60 * 60 * 1e3;
+var ModelTierSchema = z19.enum(["fast", "balanced", "powerful"]);
+var ModelSelectionShadowRecordSchema = z19.object({
+  schema: z19.literal(MODEL_SELECTION_SHADOW_SCHEMA_VERSION),
+  /** ISO timestamp of the outcome join. */
+  timestamp: z19.string().min(1),
+  /** Display slot of the routed CLI (api:* arms collapse to their slot). */
+  cli: z19.string().min(1).max(40),
+  /** Difficulty tier the ZeroRouter computed for the task. */
+  tier: ModelTierSchema,
+  /** Model the live decision actually used (or the CLI default when route-time selection is off). */
+  actualModel: z19.string().min(1).max(120),
+  /** Model `resolveModelForTier` WOULD have picked (never executed). */
+  shadowModel: z19.string().min(1).max(120),
+  /** Whether shadow and actual agree. */
+  agree: z19.boolean(),
+  /** Whether the actually-executed decision succeeded. */
+  success: z19.boolean(),
+  /** Measured cost of the actual execution, when available (unmeasured today on the routing path). */
+  costUsd: z19.number().nonnegative().optional()
+});
+function computeModelSelectionShadow(cli, tier, actualModel) {
+  const shadowModel = resolveModelForTier(cli, tier);
+  const actual = actualModel ?? getDefaultModelForCli(cli);
+  return { cli, tier, actualModel: actual, shadowModel, agree: shadowModel === actual };
+}
+var shadowFailureCount = 0;
+function recordModelSelectionShadowFailure() {
+  return ++shadowFailureCount;
+}
+var persistLogger = createLogger({ component: "ModelSelectionShadow" });
+function persistModelSelectionShadowRecord(record) {
+  try {
+    ensureLearningDir();
+    appendFileSync2(getModelSelectionShadowFile(), JSON.stringify(record) + "\n", "utf-8");
+  } catch (err2) {
+    recordModelSelectionShadowFailure();
+    persistLogger.warn("Failed to persist model-selection shadow record (ignored)", {
+      error: getErrorMessage(err2)
+    });
+  }
+}
+function readModelSelectionShadowRecords() {
+  const file = getModelSelectionShadowFile();
+  if (!existsSync7(file)) return [];
+  const records = [];
+  try {
+    const cutoff = Date.now() - READ_LOOKBACK_MS;
+    const lines = readFileSync6(file, "utf-8").split("\n").filter((l) => l.trim().length > 0);
+    for (const line of lines) {
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const result = ModelSelectionShadowRecordSchema.safeParse(parsed);
+      if (!result.success) continue;
+      const ts = Date.parse(result.data.timestamp);
+      if (Number.isNaN(ts) || ts < cutoff) continue;
+      records.push(result.data);
+    }
+  } catch (err2) {
+    persistLogger.warn("Failed to read model-selection shadow records (ignored)", {
+      error: getErrorMessage(err2)
+    });
+  }
+  return records;
+}
+
+// src/cli-adapters/model-selection-readiness.ts
+var DEFAULT_MODEL_SELECTION_READINESS_CONFIG = {
+  minDivergingDecisions: 50,
+  minSuccessDelta: 0.05,
+  minCostSamples: 10
+};
+function successRate2(t) {
+  return t.count === 0 ? 0 : t.successes / t.count;
+}
+function summarizeModelSelectionShadow(records) {
+  const agree = { count: 0, successes: 0 };
+  const diverge = { count: 0, successes: 0 };
+  let costSamples = 0;
+  let costTotal = 0;
+  for (const r of records) {
+    const cohort = r.agree ? agree : diverge;
+    cohort.count++;
+    if (r.success) cohort.successes++;
+    if (r.costUsd !== void 0) {
+      costSamples++;
+      costTotal += r.costUsd;
+    }
+  }
+  const agreeSuccessRate = successRate2(agree);
+  const divergeSuccessRate = successRate2(diverge);
+  const successDelta = agree.count === 0 || diverge.count === 0 ? 0 : agreeSuccessRate - divergeSuccessRate;
+  return {
+    total: records.length,
+    agreeing: agree.count,
+    diverging: diverge.count,
+    agreeSuccessRate,
+    divergeSuccessRate,
+    successDelta,
+    costSamples,
+    meanCostUsd: costSamples === 0 ? 0 : costTotal / costSamples
+  };
+}
+function evaluateModelSelectionReadiness(records, config = DEFAULT_MODEL_SELECTION_READINESS_CONFIG) {
+  const s = summarizeModelSelectionShadow(records);
+  const criteria = [
+    {
+      name: "volume",
+      met: s.diverging >= config.minDivergingDecisions,
+      detail: `${String(s.diverging)} shadow-diverging decisions (need \u2265 ${String(config.minDivergingDecisions)})`
+    },
+    {
+      name: "success-delta",
+      met: s.successDelta >= config.minSuccessDelta,
+      detail: `agree\u2212diverge success delta ${s.successDelta.toFixed(2)} (agree ${s.agreeSuccessRate.toFixed(2)} over ${String(s.agreeing)}, diverge ${s.divergeSuccessRate.toFixed(2)} over ${String(s.diverging)}; need \u2265 ${config.minSuccessDelta.toFixed(2)})`
+    },
+    {
+      name: "cost-measured",
+      met: s.costSamples >= config.minCostSamples,
+      detail: `${String(s.costSamples)} decisions with measured costUsd, mean $${s.meanCostUsd.toFixed(4)} (need \u2265 ${String(config.minCostSamples)})`
+    }
+  ];
+  const blockers = criteria.filter((c) => !c.met).map((c) => c.name);
+  return { ready: blockers.length === 0, criteria, blockers };
+}
+var readinessLogged = false;
+function logModelSelectionReadinessOnce(logger14) {
+  if (readinessLogged) return;
+  readinessLogged = true;
+  try {
+    const records = readModelSelectionShadowRecords();
+    const summary = summarizeModelSelectionShadow(records);
+    const verdict = evaluateModelSelectionReadiness(records);
+    logger14.info("route-model-selection shadow readiness", {
+      ready: verdict.ready,
+      blockers: verdict.blockers,
+      total: summary.total,
+      diverging: summary.diverging,
+      successDelta: summary.successDelta,
+      agreeSuccessRate: summary.agreeSuccessRate,
+      divergeSuccessRate: summary.divergeSuccessRate,
+      costSamples: summary.costSamples,
+      meanCostUsd: summary.meanCostUsd
+    });
+  } catch (err2) {
+    logger14.warn("route-model-selection readiness signal failed (non-fatal)", {
+      error: getErrorMessage(err2)
+    });
+  }
+}
+
 // src/cli-adapters/composite-router-outcome.ts
 var sharedAnalyzer3 = createSharedTaskAnalyzer();
 function recordBanditOutcome(cliName, task, reward, deps) {
@@ -13894,6 +14067,13 @@ var CompositeRouter = class _CompositeRouter {
   lastRoutedTask;
   // Track last traceId for metrics correlation (Issue #559)
   lastTraceId;
+  /**
+   * Pending model-selection shadow comparison awaiting its outcome join
+   * (#4197). Keyed by task content like {@link lastRoutedTask}; persisted with
+   * `success` when `recordDifficultyOutcome` reports the matching outcome.
+   * The task content itself is never persisted.
+   */
+  pendingModelShadow;
   constructor(adapters, config, logger14) {
     const {
       preferenceRouterConfig,
@@ -14078,7 +14258,7 @@ var CompositeRouter = class _CompositeRouter {
    */
   async consultUnifiedContext(task) {
     try {
-      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-YGPEAEPO.js");
+      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-4SWGSINU.js");
       const ctx = await getContextForTask({
         task: task.content,
         category: inferTaskCategory(task.content),
@@ -14202,12 +14382,16 @@ var CompositeRouter = class _CompositeRouter {
         return pipelineResult;
       }
       this.trackLastRoutedTask(task, pipelineResult.value);
-      return this.buildRoutingDecision({
+      const decisionResult = this.buildRoutingDecision({
         ...pipelineResult.value,
         taskProfile,
         stagesExecuted,
         startTime
       });
+      if (decisionResult.ok) {
+        this.trackModelSelectionShadow(task, decisionResult.value);
+      }
+      return decisionResult;
     } catch (error) {
       return this.handleRoutingError(error, stagesExecuted);
     }
@@ -14293,6 +14477,80 @@ var CompositeRouter = class _CompositeRouter {
       };
     }
   }
+  /**
+   * Compute the model-selection SHADOW comparison for a routed decision
+   * (#4197): what `resolveModelForTier` WOULD have picked vs the model the
+   * decision actually carries (or the CLI default the adapter will resolve).
+   * Held pending until `recordDifficultyOutcome` supplies the outcome, then
+   * persisted to the dedicated shadow log. Gated behind
+   * `NEXUS_ROUTE_MODEL_SHADOW=1` (default OFF). NEVER affects the live
+   * decision — any failure increments the shadow-failure counter and is
+   * logged, not thrown into the routing path.
+   *
+   * Tasks with a PINNED model (`CliTask.model`) are SKIPPED entirely: the
+   * adapter executes the pinned model (base-adapter), not the CLI default the
+   * comparison would otherwise assume, so a pinned run says nothing about the
+   * tier selector — sampling it would mislabel the agree/diverge cohorts and
+   * pad the volume criterion with garbage (#4218 review).
+   */
+  trackModelSelectionShadow(task, decision) {
+    try {
+      if (!isRouteModelShadowEnabled() || decision.difficultyTier === void 0) return;
+      if (task.model !== void 0) return;
+      logModelSelectionReadinessOnce(this.logger);
+      const comparison = computeModelSelectionShadow(
+        routingArmDisplaySlot(decision.cliName),
+        decision.difficultyTier,
+        decision.model
+      );
+      this.pendingModelShadow = { ...comparison, taskContent: task.content };
+      this.logger.debug("Model-selection shadow computed (#4197)", {
+        cli: comparison.cli,
+        tier: comparison.tier,
+        actualModel: comparison.actualModel,
+        shadowModel: comparison.shadowModel,
+        agree: comparison.agree
+      });
+    } catch (error) {
+      const failures = recordModelSelectionShadowFailure();
+      this.logger.warn("Model-selection shadow failed (non-fatal, #4197)", {
+        error: getErrorMessage(error),
+        failures
+      });
+    }
+  }
+  /**
+   * Join a pending model-selection shadow comparison with its task outcome and
+   * persist the completed record (#4197). Matches by task content, mirroring
+   * {@link getDifficultyInfo}'s lastRoutedTask join. `costUsd` is deliberately
+   * absent: the routing outcome path measures no per-decision cost today, and
+   * the readiness gate's cost criterion stays fail-closed until it does.
+   * Exception-guarded — an outcome-join failure never breaks outcome recording.
+   */
+  joinModelSelectionShadowOutcome(task, success) {
+    const pending = this.pendingModelShadow;
+    if (pending === void 0) return;
+    if (pending.taskContent !== task.content) return;
+    this.pendingModelShadow = void 0;
+    try {
+      persistModelSelectionShadowRecord({
+        schema: MODEL_SELECTION_SHADOW_SCHEMA_VERSION,
+        timestamp: new Date(getTimeProvider().now()).toISOString(),
+        cli: pending.cli,
+        tier: pending.tier,
+        actualModel: pending.actualModel,
+        shadowModel: pending.shadowModel,
+        agree: pending.agree,
+        success
+      });
+    } catch (error) {
+      const failures = recordModelSelectionShadowFailure();
+      this.logger.warn("Model-selection shadow outcome join failed (non-fatal, #4197)", {
+        error: getErrorMessage(error),
+        failures
+      });
+    }
+  }
   buildRoutingDecision(params) {
     const selectedAdapter = this.adapters.get(params.selectedCli);
     if (selectedAdapter === void 0) {
@@ -14373,6 +14631,7 @@ var CompositeRouter = class _CompositeRouter {
   }
   recordDifficultyOutcome(task, success, qualityScore) {
     recordZeroRouterOutcome(task, success, qualityScore, this.getOutcomeDependencies());
+    this.joinModelSelectionShadowOutcome(task, success);
   }
   hasMinimumPreferenceData() {
     return hasMinimumPreferenceData(this.getOutcomeDependencies());
@@ -14503,7 +14762,7 @@ import { dirname as dirname5 } from "path";
 import { mkdirSync as mkdirSync3 } from "fs";
 
 // src/context/mobimem-types.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var DEFAULT_MOBIMEM_CONFIG = {
   dbPath: ":memory:",
   maxProfileEntries: 100,
@@ -14515,15 +14774,15 @@ var DEFAULT_MOBIMEM_CONFIG = {
   minExperienceSuccessRate: 0.7,
   autoEviction: true
 };
-var MobiMemConfigSchema = z19.object({
-  dbPath: z19.string(),
-  maxProfileEntries: z19.number().int().positive().default(100),
-  maxExperiencePatterns: z19.number().int().positive().default(500),
-  maxActionCacheEntries: z19.number().int().positive().default(1e3),
-  actionCacheTtlMs: z19.number().int().positive().default(36e5),
-  minProfileConfidence: z19.number().min(0).max(1).default(0.6),
-  minExperienceSuccessRate: z19.number().min(0).max(1).default(0.7),
-  autoEviction: z19.boolean().default(true)
+var MobiMemConfigSchema = z20.object({
+  dbPath: z20.string(),
+  maxProfileEntries: z20.number().int().positive().default(100),
+  maxExperiencePatterns: z20.number().int().positive().default(500),
+  maxActionCacheEntries: z20.number().int().positive().default(1e3),
+  actionCacheTtlMs: z20.number().int().positive().default(36e5),
+  minProfileConfidence: z20.number().min(0).max(1).default(0.6),
+  minExperienceSuccessRate: z20.number().min(0).max(1).default(0.7),
+  autoEviction: z20.boolean().default(true)
 });
 
 // src/context/mobimem-impl.ts
@@ -14543,9 +14802,9 @@ function generatePatternKey(taskType, actionSequence, contextSignature) {
 function hashInput(input) {
   return createHash2("sha256").update(JSON.stringify(input)).digest("hex");
 }
-function calculatePatternScore(successRate2, contextMatches, attemptCount) {
+function calculatePatternScore(successRate3, contextMatches, attemptCount) {
   const contextMatch = contextMatches ? 1 : 0.5;
-  return successRate2 * contextMatch * Math.log10(attemptCount + 1);
+  return successRate3 * contextMatch * Math.log10(attemptCount + 1);
 }
 function computeSuccessRate(successCount, attemptCount) {
   return attemptCount > 0 ? successCount / attemptCount : 0;
@@ -15588,4 +15847,4 @@ export {
   AgentCapability,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-WGDZFYP3.js.map
+//# sourceMappingURL=chunk-N6WRMZYA.js.map