nexus-agents 8.85.2 → 8.86.0

package/dist/{chunk-YGOTLETF.js → chunk-64IJKT4I.js}

@@ -2,8 +2,9 @@ import {
   ensureLearningDir,
   getDecisionCostFile,
   getModelSelectionShadowFile,
-  isPersistenceEnabled
-} from "./chunk-4UHDDCRB.js";
+  isPersistenceEnabled,
+  isStrategyDistillationEnabled
+} from "./chunk-RQLIPUQK.js";
 import {
   getNexusDataDir,
   nexusDataPath,
@@ -1303,9 +1304,9 @@ var DEFAULT_MODEL_CAPABILITIES = {
     },
     {
       id: "codex-5.2",
-      displayName: "GPT-5.3 Codex Spark",
+      displayName: "GPT-5.6 Luna",
       provider: "openai",
-      contextWindow: 128e3,
+      contextWindow: 105e4,
       outputModalities: ["text", "structured_json", "code"],
       inputModalities: ["text", "image", "pdf", "code"],
       toolCapabilities: [
@@ -1322,33 +1323,41 @@ var DEFAULT_MODEL_CAPABILITIES = {
         "No native image/audio/video generation",
         "Network access restricted in sandbox"
       ],
-      // #5091: repointed from gpt-5.2-codex, which codex 0.146.0 no longer
-      // serves (~/.codex/models_cache.json visibility=list). Context window,
-      // max output and pricing are models.dev's figures for this slug
-      // (snapshot 2026-08-31). Quality scores are the codex arm's tier
-      // positions carried over from the replaced entry, not a measurement of
-      // this slug; `cost` is unchanged because the price is identical.
+      // 2026-09-23: repointed from gpt-5.3-codex-spark, which codex-cli 0.155.1
+      // no longer serves (~/.codex/models_cache.json visibility=list; the
+      // verify Codex Models check reported it). Same shape as #5091 option A:
+      // the id stays (it holds the arm's outcome history), only the slug and
+      // the metadata describing it move.
+      // WHY gpt-5.6-luna: this id is the codex fast/spark tier. The served
+      // fast models are the two "luna" variants (codex catalog: gpt-5.6-luna
+      // "Older fast and efficient model"; gpt-6-luna "Fast and affordable model
+      // for easier tasks"). gpt-6-luna is the cheaper of the two, so it takes
+      // the mini id; this id takes gpt-5.6-luna.
+      // Context window, max output and pricing are models.dev's figures for
+      // this slug (snapshot 2026-09-21); the codex cache reports a 272K default
+      // window. reasoning/codeGeneration/speed are tier positions CARRIED OVER
+      // from the replaced entry, not a measurement of this slug; `cost` follows
+      // the registry's price scale (9, as for $0.3/$1 openrouter-qwen-coder;
+      // only the free model scores 10) — spark's 7 described a $1.75/$14 slug.
       // ROUTING CONSEQUENCE: `resolve-model-for-tier` ranks the balanced tier
       // by codeGeneration and breaks the 10/10/10 tie on the higher `cost`
-      // score, so this entry (cost 7) wins the balanced codex tier over
-      // codex-5.3 (5) and gpt-5.5 (4). It already did; what changed is that
-      // the winner now runs (spark) instead of being rejected (gpt-5.2-codex).
-      // `resolve-model-for-tier.test.ts` pins this so a rescore is a visible
-      // decision, not a side effect.
-      notes: "GPT-5.3 Codex Spark (models.dev 2026-08-31); fast codex-tuned tier below GPT-5.4; 128K context; sandboxed execution environment",
-      pricing: { inputPer1M: 1.75, outputPer1M: 14 },
-      qualityScores: { reasoning: 9, codeGeneration: 10, speed: 8, cost: 7 },
-      maxOutputTokens: 32e3,
+      // score, so this entry (now cost 9) still wins the balanced codex tier
+      // over codex-5.3 (5) and gpt-5.5 (4). `resolve-model-for-tier.test.ts`
+      // pins it so a rescore is a visible decision, not a side effect.
+      notes: 'GPT-5.6 Luna (models.dev 2026-09-21; codex catalog: "older fast and efficient model"); fast codex tier; served by codex-cli 0.155.1; 1.05M context (codex cache default window 272K)',
+      pricing: { inputPer1M: 0.2, outputPer1M: 1.2 },
+      qualityScores: { reasoning: 9, codeGeneration: 10, speed: 8, cost: 9 },
+      maxOutputTokens: 128e3,
       cliName: "codex",
-      cliModelName: "gpt-5.3-codex-spark",
+      cliModelName: "gpt-5.6-luna",
       unsupportedParameters: ["temperature"],
       maxTokensParam: "max_completion_tokens"
     },
     {
       id: "codex-5.1-mini",
-      displayName: "GPT-5.4 Mini",
+      displayName: "GPT-6 Luna",
       provider: "openai",
-      contextWindow: 4e5,
+      contextWindow: 105e4,
       outputModalities: ["text", "structured_json", "code"],
       inputModalities: ["text", "image", "code"],
       toolCapabilities: [
@@ -1360,19 +1369,25 @@ var DEFAULT_MODEL_CAPABILITIES = {
       ],
       specialFeatures: ["streaming"],
       constraints: ["Sandboxed execution only", "No native image/audio/video generation"],
-      // #5091: repointed from o3-mini, which codex 0.146.0 no longer serves
-      // (~/.codex/models_cache.json visibility=list). Context window, max
-      // output and pricing are models.dev's figures for this slug (snapshot
-      // 2026-08-31). Quality scores are the codex arm's tier positions carried
-      // over from the replaced entry, not a measurement of this slug; `cost`
-      // follows the registry's own price scale ($1/$5 haiku and $0.5/$3
-      // gemini-3-flash both score 9, and $0.75/$4.5 sits between them).
-      notes: "GPT-5.4 Mini (models.dev 2026-08-31); compact codex tier; fast and cost-effective for code tasks; 400K context",
-      pricing: { inputPer1M: 0.75, outputPer1M: 4.5 },
+      // 2026-09-23: repointed from gpt-5.4-mini, which codex-cli 0.155.1 no
+      // longer serves (~/.codex/models_cache.json visibility=list); #5091 had
+      // repointed it from o3-mini. WHY gpt-6-luna: it is the smallest served
+      // model — $0.1/$0.5 per 1M, below gpt-5.6-luna's $0.2/$1.2 — and the
+      // codex catalog calls it "Fast and affordable model for easier tasks".
+      // SOURCE: the committed models.dev snapshot (2026-09-21) and generated
+      // catalogue (2026-09-20) predate gpt-6-luna. Context window, max output
+      // and pricing are the live models.dev / LiteLLM figures for
+      // `openai/gpt-6-luna` as read by `pnpm build:registry` on 2026-09-23
+      // (LiteLLM: 922K max input); the codex cache reports a 272K default
+      // window. Quality scores are the codex arm's tier positions carried
+      // over, not a measurement of this slug; `cost` stays 9 on the registry's
+      // price scale (only the free model scores 10).
+      notes: 'GPT-6 Luna (models.dev/LiteLLM 2026-09-23; codex catalog: "fast and affordable model for easier tasks"); compact codex tier; served by codex-cli 0.155.1; 1.05M context (codex cache default window 272K)',
+      pricing: { inputPer1M: 0.1, outputPer1M: 0.5 },
       qualityScores: { reasoning: 7, codeGeneration: 8, speed: 9, cost: 9 },
       maxOutputTokens: 128e3,
       cliName: "codex",
-      cliModelName: "gpt-5.4-mini",
+      cliModelName: "gpt-6-luna",
       unsupportedParameters: ["temperature"],
       maxTokensParam: "max_completion_tokens"
     },
@@ -2628,7 +2643,7 @@ function setDefaultRegistry(registry) {
 }
 async function reloadDefaultRegistry() {
   globalRegistry = buildDefaultRegistry();
-  const { resetGlobalRegistry } = await import("./unified-registry-NODUOBMA.js");
+  const { resetGlobalRegistry } = await import("./unified-registry-Y327PN6R.js");
   resetGlobalRegistry();
   return globalRegistry;
 }
@@ -9641,20 +9656,40 @@ var DistilledRuleStage = class {
   config;
   logger;
   rulesAppliedCount = 0;
+  firstRunChecked = false;
   constructor(distiller, config, logger15) {
     this.distiller = distiller;
     this.config = { ...DEFAULT_CONFIG5, ...config };
     this.logger = logger15 ?? createLogger({ component: "DistilledRuleStage" });
   }
   canHandle(ctx) {
+    this.checkPersistedTriggerOnce();
     const candidates = getRemainingCandidates(ctx);
     if (candidates.length <= 1) return false;
     const activeRules = this.distiller.getRules("active");
     return activeRules.length > 0;
   }
   route(ctx) {
+    this.checkPersistedTriggerOnce();
     return Promise.resolve(this.routeSync(ctx));
   }
+  /**
+   * The first time this stage runs, let the distiller distill from the
+   * persisted outcome store (#6512). Without it, rules only ever came from 50
+   * outcomes seen inside one process, which short-lived CLI processes never
+   * reach. A failure here is logged and routing continues without rules.
+   */
+  checkPersistedTriggerOnce() {
+    if (this.firstRunChecked) return;
+    this.firstRunChecked = true;
+    try {
+      this.distiller.checkPersistedTrigger();
+    } catch (error) {
+      this.logger.warn("Persisted-store distill trigger failed; routing without new rules", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   recordOutcome(outcome) {
     this.distiller.onOutcome();
     this.logger.debug("Forwarded outcome to distiller", {
@@ -10182,367 +10217,58 @@ var DEFAULT_DISTILLER_CONFIG = {
   ruleExpiryMs: 24 * 60 * 60 * 1e3
 };
 
-// src/learning/strategy-distiller.ts
-function sigmoidConfidence(observations, center = 30) {
-  const raw = 1 / (1 + Math.exp(-(observations - center) / 5));
-  return Math.max(0, Math.min(1, raw));
-}
-function clampUnit(value) {
-  if (!Number.isFinite(value)) return 0;
-  return Math.max(0, Math.min(1, value));
-}
-function effectFor(patternType, metric, thresholds) {
-  switch (patternType) {
-    case "failure-rate":
-      return clampUnit(
-        (metric - thresholds.failureRateThreshold) / (1 - thresholds.failureRateThreshold)
-      );
-    case "success-rate":
-      return clampUnit(
-        (metric - thresholds.successRateThreshold) / (1 - thresholds.successRateThreshold)
-      );
-    case "latency-spike":
-      return clampUnit(
-        (metric - thresholds.latencyRatioThreshold) / thresholds.latencyRatioThreshold
-      );
-  }
-}
-function ruleFingerprint(patternType, cli, category) {
-  return `${patternType}:${cli}:${category}`;
-}
-function groupOutcomes(outcomes) {
-  const map2 = /* @__PURE__ */ new Map();
-  for (const o of outcomes) {
-    const key = `${o.cli}:${o.category}`;
-    const list = map2.get(key);
-    if (list !== void 0) {
-      list.push(o);
-    } else {
-      map2.set(key, [o]);
-    }
-  }
-  const groups = [];
-  for (const [key, list] of map2) {
-    const [cli, category] = key.split(":");
-    groups.push({ cli, category, outcomes: list });
-  }
-  return groups;
-}
-function percentile(sorted, p) {
-  if (sorted.length === 0) return 0;
-  const idx = Math.ceil(p / 100 * sorted.length) - 1;
-  return sorted[Math.max(0, idx)] ?? 0;
-}
-function detectFailurePatterns(groups, threshold) {
-  const patterns = [];
-  for (const g of groups) {
-    const failCount = g.outcomes.filter((o) => !o.success).length;
-    const failRate = failCount / g.outcomes.length;
-    if (failRate >= threshold) {
-      patterns.push({
-        cli: g.cli,
-        category: g.category,
-        patternType: "failure-rate",
-        action: failRate >= 0.8 ? "avoid" : "penalize",
-        metric: failRate,
-        observationCount: g.outcomes.length
-      });
-    }
-  }
-  return patterns;
-}
-function detectSuccessPatterns(groups, threshold) {
-  const patterns = [];
-  for (const g of groups) {
-    const successCount = g.outcomes.filter((o) => o.success).length;
-    const successRate3 = successCount / g.outcomes.length;
-    if (successRate3 >= threshold) {
-      patterns.push({
-        cli: g.cli,
-        category: g.category,
-        patternType: "success-rate",
-        action: "boost",
-        metric: successRate3,
-        observationCount: g.outcomes.length
-      });
-    }
-  }
-  return patterns;
-}
-function detectLatencyPatterns(groups, threshold) {
-  const patterns = [];
-  for (const g of groups) {
-    const durations = g.outcomes.map((o) => o.durationMs).sort((a, b) => a - b);
-    if (durations.length < 3) continue;
-    const median = percentile(durations, 50);
-    const p90 = percentile(durations, 90);
-    if (median <= 0) continue;
-    const ratio = p90 / median;
-    if (ratio >= threshold) {
-      patterns.push({
-        cli: g.cli,
-        category: g.category,
-        patternType: "latency-spike",
-        action: "penalize",
-        metric: ratio,
-        observationCount: g.outcomes.length
-      });
-    }
-  }
-  return patterns;
-}
-var StrategyDistiller = class {
-  /** Protected so `PersistentStrategyDistiller` hydrates legacy rules under the live thresholds. */
-  config;
-  outcomeStore;
-  logger;
-  rules = /* @__PURE__ */ new Map();
-  outcomeCounter = 0;
-  lastDistillAt;
-  constructor(outcomeStore, logger15, config) {
-    this.outcomeStore = outcomeStore;
-    this.config = { ...DEFAULT_DISTILLER_CONFIG, ...config };
-    this.logger = logger15 ?? createLogger({ component: "StrategyDistiller" });
-  }
-  /** Called for each processed outcome. Triggers distillation at threshold. */
-  onOutcome() {
-    this.outcomeCounter++;
-    if (this.outcomeCounter >= this.config.triggerThreshold) {
-      this.distill();
-      this.outcomeCounter = 0;
-    }
-  }
-  /** Run distillation on current OutcomeStore data. */
-  distill() {
-    const now = getTimeProvider().now();
-    const outcomes = this.outcomeStore.query();
-    const groups = groupOutcomes(outcomes);
-    this.expireRules(now);
-    const failurePatterns = detectFailurePatterns(groups, this.config.failureRateThreshold);
-    const successPatterns = detectSuccessPatterns(groups, this.config.successRateThreshold);
-    const latencyPatterns = detectLatencyPatterns(groups, this.config.latencyRatioThreshold);
-    const allPatterns = [...failurePatterns, ...successPatterns, ...latencyPatterns];
-    for (const pattern of allPatterns) {
-      this.upsertRule(pattern, now);
-    }
-    this.enforceMaxRules();
-    this.lastDistillAt = now;
-    this.logger.debug("Distillation complete", {
-      rulesTotal: this.rules.size,
-      patternsFound: allPatterns.length,
-      outcomesAnalyzed: outcomes.length
-    });
-  }
-  /** Get rules filtered by status. */
-  getRules(status) {
-    const all = [...this.rules.values()];
-    if (status === void 0) return all;
-    return all.filter((r) => r.status === status);
-  }
-  /** Get distiller statistics. */
-  getStats() {
-    const countByStatus = {
-      draft: 0,
-      active: 0,
-      promoted: 0,
-      expired: 0
-    };
-    for (const rule of this.rules.values()) {
-      countByStatus[rule.status]++;
-    }
-    return {
-      ruleCountByStatus: countByStatus,
-      totalRules: this.rules.size,
-      lastDistillAt: this.lastDistillAt,
-      outcomesSinceLastDistill: this.outcomeCounter
-    };
-  }
+// src/learning/distiller-eligibility.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "node:fs";
+
+// src/orchestration/outcomes/outcome-types.ts
+import { z as z14 } from "zod";
+var logger8 = createLogger({ component: "outcome-error-taxonomy" });
+var OutcomeSourceSchema = z14.enum(["delegate", "consensus", "manual"]);
+var OutcomeFailureCategorySchema = z14.enum([
+  "timeout",
+  "authentication",
+  "rate_limit",
+  "connection",
+  "crash",
+  "adapter_unavailable",
+  "validation",
+  "parse",
+  "execution",
+  "generic",
+  "unknown"
+]);
+var OutcomeCliSchema = z14.union([CliNameSchema, ApiArmIdSchema, z14.literal("unknown")]);
+var OutcomeCliSourceSchema = z14.enum(["executed", "category-default"]);
+var TaskOutcomeSchema = z14.object({
+  id: z14.string().min(1),
+  cli: OutcomeCliSchema,
+  /** How the CLI attribution was obtained. Absent on legacy, unmeasured records. */
+  cliSource: OutcomeCliSourceSchema.optional(),
+  category: TaskCategorySchema,
+  model: z14.string().min(1),
+  success: z14.boolean(),
+  durationMs: z14.number().nonnegative(),
+  timestamp: z14.string().min(1),
+  qualitySignals: z14.array(z14.string()).optional(),
+  failureCategory: OutcomeFailureCategorySchema.optional(),
+  errorMessage: z14.string().max(500).optional(),
+  source: OutcomeSourceSchema,
+  /** Whether this outcome came from a triage-initiated retry (#1506). */
+  wasRetried: z14.boolean().optional(),
+  /** Triage action taken on the failure (#1506). */
+  triageAction: z14.string().max(30).optional(),
+  /** Routing stage that selected this CLI (#1785). */
+  routingStage: z14.string().max(50).optional(),
+  /** Number of retry attempts before this outcome (#1785). */
+  retryCount: z14.number().int().nonnegative().optional(),
+  /** Vendor resolved from `model` via ModelRegistry at write time (#2548). */
+  vendor: z14.string().min(1).max(40).optional(),
+  /** Family resolved from `model` via ModelRegistry at write time (#2548). */
+  family: z14.string().min(1).max(80).optional(),
   /**
-   * Promote high-confidence rules to RoutingMemory.
-   * Rules must be active, with sufficient observations and confidence.
-   *
-   * @deprecated No production caller (#5004 finding 4). `DistilledRuleStage`
-   * is the single channel by which distilled rules reach routing; this
-   * second channel into `RoutingMemory` is kept only so the deprecation is
-   * non-breaking. Removal is tracked in #5467. Note the gate now compares
-   * `confidence = support × effect` against `promotionConfidence`, so a rule
-   * that would have promoted on sample size alone may no longer clear it.
-   */
-  promote(routingMemory) {
-    let promoted = 0;
-    for (const [id, rule] of this.rules) {
-      if (rule.status !== "active") continue;
-      if (rule.observationCount < this.config.minObservationsForActive) continue;
-      if (rule.confidence < this.config.promotionConfidence) continue;
-      const performance2 = this.ruleToPerformance(rule);
-      routingMemory.storePreference(rule.cli, rule.category, performance2);
-      this.rules.set(id, { ...rule, status: "promoted", updatedAt: getTimeProvider().now() });
-      promoted++;
-      this.logger.info("Promoted distilled rule to RoutingMemory", {
-        ruleId: id,
-        cli: rule.cli,
-        category: rule.category,
-        confidence: rule.confidence
-      });
-    }
-    return promoted;
-  }
-  // ==========================================================================
-  // Protected — for subclass hydration (Issue #1009)
-  // ==========================================================================
-  /** Load pre-existing rules (e.g., from disk). Used by PersistentStrategyDistiller. */
-  loadRules(rules) {
-    for (const rule of rules) {
-      this.rules.set(rule.id, rule);
-    }
-  }
-  // ==========================================================================
-  // Private
-  // ==========================================================================
-  upsertRule(pattern, now) {
-    const id = ruleFingerprint(pattern.patternType, pattern.cli, pattern.category);
-    const existing = this.rules.get(id);
-    if (existing === void 0 && pattern.observationCount < this.config.minObservationsForDraft) {
-      return;
-    }
-    const support = sigmoidConfidence(pattern.observationCount);
-    const effect = effectFor(pattern.patternType, pattern.metric, this.config);
-    const confidence = support * effect;
-    const status = this.computeStatus(pattern.observationCount, existing?.status);
-    if (existing !== void 0) {
-      this.rules.set(id, {
-        ...existing,
-        action: pattern.action,
-        confidence,
-        support,
-        effect,
-        observationCount: pattern.observationCount,
-        metric: pattern.metric,
-        status,
-        updatedAt: now
-      });
-    } else {
-      this.rules.set(id, {
-        id,
-        patternType: pattern.patternType,
-        cli: pattern.cli,
-        category: pattern.category,
-        action: pattern.action,
-        confidence,
-        support,
-        effect,
-        observationCount: pattern.observationCount,
-        metric: pattern.metric,
-        status,
-        createdAt: now,
-        updatedAt: now,
-        tainted: false
-      });
-    }
-  }
-  computeStatus(observations, existing) {
-    if (existing === "promoted") return "promoted";
-    if (observations >= this.config.minObservationsForActive) return "active";
-    return "draft";
-  }
-  expireRules(now) {
-    for (const [id, rule] of this.rules) {
-      if (rule.status === "promoted") continue;
-      if (now - rule.updatedAt > this.config.ruleExpiryMs) {
-        this.rules.set(id, { ...rule, status: "expired", updatedAt: now });
-      }
-    }
-  }
-  enforceMaxRules() {
-    if (this.rules.size <= this.config.maxRules) return;
-    const sorted = [...this.rules.entries()].sort((a, b) => {
-      if (a[1].status === "expired" && b[1].status !== "expired") return -1;
-      if (b[1].status === "expired" && a[1].status !== "expired") return 1;
-      return a[1].confidence - b[1].confidence;
-    });
-    const excess = this.rules.size - this.config.maxRules;
-    for (let i = 0; i < excess; i++) {
-      const entry = sorted[i];
-      if (entry !== void 0) {
-        this.rules.delete(entry[0]);
-      }
-    }
-  }
-  /** Convert rule metrics into ModelPerformance for RoutingMemory. */
-  ruleToPerformance(rule) {
-    const successRate3 = rule.patternType === "success-rate" ? rule.metric : 1 - rule.metric;
-    return {
-      avgQuality: rule.confidence,
-      successRate: Math.max(0, Math.min(1, successRate3)),
-      avgLatencyMs: 0,
-      avgTokens: 0,
-      observations: rule.observationCount
-    };
-  }
-};
-function createStrategyDistiller(outcomeStore, logger15, config) {
-  return new StrategyDistiller(outcomeStore, logger15, config);
-}
-var persistentDistillerFactory;
-function registerPersistentDistillerFactory(factory) {
-  persistentDistillerFactory = factory;
-}
-function createPersistentDistillerOrFallback(outcomeStore, logger15) {
-  if (persistentDistillerFactory !== void 0) {
-    return persistentDistillerFactory(outcomeStore, logger15);
-  }
-  return new StrategyDistiller(outcomeStore, logger15);
-}
-
-// src/orchestration/outcomes/outcome-types.ts
-import { z as z14 } from "zod";
-var logger8 = createLogger({ component: "outcome-error-taxonomy" });
-var OutcomeSourceSchema = z14.enum(["delegate", "consensus", "manual"]);
-var OutcomeFailureCategorySchema = z14.enum([
-  "timeout",
-  "authentication",
-  "rate_limit",
-  "connection",
-  "crash",
-  "adapter_unavailable",
-  "validation",
-  "parse",
-  "execution",
-  "generic",
-  "unknown"
-]);
-var OutcomeCliSchema = z14.union([CliNameSchema, ApiArmIdSchema, z14.literal("unknown")]);
-var OutcomeCliSourceSchema = z14.enum(["executed", "category-default"]);
-var TaskOutcomeSchema = z14.object({
-  id: z14.string().min(1),
-  cli: OutcomeCliSchema,
-  /** How the CLI attribution was obtained. Absent on legacy, unmeasured records. */
-  cliSource: OutcomeCliSourceSchema.optional(),
-  category: TaskCategorySchema,
-  model: z14.string().min(1),
-  success: z14.boolean(),
-  durationMs: z14.number().nonnegative(),
-  timestamp: z14.string().min(1),
-  qualitySignals: z14.array(z14.string()).optional(),
-  failureCategory: OutcomeFailureCategorySchema.optional(),
-  errorMessage: z14.string().max(500).optional(),
-  source: OutcomeSourceSchema,
-  /** Whether this outcome came from a triage-initiated retry (#1506). */
-  wasRetried: z14.boolean().optional(),
-  /** Triage action taken on the failure (#1506). */
-  triageAction: z14.string().max(30).optional(),
-  /** Routing stage that selected this CLI (#1785). */
-  routingStage: z14.string().max(50).optional(),
-  /** Number of retry attempts before this outcome (#1785). */
-  retryCount: z14.number().int().nonnegative().optional(),
-  /** Vendor resolved from `model` via ModelRegistry at write time (#2548). */
-  vendor: z14.string().min(1).max(40).optional(),
-  /** Family resolved from `model` via ModelRegistry at write time (#2548). */
-  family: z14.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.
+   * 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: z14.string().min(1).max(40).optional(),
   /**
@@ -10766,6 +10492,411 @@ function categorizeOutcomeErrorMessage(msg) {
   return classifyText(msg.toLowerCase());
 }
 
+// src/learning/distiller-eligibility.ts
+var ROUTABLE_CLIS = new Set(CLI_NAMES);
+function isDistillerEligible(outcome) {
+  if (outcome.source !== "delegate") return false;
+  if (outcome.cliSource !== "executed") return false;
+  if (!(outcome.durationMs > 0)) return false;
+  return ROUTABLE_CLIS.has(outcome.cli);
+}
+function countEligibleSince(outcomes, sinceMs) {
+  let count = 0;
+  for (const outcome of outcomes) {
+    if (!isDistillerEligible(outcome)) continue;
+    if (sinceMs !== void 0 && !(Date.parse(outcome.timestamp) > sinceMs)) continue;
+    count++;
+  }
+  return count;
+}
+var eligibilityFieldsSchema;
+function getEligibilityFieldsSchema() {
+  eligibilityFieldsSchema ??= TaskOutcomeSchema.pick({
+    source: true,
+    cli: true,
+    cliSource: true,
+    durationMs: true
+  });
+  return eligibilityFieldsSchema;
+}
+function parseLine(line) {
+  try {
+    const parsed = getEligibilityFieldsSchema().safeParse(JSON.parse(line));
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function countEligibleOutcomesInFile(filePath) {
+  if (!existsSync6(filePath)) return 0;
+  let count = 0;
+  for (const line of readFileSync6(filePath, "utf-8").split("\n")) {
+    if (line.trim().length === 0) continue;
+    const fields = parseLine(line);
+    if (fields !== void 0 && isDistillerEligible(fields)) count++;
+  }
+  return count;
+}
+
+// src/learning/strategy-distiller.ts
+function sigmoidConfidence(observations, center = 30) {
+  const raw = 1 / (1 + Math.exp(-(observations - center) / 5));
+  return Math.max(0, Math.min(1, raw));
+}
+function clampUnit(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, value));
+}
+function effectFor(patternType, metric, thresholds) {
+  switch (patternType) {
+    case "failure-rate":
+      return clampUnit(
+        (metric - thresholds.failureRateThreshold) / (1 - thresholds.failureRateThreshold)
+      );
+    case "success-rate":
+      return clampUnit(
+        (metric - thresholds.successRateThreshold) / (1 - thresholds.successRateThreshold)
+      );
+    case "latency-spike":
+      return clampUnit(
+        (metric - thresholds.latencyRatioThreshold) / thresholds.latencyRatioThreshold
+      );
+  }
+}
+function ruleFingerprint(patternType, cli, category) {
+  return `${patternType}:${cli}:${category}`;
+}
+function groupOutcomes(outcomes) {
+  const map2 = /* @__PURE__ */ new Map();
+  for (const o of outcomes) {
+    const key = `${o.cli}:${o.category}`;
+    const list = map2.get(key);
+    if (list !== void 0) {
+      list.push(o);
+    } else {
+      map2.set(key, [o]);
+    }
+  }
+  const groups = [];
+  for (const [key, list] of map2) {
+    const [cli, category] = key.split(":");
+    groups.push({ cli, category, outcomes: list });
+  }
+  return groups;
+}
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.ceil(p / 100 * sorted.length) - 1;
+  return sorted[Math.max(0, idx)] ?? 0;
+}
+function detectFailurePatterns(groups, threshold) {
+  const patterns = [];
+  for (const g of groups) {
+    const failCount = g.outcomes.filter((o) => !o.success).length;
+    const failRate = failCount / g.outcomes.length;
+    if (failRate >= threshold) {
+      patterns.push({
+        cli: g.cli,
+        category: g.category,
+        patternType: "failure-rate",
+        action: failRate >= 0.8 ? "avoid" : "penalize",
+        metric: failRate,
+        observationCount: g.outcomes.length
+      });
+    }
+  }
+  return patterns;
+}
+function detectSuccessPatterns(groups, threshold) {
+  const patterns = [];
+  for (const g of groups) {
+    const successCount = g.outcomes.filter((o) => o.success).length;
+    const successRate3 = successCount / g.outcomes.length;
+    if (successRate3 >= threshold) {
+      patterns.push({
+        cli: g.cli,
+        category: g.category,
+        patternType: "success-rate",
+        action: "boost",
+        metric: successRate3,
+        observationCount: g.outcomes.length
+      });
+    }
+  }
+  return patterns;
+}
+function detectLatencyPatterns(groups, threshold) {
+  const patterns = [];
+  for (const g of groups) {
+    const durations = g.outcomes.map((o) => o.durationMs).sort((a, b) => a - b);
+    if (durations.length < 3) continue;
+    const median = percentile(durations, 50);
+    const p90 = percentile(durations, 90);
+    if (median <= 0) continue;
+    const ratio = p90 / median;
+    if (ratio >= threshold) {
+      patterns.push({
+        cli: g.cli,
+        category: g.category,
+        patternType: "latency-spike",
+        action: "penalize",
+        metric: ratio,
+        observationCount: g.outcomes.length
+      });
+    }
+  }
+  return patterns;
+}
+var StrategyDistiller = class {
+  /** Protected so `PersistentStrategyDistiller` hydrates legacy rules under the live thresholds. */
+  config;
+  outcomeStore;
+  logger;
+  rules = /* @__PURE__ */ new Map();
+  outcomeCounter = 0;
+  lastDistillAt;
+  eligibleAtLastDistill;
+  persistedTriggerChecked = false;
+  constructor(outcomeStore, logger15, config) {
+    this.outcomeStore = outcomeStore;
+    this.config = { ...DEFAULT_DISTILLER_CONFIG, ...config };
+    this.logger = logger15 ?? createLogger({ component: "StrategyDistiller" });
+  }
+  /**
+   * Called for each processed outcome. Triggers distillation at threshold.
+   * This counter is per-process; `checkPersistedTrigger` covers the
+   * cross-process case (#6512).
+   */
+  onOutcome() {
+    this.outcomeCounter++;
+    if (this.outcomeCounter >= this.config.triggerThreshold) {
+      this.distill();
+      this.outcomeCounter = 0;
+    }
+  }
+  /**
+   * First-route trigger against the persisted store (#6512).
+   *
+   * The in-process counter above only fires after `triggerThreshold` outcomes
+   * in ONE process, which short-lived CLI processes never reach. This checks
+   * the store instead: distill when it holds at least `triggerThreshold`
+   * eligible outcomes newer than the last distill (a hydrated snapshot's
+   * `savedAt`; no snapshot means all of them count). With no snapshot and zero
+   * eligible outcomes it distills anyway, so the empty state is recorded as
+   * "0 eligible, 0 rules, at <time>" rather than left as "never".
+   *
+   * Before deciding, rules past `ruleExpiryMs` are expired, so a hydrated rule
+   * that is out of date is never applied.
+   *
+   * Runs at most once per instance; `DistilledRuleStage` calls it when it first
+   * runs, so constructing a distiller stays cheap. Returns whether it distilled.
+   */
+  checkPersistedTrigger() {
+    if (this.persistedTriggerChecked) return false;
+    this.persistedTriggerChecked = true;
+    this.expireRules(getTimeProvider().now());
+    const newer = countEligibleSince(this.outcomeStore.query(), this.lastDistillAt);
+    const recordEmpty = this.lastDistillAt === void 0 && newer === 0;
+    if (newer < this.config.triggerThreshold && !recordEmpty) return false;
+    this.logger.debug("Persisted-store distill trigger fired", {
+      eligibleSinceLastDistill: newer,
+      triggerThreshold: this.config.triggerThreshold
+    });
+    this.distill();
+    return true;
+  }
+  /** Run distillation on the eligible outcomes in the OutcomeStore (#6512). */
+  distill() {
+    const now = getTimeProvider().now();
+    const outcomes = this.outcomeStore.query().filter(isDistillerEligible);
+    const groups = groupOutcomes(outcomes);
+    this.expireRules(now);
+    const failurePatterns = detectFailurePatterns(groups, this.config.failureRateThreshold);
+    const successPatterns = detectSuccessPatterns(groups, this.config.successRateThreshold);
+    const latencyPatterns = detectLatencyPatterns(groups, this.config.latencyRatioThreshold);
+    const allPatterns = [...failurePatterns, ...successPatterns, ...latencyPatterns];
+    for (const pattern of allPatterns) {
+      this.upsertRule(pattern, now);
+    }
+    this.enforceMaxRules();
+    this.lastDistillAt = now;
+    this.eligibleAtLastDistill = outcomes.length;
+    this.logger.debug("Distillation complete", {
+      rulesTotal: this.rules.size,
+      patternsFound: allPatterns.length,
+      outcomesAnalyzed: outcomes.length
+    });
+  }
+  /** Get rules filtered by status. */
+  getRules(status) {
+    const all = [...this.rules.values()];
+    if (status === void 0) return all;
+    return all.filter((r) => r.status === status);
+  }
+  /** Get distiller statistics. */
+  getStats() {
+    const countByStatus = {
+      draft: 0,
+      active: 0,
+      promoted: 0,
+      expired: 0
+    };
+    for (const rule of this.rules.values()) {
+      countByStatus[rule.status]++;
+    }
+    return {
+      ruleCountByStatus: countByStatus,
+      totalRules: this.rules.size,
+      lastDistillAt: this.lastDistillAt,
+      outcomesSinceLastDistill: this.outcomeCounter,
+      eligibleOutcomesAtLastDistill: this.eligibleAtLastDistill
+    };
+  }
+  /**
+   * Promote high-confidence rules to RoutingMemory.
+   * Rules must be active, with sufficient observations and confidence.
+   *
+   * @deprecated No production caller (#5004 finding 4). `DistilledRuleStage`
+   * is the single channel by which distilled rules reach routing; this
+   * second channel into `RoutingMemory` is kept only so the deprecation is
+   * non-breaking. Removal is tracked in #5467. Note the gate now compares
+   * `confidence = support × effect` against `promotionConfidence`, so a rule
+   * that would have promoted on sample size alone may no longer clear it.
+   */
+  promote(routingMemory) {
+    let promoted = 0;
+    for (const [id, rule] of this.rules) {
+      if (rule.status !== "active") continue;
+      if (rule.observationCount < this.config.minObservationsForActive) continue;
+      if (rule.confidence < this.config.promotionConfidence) continue;
+      const performance2 = this.ruleToPerformance(rule);
+      routingMemory.storePreference(rule.cli, rule.category, performance2);
+      this.rules.set(id, { ...rule, status: "promoted", updatedAt: getTimeProvider().now() });
+      promoted++;
+      this.logger.info("Promoted distilled rule to RoutingMemory", {
+        ruleId: id,
+        cli: rule.cli,
+        category: rule.category,
+        confidence: rule.confidence
+      });
+    }
+    return promoted;
+  }
+  // ==========================================================================
+  // Protected — for subclass hydration (Issue #1009)
+  // ==========================================================================
+  /** Load pre-existing rules (e.g., from disk). Used by PersistentStrategyDistiller. */
+  loadRules(rules) {
+    for (const rule of rules) {
+      this.rules.set(rule.id, rule);
+    }
+  }
+  /**
+   * Restore last-distill state from a persisted snapshot (#6512), so the
+   * first-route trigger counts only outcomes newer than that snapshot.
+   */
+  restoreDistillState(lastDistillAt, eligibleOutcomes) {
+    this.lastDistillAt = lastDistillAt;
+    this.eligibleAtLastDistill = eligibleOutcomes;
+  }
+  // ==========================================================================
+  // Private
+  // ==========================================================================
+  upsertRule(pattern, now) {
+    const id = ruleFingerprint(pattern.patternType, pattern.cli, pattern.category);
+    const existing = this.rules.get(id);
+    if (existing === void 0 && pattern.observationCount < this.config.minObservationsForDraft) {
+      return;
+    }
+    const support = sigmoidConfidence(pattern.observationCount);
+    const effect = effectFor(pattern.patternType, pattern.metric, this.config);
+    const confidence = support * effect;
+    const status = this.computeStatus(pattern.observationCount, existing?.status);
+    if (existing !== void 0) {
+      this.rules.set(id, {
+        ...existing,
+        action: pattern.action,
+        confidence,
+        support,
+        effect,
+        observationCount: pattern.observationCount,
+        metric: pattern.metric,
+        status,
+        updatedAt: now
+      });
+    } else {
+      this.rules.set(id, {
+        id,
+        patternType: pattern.patternType,
+        cli: pattern.cli,
+        category: pattern.category,
+        action: pattern.action,
+        confidence,
+        support,
+        effect,
+        observationCount: pattern.observationCount,
+        metric: pattern.metric,
+        status,
+        createdAt: now,
+        updatedAt: now,
+        tainted: false
+      });
+    }
+  }
+  computeStatus(observations, existing) {
+    if (existing === "promoted") return "promoted";
+    if (observations >= this.config.minObservationsForActive) return "active";
+    return "draft";
+  }
+  expireRules(now) {
+    for (const [id, rule] of this.rules) {
+      if (rule.status === "promoted") continue;
+      if (now - rule.updatedAt > this.config.ruleExpiryMs) {
+        this.rules.set(id, { ...rule, status: "expired", updatedAt: now });
+      }
+    }
+  }
+  enforceMaxRules() {
+    if (this.rules.size <= this.config.maxRules) return;
+    const sorted = [...this.rules.entries()].sort((a, b) => {
+      if (a[1].status === "expired" && b[1].status !== "expired") return -1;
+      if (b[1].status === "expired" && a[1].status !== "expired") return 1;
+      return a[1].confidence - b[1].confidence;
+    });
+    const excess = this.rules.size - this.config.maxRules;
+    for (let i = 0; i < excess; i++) {
+      const entry = sorted[i];
+      if (entry !== void 0) {
+        this.rules.delete(entry[0]);
+      }
+    }
+  }
+  /** Convert rule metrics into ModelPerformance for RoutingMemory. */
+  ruleToPerformance(rule) {
+    const successRate3 = rule.patternType === "success-rate" ? rule.metric : 1 - rule.metric;
+    return {
+      avgQuality: rule.confidence,
+      successRate: Math.max(0, Math.min(1, successRate3)),
+      avgLatencyMs: 0,
+      avgTokens: 0,
+      observations: rule.observationCount
+    };
+  }
+};
+function createStrategyDistiller(outcomeStore, logger15, config) {
+  return new StrategyDistiller(outcomeStore, logger15, config);
+}
+var persistentDistillerFactory;
+function registerPersistentDistillerFactory(factory) {
+  persistentDistillerFactory = factory;
+}
+function createPersistentDistillerOrFallback(outcomeStore, logger15) {
+  if (persistentDistillerFactory !== void 0) {
+    return persistentDistillerFactory(outcomeStore, logger15);
+  }
+  return new StrategyDistiller(outcomeStore, logger15);
+}
+
 // src/orchestration/outcomes/outcome-store.ts
 var DEFAULT_MAX_ENTRIES2 = 1e4;
 var DEFAULT_FAMILY_FALLBACK_THRESHOLD = 5;
@@ -12860,7 +12991,7 @@ function aggregateDecisionCosts(records, windowMs) {
 import { z as z18 } from "zod";
 
 // src/config/jsonl-store.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync } from "node:fs";
+import { appendFileSync as appendFileSync3, existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync } from "node:fs";
 import { dirname as dirname5 } from "node:path";
 var DIR_MODE = 448;
 var JsonlStore = class {
@@ -12923,14 +13054,14 @@ var JsonlStore = class {
     }
   }
   hydrate() {
-    if (!existsSync6(this.filePath)) {
+    if (!existsSync7(this.filePath)) {
       this.logger.debug("No JSONL file found, starting fresh", { path: this.filePath });
       return;
     }
     let loaded = 0;
     let skipped = 0;
     try {
-      const content = readFileSync6(this.filePath, "utf-8");
+      const content = readFileSync7(this.filePath, "utf-8");
       const lines = content.split("\n").filter((line) => line.trim().length > 0);
       for (const line of lines) {
         try {
@@ -15202,7 +15333,7 @@ function resolveModelForTier(cliName, tier, opts = {}) {
 }
 
 // src/cli-adapters/model-selection-shadow.ts
-import { appendFileSync as appendFileSync4, existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
+import { appendFileSync as appendFileSync4, existsSync as existsSync8, readFileSync as readFileSync8 } from "node:fs";
 import { z as z22 } from "zod";
 function isRouteModelShadowEnabled() {
   return parseBoolEnv("NEXUS_ROUTE_MODEL_SHADOW", false) && isPersistenceEnabled();
@@ -15253,11 +15384,11 @@ function persistModelSelectionShadowRecord(record) {
 }
 function readModelSelectionShadowRecords() {
   const file = getModelSelectionShadowFile();
-  if (!existsSync7(file)) return [];
+  if (!existsSync8(file)) return [];
   const records = [];
   try {
     const cutoff = Date.now() - READ_LOOKBACK_MS;
-    const lines = readFileSync7(file, "utf-8").split("\n").filter((l) => l.trim().length > 0);
+    const lines = readFileSync8(file, "utf-8").split("\n").filter((l) => l.trim().length > 0);
     for (const line of lines) {
       let parsed;
       try {
@@ -15612,6 +15743,9 @@ function generateTraceId2() {
 // src/cli-adapters/composite-router.ts
 var FAILURE_QUALITY_SCORE = 0.3;
 var DEFAULT_TOKEN_ESTIMATE = 1e3;
+function applyDistillationSwitch(config) {
+  return isStrategyDistillationEnabled() ? config : { ...config, enableStrategyDistillation: false };
+}
 var CompositeRouter = class _CompositeRouter {
   config;
   logger;
@@ -15694,7 +15828,7 @@ var CompositeRouter = class _CompositeRouter {
       availableModelsCache,
       ...baseConfig
     } = config ?? {};
-    this.config = CompositeRouterConfigSchema.parse(baseConfig);
+    this.config = applyDistillationSwitch(CompositeRouterConfigSchema.parse(baseConfig));
     this.logger = logger15 ?? createLogger({ component: "CompositeRouter" });
     this.pendingRoutingOutcomes = new PendingRoutingOutcomes(this.logger);
     this.adapters = adapters;
@@ -15880,7 +16014,7 @@ var CompositeRouter = class _CompositeRouter {
    */
   async consultUnifiedContext(task) {
     try {
-      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-CH3GEH2Z.js");
+      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-NZOSGG6S.js");
       const ctx = await getContextForTask({
         task: task.content,
         category: inferTaskCategory(task.content),
@@ -17463,6 +17597,7 @@ export {
   RoutingMemory,
   createRoutingMemory,
   DEFAULT_DISTILLER_CONFIG,
+  countEligibleOutcomesInFile,
   sigmoidConfidence,
   effectFor,
   detectFailurePatterns,
@@ -17515,4 +17650,4 @@ export {
   AgentCapability,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-YGOTLETF.js.map
+//# sourceMappingURL=chunk-64IJKT4I.js.map