nexus-agents 8.85.3 → 8.86.0

package/dist/{chunk-OMIR6ISN.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,
@@ -2642,7 +2643,7 @@ function setDefaultRegistry(registry) {
 }
 async function reloadDefaultRegistry() {
   globalRegistry = buildDefaultRegistry();
-  const { resetGlobalRegistry } = await import("./unified-registry-J2PCYXUU.js");
+  const { resetGlobalRegistry } = await import("./unified-registry-Y327PN6R.js");
   resetGlobalRegistry();
   return globalRegistry;
 }
@@ -9655,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", {
@@ -10196,317 +10217,8 @@ 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
-    };
-  }
-  /**
-   * 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/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";
@@ -10747,37 +10459,442 @@ function classifyText(text) {
   if (matchesAny(text, PARSE_PATTERNS)) return "parse";
   return classifyExecutionOrGeneric(text);
 }
-var MAX_ERROR_MESSAGE_LENGTH = 500;
-function extractNonErrorMessage(error) {
-  if (error === null || error === void 0) return void 0;
-  if (typeof error === "string") {
-    return error.slice(0, MAX_ERROR_MESSAGE_LENGTH);
+var MAX_ERROR_MESSAGE_LENGTH = 500;
+function extractNonErrorMessage(error) {
+  if (error === null || error === void 0) return void 0;
+  if (typeof error === "string") {
+    return error.slice(0, MAX_ERROR_MESSAGE_LENGTH);
+  }
+  if (typeof error === "object") {
+    const record = error;
+    if (typeof record["message"] === "string") {
+      return record["message"].slice(0, MAX_ERROR_MESSAGE_LENGTH);
+    }
+    try {
+      const json = JSON.stringify(error);
+      return json.slice(0, MAX_ERROR_MESSAGE_LENGTH);
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function categorizeOutcomeError(error) {
+  if (error instanceof Error) {
+    const text = `${error.message.toLowerCase()} ${error.name.toLowerCase()}`;
+    return classifyText(text);
+  }
+  const extracted = extractNonErrorMessage(error);
+  if (extracted === void 0) return "execution";
+  return classifyText(extracted.toLowerCase());
+}
+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
+      });
+    }
   }
-  if (typeof error === "object") {
-    const record = error;
-    if (typeof record["message"] === "string") {
-      return record["message"].slice(0, MAX_ERROR_MESSAGE_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;
     }
-    try {
-      const json = JSON.stringify(error);
-      return json.slice(0, MAX_ERROR_MESSAGE_LENGTH);
-    } catch {
-      return void 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
+    });
   }
-  return void 0;
-}
-function categorizeOutcomeError(error) {
-  if (error instanceof Error) {
-    const text = `${error.message.toLowerCase()} ${error.name.toLowerCase()}`;
-    return classifyText(text);
+  /** 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);
   }
-  const extracted = extractNonErrorMessage(error);
-  if (extracted === void 0) return "execution";
-  return classifyText(extracted.toLowerCase());
+  /** 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);
 }
-function categorizeOutcomeErrorMessage(msg) {
-  return classifyText(msg.toLowerCase());
+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
@@ -12874,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 {
@@ -12937,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 {
@@ -15216,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();
@@ -15267,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 {
@@ -15626,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;
@@ -15708,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;
@@ -15894,7 +16014,7 @@ var CompositeRouter = class _CompositeRouter {
    */
   async consultUnifiedContext(task) {
     try {
-      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-VRAIKZTE.js");
+      const { getContextForTask, inferTaskCategory } = await import("./context-retriever-NZOSGG6S.js");
       const ctx = await getContextForTask({
         task: task.content,
         category: inferTaskCategory(task.content),
@@ -17477,6 +17597,7 @@ export {
   RoutingMemory,
   createRoutingMemory,
   DEFAULT_DISTILLER_CONFIG,
+  countEligibleOutcomesInFile,
   sigmoidConfidence,
   effectFor,
   detectFailurePatterns,
@@ -17529,4 +17650,4 @@ export {
   AgentCapability,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-OMIR6ISN.js.map
+//# sourceMappingURL=chunk-64IJKT4I.js.map