@sovr/engine 3.4.0 → 3.5.0

package/dist/index.mjs

@@ -1999,6 +1999,1206 @@ function createEvolutionChannel(config) {
   return new EvolutionChannelEngine(config);
 }
 
+// src/twoPhaseRouter.ts
+var DEFAULT_HARD_RULES = [
+  {
+    id: "HR-001",
+    name: "high_risk_requires_powerful",
+    condition: (req, candidate) => (req.riskLevel === "critical" || req.riskLevel === "high") && candidate.tier === "cheap",
+    reasonCode: "RISK_TIER_MISMATCH",
+    reasonTemplate: "High/critical risk tasks cannot use cheap tier models",
+    enabled: true
+  },
+  {
+    id: "HR-002",
+    name: "critical_requires_powerful_only",
+    condition: (req, candidate) => req.riskLevel === "critical" && candidate.tier !== "powerful",
+    reasonCode: "RISK_TIER_MISMATCH",
+    reasonTemplate: "Critical risk tasks require powerful tier models only",
+    enabled: true
+  },
+  {
+    id: "HR-003",
+    name: "budget_hard_cap",
+    condition: (req, candidate) => {
+      if (!req.maxCostUsd) return false;
+      const estimatedCost = req.estimatedTokens / 1e3 * candidate.costPer1kTokens;
+      return estimatedCost > req.maxCostUsd;
+    },
+    reasonCode: "COST_EXCEEDS_BUDGET",
+    reasonTemplate: "Estimated cost exceeds hard budget cap",
+    enabled: true
+  }
+];
+var DEFAULT_SCORING_WEIGHTS = {
+  cost: 0.25,
+  latency: 0.2,
+  capability: 0.25,
+  weight: 0.15,
+  tierMatch: 0.15
+};
+var TwoPhaseRouter = class {
+  config;
+  constructor(config) {
+    this.config = {
+      ...config,
+      hardRules: config.hardRules.length > 0 ? config.hardRules : DEFAULT_HARD_RULES,
+      scoringWeights: config.scoringWeights ?? DEFAULT_SCORING_WEIGHTS
+    };
+  }
+  /**
+   * Phase 1: Eligibility — 硬性规则过滤
+   */
+  evaluateEligibility(request) {
+    return this.config.models.map((candidate) => {
+      if (!candidate.enabled) {
+        return {
+          candidateId: candidate.id,
+          eligible: false,
+          reasonCode: "DISABLED",
+          reasonDetail: `Model ${candidate.name} is disabled`
+        };
+      }
+      const missingCaps = request.requiredCapabilities.filter(
+        (cap) => !candidate.capabilities.includes(cap)
+      );
+      if (missingCaps.length > 0) {
+        return {
+          candidateId: candidate.id,
+          eligible: false,
+          reasonCode: "CAPABILITY_MISSING",
+          reasonDetail: `Missing capabilities: ${missingCaps.join(", ")}`
+        };
+      }
+      if (request.estimatedTokens > candidate.maxContextTokens) {
+        return {
+          candidateId: candidate.id,
+          eligible: false,
+          reasonCode: "CONTEXT_TOO_LARGE",
+          reasonDetail: `Estimated ${request.estimatedTokens} tokens exceeds max ${candidate.maxContextTokens}`
+        };
+      }
+      if (request.maxLatencyMs && candidate.avgLatencyMs > request.maxLatencyMs) {
+        return {
+          candidateId: candidate.id,
+          eligible: false,
+          reasonCode: "LATENCY_EXCEEDS_LIMIT",
+          reasonDetail: `Avg latency ${candidate.avgLatencyMs}ms exceeds limit ${request.maxLatencyMs}ms`
+        };
+      }
+      for (const rule of this.config.hardRules) {
+        if (!rule.enabled) continue;
+        if (rule.condition(request, candidate)) {
+          return {
+            candidateId: candidate.id,
+            eligible: false,
+            reasonCode: rule.reasonCode,
+            reasonDetail: rule.reasonTemplate
+          };
+        }
+      }
+      return {
+        candidateId: candidate.id,
+        eligible: true,
+        reasonCode: "ELIGIBLE",
+        reasonDetail: "Passed all eligibility checks"
+      };
+    });
+  }
+  /**
+   * Phase 2: Scoring — 软性指标加权评分
+   */
+  evaluateScoring(request, eligibleIds) {
+    const eligible = this.config.models.filter((m) => eligibleIds.has(m.id));
+    if (eligible.length === 0) return [];
+    const w = this.config.scoringWeights;
+    const maxCost = Math.max(...eligible.map((m) => m.costPer1kTokens), 1e-3);
+    const maxLatency = Math.max(...eligible.map((m) => m.avgLatencyMs), 1);
+    return eligible.map((candidate) => {
+      const costScore = 100 * (1 - candidate.costPer1kTokens / maxCost);
+      const latencyScore = 100 * (1 - candidate.avgLatencyMs / maxLatency);
+      const matchedCaps = request.requiredCapabilities.filter(
+        (cap) => candidate.capabilities.includes(cap)
+      ).length;
+      const capabilityScore = request.requiredCapabilities.length > 0 ? 100 * (matchedCaps / request.requiredCapabilities.length) : 50;
+      const weightScore = candidate.weight;
+      let tierMatchScore = 50;
+      if (request.preferredTier) {
+        if (candidate.tier === request.preferredTier) tierMatchScore = 100;
+        else {
+          const tierOrder = ["cheap", "balanced", "powerful"];
+          const diff = Math.abs(
+            tierOrder.indexOf(candidate.tier) - tierOrder.indexOf(request.preferredTier)
+          );
+          tierMatchScore = Math.max(0, 100 - diff * 40);
+        }
+      }
+      const score = costScore * w.cost + latencyScore * w.latency + capabilityScore * w.capability + weightScore * w.weight + tierMatchScore * w.tierMatch;
+      return {
+        candidateId: candidate.id,
+        score: Math.round(score * 100) / 100,
+        breakdown: {
+          costScore: Math.round(costScore * 100) / 100,
+          latencyScore: Math.round(latencyScore * 100) / 100,
+          capabilityScore: Math.round(capabilityScore * 100) / 100,
+          weightScore: Math.round(weightScore * 100) / 100,
+          tierMatchScore: Math.round(tierMatchScore * 100) / 100
+        }
+      };
+    });
+  }
+  /**
+   * Main routing decision
+   */
+  async route(request) {
+    const startTime = Date.now();
+    const phase1Results = this.evaluateEligibility(request);
+    const eligibleIds = new Set(
+      phase1Results.filter((r) => r.eligible).map((r) => r.candidateId)
+    );
+    const phase2Results = this.evaluateScoring(request, eligibleIds);
+    phase2Results.sort((a, b) => b.score - a.score);
+    let selectedModelId;
+    let fallbackUsed = false;
+    const reasonChain = [];
+    if (phase2Results.length > 0) {
+      selectedModelId = phase2Results[0].candidateId;
+      reasonChain.push(
+        `Phase 1: ${eligibleIds.size}/${this.config.models.length} candidates eligible`
+      );
+      reasonChain.push(
+        `Phase 2: Top scorer = ${selectedModelId} (score: ${phase2Results[0].score})`
+      );
+      const rejected = phase1Results.filter((r) => !r.eligible);
+      if (rejected.length > 0) {
+        reasonChain.push(
+          `Rejected: ${rejected.map((r) => `${r.candidateId}(${r.reasonCode})`).join(", ")}`
+        );
+      }
+    } else if (this.config.fallbackModelId) {
+      selectedModelId = this.config.fallbackModelId;
+      fallbackUsed = true;
+      reasonChain.push("Phase 1: No eligible candidates");
+      reasonChain.push(`Fallback: Using ${selectedModelId}`);
+    } else {
+      const leastBad = this.config.models.find((m) => m.enabled);
+      selectedModelId = leastBad?.id ?? this.config.models[0]?.id ?? "unknown";
+      fallbackUsed = true;
+      reasonChain.push("Phase 1: No eligible candidates, no fallback configured");
+      reasonChain.push(`Emergency: Using ${selectedModelId}`);
+    }
+    const selectedModel = this.config.models.find((m) => m.id === selectedModelId);
+    const decisionTimeMs = Date.now() - startTime;
+    const decision = {
+      selectedModelId,
+      selectedModelName: selectedModel?.name ?? "unknown",
+      tier: selectedModel?.tier ?? this.config.defaultTier,
+      phase1Results,
+      phase2Results,
+      reasonChain,
+      totalCandidates: this.config.models.length,
+      eligibleCandidates: eligibleIds.size,
+      decisionTimeMs,
+      fallbackUsed
+    };
+    if (this.config.onDecision) {
+      try {
+        await this.config.onDecision(decision);
+      } catch {
+      }
+    }
+    if (this.config.onAudit) {
+      try {
+        await this.config.onAudit({
+          type: "routing_decision",
+          data: {
+            selectedModelId,
+            tier: decision.tier,
+            eligibleCount: eligibleIds.size,
+            totalCount: this.config.models.length,
+            fallbackUsed,
+            decisionTimeMs,
+            taskType: request.taskType,
+            riskLevel: request.riskLevel
+          }
+        });
+      } catch {
+      }
+    }
+    return decision;
+  }
+  /**
+   * Get models by tier
+   */
+  getModelsByTier(tier) {
+    return this.config.models.filter((m) => m.tier === tier && m.enabled);
+  }
+  /**
+   * Update model status
+   */
+  updateModel(modelId, updates) {
+    const idx = this.config.models.findIndex((m) => m.id === modelId);
+    if (idx === -1) return false;
+    this.config.models[idx] = { ...this.config.models[idx], ...updates };
+    return true;
+  }
+  /**
+   * Add a new hard rule
+   */
+  addHardRule(rule) {
+    this.config.hardRules.push(rule);
+  }
+  /**
+   * Get routing explanation for a specific request (dry run)
+   */
+  async explain(request) {
+    const decision = await this.route(request);
+    const lines = [
+      `=== SOVR Routing Explanation ===`,
+      `Task: ${request.taskType} | Risk: ${request.riskLevel}`,
+      `Required Capabilities: ${request.requiredCapabilities.join(", ") || "none"}`,
+      `Estimated Tokens: ${request.estimatedTokens}`,
+      ``,
+      `--- Phase 1: Eligibility ---`
+    ];
+    for (const r of decision.phase1Results) {
+      const model = this.config.models.find((m) => m.id === r.candidateId);
+      lines.push(
+        `  ${r.eligible ? "\u2705" : "\u274C"} ${model?.name ?? r.candidateId} [${r.reasonCode}] ${r.reasonDetail}`
+      );
+    }
+    lines.push("", `--- Phase 2: Scoring ---`);
+    for (const r of decision.phase2Results) {
+      const model = this.config.models.find((m) => m.id === r.candidateId);
+      lines.push(
+        `  ${model?.name ?? r.candidateId}: ${r.score} (cost=${r.breakdown.costScore} lat=${r.breakdown.latencyScore} cap=${r.breakdown.capabilityScore})`
+      );
+    }
+    lines.push(
+      "",
+      `--- Decision ---`,
+      `Selected: ${decision.selectedModelName} (${decision.tier})`,
+      `Fallback: ${decision.fallbackUsed ? "YES" : "NO"}`,
+      `Time: ${decision.decisionTimeMs}ms`
+    );
+    return { decision, explanation: lines.join("\n") };
+  }
+};
+
+// src/timeSeriesAggregator.ts
+var DEFAULT_TSA_CONFIG = {
+  windowSizeMs: 6e4,
+  // 1 minute
+  windowType: "tumbling",
+  maxWindows: 60,
+  // Keep 1 hour of 1-min windows
+  maxValuesPerWindow: 1e4
+};
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  if (sorted.length === 1) return sorted[0];
+  const idx = p / 100 * (sorted.length - 1);
+  const lower = Math.floor(idx);
+  const upper = Math.ceil(idx);
+  if (lower === upper) return sorted[lower];
+  return sorted[lower] + (sorted[upper] - sorted[lower]) * (idx - lower);
+}
+var TimeSeriesAggregator = class {
+  windows = /* @__PURE__ */ new Map();
+  closedResults = [];
+  config;
+  totalDedups = 0;
+  constructor(config) {
+    this.config = { ...DEFAULT_TSA_CONFIG, ...config };
+  }
+  /**
+   * Ingest a data point (idempotent — duplicates are rejected)
+   */
+  async ingest(point) {
+    const windowId = this.getWindowId(point.timestamp);
+    let window = this.windows.get(windowId);
+    if (!window) {
+      window = this.createWindow(windowId, point.timestamp);
+      this.windows.set(windowId, window);
+      this.evictOldWindows();
+    }
+    if (window.seenIds.has(point.id)) {
+      this.totalDedups++;
+      return { accepted: false, windowId, duplicate: true };
+    }
+    window.seenIds.add(point.id);
+    window.count++;
+    window.sum += point.value;
+    window.min = Math.min(window.min, point.value);
+    window.max = Math.max(window.max, point.value);
+    if (window.values.length < this.config.maxValuesPerWindow) {
+      window.values.push(point.value);
+    }
+    return { accepted: true, windowId, duplicate: false };
+  }
+  /**
+   * Ingest multiple points (batch)
+   */
+  async ingestBatch(points) {
+    let accepted = 0;
+    let duplicates = 0;
+    let errors = 0;
+    for (const point of points) {
+      try {
+        const result = await this.ingest(point);
+        if (result.accepted) accepted++;
+        if (result.duplicate) duplicates++;
+      } catch {
+        errors++;
+      }
+    }
+    return { accepted, duplicates, errors };
+  }
+  /**
+   * Get aggregation result for a specific window
+   */
+  getWindowResult(windowId) {
+    const window = this.windows.get(windowId);
+    if (!window) {
+      return this.closedResults.find((r) => r.windowId === windowId) ?? null;
+    }
+    return this.computeResult(window);
+  }
+  /**
+   * Get current (latest) window result
+   */
+  getCurrentResult() {
+    const now = Date.now();
+    const windowId = this.getWindowId(now);
+    return this.getWindowResult(windowId);
+  }
+  /**
+   * Get results for a time range
+   */
+  getResultsInRange(startMs, endMs) {
+    const results = [];
+    for (const window of this.windows.values()) {
+      if (window.startMs >= startMs && window.endMs <= endMs) {
+        results.push(this.computeResult(window));
+      }
+    }
+    for (const result of this.closedResults) {
+      if (result.startMs >= startMs && result.endMs <= endMs) {
+        if (!results.find((r) => r.windowId === result.windowId)) {
+          results.push(result);
+        }
+      }
+    }
+    return results.sort((a, b) => a.startMs - b.startMs);
+  }
+  /**
+   * Close current window and emit result
+   */
+  async closeWindow(windowId) {
+    const window = this.windows.get(windowId);
+    if (!window) return null;
+    const result = this.computeResult(window);
+    this.closedResults.push(result);
+    this.windows.delete(windowId);
+    if (this.closedResults.length > this.config.maxWindows * 2) {
+      this.closedResults = this.closedResults.slice(-this.config.maxWindows);
+    }
+    if (this.config.onWindowClosed) {
+      try {
+        await this.config.onWindowClosed(result);
+      } catch {
+      }
+    }
+    if (this.config.onAudit) {
+      try {
+        await this.config.onAudit({
+          type: "window_closed",
+          data: {
+            windowId,
+            count: result.metrics.count,
+            avg: result.metrics.avg,
+            p95: result.metrics.p95,
+            dedupCount: result.dedupCount
+          }
+        });
+      } catch {
+      }
+    }
+    return result;
+  }
+  /**
+   * Get overall stats
+   */
+  getStats() {
+    let totalDataPoints = 0;
+    for (const w of this.windows.values()) totalDataPoints += w.count;
+    for (const r of this.closedResults) totalDataPoints += r.metrics.count;
+    return {
+      activeWindows: this.windows.size,
+      closedWindows: this.closedResults.length,
+      totalDedups: this.totalDedups,
+      totalDataPoints
+    };
+  }
+  /**
+   * Reset all windows
+   */
+  reset() {
+    this.windows.clear();
+    this.closedResults = [];
+    this.totalDedups = 0;
+  }
+  // ─── Internal ────────────────────────────────────────────────────
+  getWindowId(timestamp) {
+    const windowStart = Math.floor(timestamp / this.config.windowSizeMs) * this.config.windowSizeMs;
+    return `w_${windowStart}`;
+  }
+  createWindow(windowId, timestamp) {
+    const windowStart = Math.floor(timestamp / this.config.windowSizeMs) * this.config.windowSizeMs;
+    return {
+      windowId,
+      windowType: this.config.windowType,
+      startMs: windowStart,
+      endMs: windowStart + this.config.windowSizeMs,
+      count: 0,
+      sum: 0,
+      min: Infinity,
+      max: -Infinity,
+      values: [],
+      seenIds: /* @__PURE__ */ new Set()
+    };
+  }
+  computeResult(window) {
+    const sorted = [...window.values].sort((a, b) => a - b);
+    const durationSec = (window.endMs - window.startMs) / 1e3;
+    return {
+      windowId: window.windowId,
+      windowType: window.windowType,
+      startMs: window.startMs,
+      endMs: window.endMs,
+      metrics: {
+        count: window.count,
+        sum: window.sum,
+        avg: window.count > 0 ? window.sum / window.count : 0,
+        min: window.min === Infinity ? 0 : window.min,
+        max: window.max === -Infinity ? 0 : window.max,
+        p50: percentile(sorted, 50),
+        p95: percentile(sorted, 95),
+        p99: percentile(sorted, 99),
+        rate: durationSec > 0 ? window.count / durationSec : 0
+      },
+      dedupCount: window.seenIds.size - window.count > 0 ? 0 : this.totalDedups
+    };
+  }
+  evictOldWindows() {
+    if (this.windows.size <= this.config.maxWindows) return;
+    const sorted = Array.from(this.windows.entries()).sort((a, b) => a[1].startMs - b[1].startMs);
+    while (sorted.length > this.config.maxWindows) {
+      const [id, window] = sorted.shift();
+      this.closedResults.push(this.computeResult(window));
+      this.windows.delete(id);
+    }
+  }
+};
+
+// src/valuationModel.ts
+var ValuationModel = class {
+  config;
+  constructor(config) {
+    this.config = config ?? {};
+  }
+  /**
+   * Calculate TAM/SAM/SOM
+   */
+  calculateMarketSize(input) {
+    return {
+      tam: input.totalMarketUsd,
+      sam: input.totalMarketUsd * input.serviceablePercent,
+      som: input.totalMarketUsd * input.serviceablePercent * input.obtainablePercent,
+      year: input.year,
+      growthRate: input.growthRate,
+      assumptions: input.assumptions
+    };
+  }
+  /**
+   * Calculate Unit Economics
+   */
+  calculateUnitEconomics(input) {
+    const netChurn = input.churnRate - input.expansionRate;
+    const effectiveChurn = Math.max(netChurn, 1e-3);
+    const ltv = input.arpu * input.grossMargin / effectiveChurn;
+    const paybackMonths = input.cac / (input.arpu * input.grossMargin);
+    return {
+      arpu: input.arpu,
+      cac: input.cac,
+      ltv: Math.round(ltv * 100) / 100,
+      ltvCacRatio: Math.round(ltv / input.cac * 100) / 100,
+      paybackMonths: Math.round(paybackMonths * 10) / 10,
+      grossMargin: input.grossMargin,
+      churnRate: input.churnRate,
+      expansionRate: input.expansionRate
+    };
+  }
+  /**
+   * DCF Valuation
+   */
+  calculateDCF(input) {
+    const fcfs = [];
+    const discountedFcfs = [];
+    for (let i = 0; i < input.projectedRevenues.length; i++) {
+      const revenue = input.projectedRevenues[i];
+      const operatingIncome = revenue * input.operatingMargin;
+      const afterTax = operatingIncome * (1 - input.taxRate);
+      const capex = revenue * input.capexRatio;
+      const fcf = afterTax - capex;
+      fcfs.push(fcf);
+      const discountFactor = Math.pow(1 + input.discountRate, i + 1);
+      discountedFcfs.push(fcf / discountFactor);
+    }
+    const presentValue = discountedFcfs.reduce((sum, v) => sum + v, 0);
+    const lastFcf = fcfs[fcfs.length - 1] ?? 0;
+    const terminalFcf = lastFcf * (1 + input.terminalGrowthRate);
+    const terminalValue = terminalFcf / (input.discountRate - input.terminalGrowthRate);
+    const discountedTerminal = terminalValue / Math.pow(1 + input.discountRate, input.projectedRevenues.length);
+    const enterpriseValue = presentValue + discountedTerminal;
+    const lastRevenue = input.projectedRevenues[input.projectedRevenues.length - 1] ?? 1;
+    const impliedMultiple = enterpriseValue / lastRevenue;
+    return {
+      presentValue: Math.round(presentValue),
+      terminalValue: Math.round(discountedTerminal),
+      enterpriseValue: Math.round(enterpriseValue),
+      freeCashFlows: fcfs.map((v) => Math.round(v)),
+      discountedCashFlows: discountedFcfs.map((v) => Math.round(v)),
+      impliedMultiple: Math.round(impliedMultiple * 10) / 10
+    };
+  }
+  /**
+   * Comparable Company Valuation
+   */
+  calculateComparable(input) {
+    const revMultiples = input.comparables.map((c) => c.evRevenue);
+    const ebitdaMultiples = input.comparables.map((c) => c.evEbitda);
+    const userValues = input.comparables.map((c) => c.evUser);
+    const medianRevMultiple = this.median(revMultiples);
+    const medianEbitdaMultiple = this.median(ebitdaMultiples);
+    const medianUserValue = this.median(userValues);
+    const revenueVal = input.revenue * medianRevMultiple;
+    const ebitdaVal = input.ebitda * medianEbitdaMultiple;
+    const userVal = input.users * medianUserValue;
+    const avgCompGrowth = input.comparables.reduce((s, c) => s + c.growthRate, 0) / input.comparables.length;
+    const growthPremium = input.growthRate / (avgCompGrowth || 0.1);
+    const growthAdjusted = revenueVal * Math.min(growthPremium, 3);
+    return {
+      revenueMultipleValuation: Math.round(revenueVal),
+      ebitdaMultipleValuation: Math.round(ebitdaVal),
+      perUserValuation: Math.round(userVal),
+      averageValuation: Math.round((revenueVal + ebitdaVal + userVal) / 3),
+      medianMultiple: medianRevMultiple,
+      growthAdjustedValuation: Math.round(growthAdjusted)
+    };
+  }
+  /**
+   * Network Effect Valuation (Metcalfe's Law)
+   */
+  calculateNetworkEffect(input) {
+    const currentValue = Math.pow(input.currentUsers, input.metcalfeExponent) * input.valuePerConnection * input.networkDensity;
+    const projectedValues = input.projectedUsers.map(
+      (users) => Math.pow(users, input.metcalfeExponent) * input.valuePerConnection * input.networkDensity
+    );
+    const metcalfeValue = Math.pow(input.currentUsers, 2) * input.valuePerConnection;
+    const adjustedValue = metcalfeValue * input.networkDensity;
+    return {
+      currentNetworkValue: Math.round(currentValue),
+      projectedValues: projectedValues.map((v) => Math.round(v)),
+      metcalfeValue: Math.round(metcalfeValue),
+      adjustedValue: Math.round(adjustedValue)
+    };
+  }
+  /**
+   * Sensitivity Analysis
+   */
+  runSensitivity(baseInput, variables) {
+    const baseResult = this.calculateDCF(baseInput);
+    const baseCase = baseResult.enterpriseValue;
+    const scenarios = [];
+    const tornado = [];
+    for (const v of variables) {
+      const lowInput = { ...baseInput, [v.field]: v.low };
+      const lowResult = this.calculateDCF(lowInput);
+      const highInput = { ...baseInput, [v.field]: v.high };
+      const highResult = this.calculateDCF(highInput);
+      scenarios.push({
+        name: `${v.name} Low`,
+        value: lowResult.enterpriseValue,
+        delta: (lowResult.enterpriseValue - baseCase) / baseCase * 100,
+        variables: { [v.name]: v.low }
+      });
+      scenarios.push({
+        name: `${v.name} High`,
+        value: highResult.enterpriseValue,
+        delta: (highResult.enterpriseValue - baseCase) / baseCase * 100,
+        variables: { [v.name]: v.high }
+      });
+      tornado.push({
+        variable: v.name,
+        lowValue: lowResult.enterpriseValue,
+        highValue: highResult.enterpriseValue,
+        range: Math.abs(highResult.enterpriseValue - lowResult.enterpriseValue)
+      });
+    }
+    tornado.sort((a, b) => b.range - a.range);
+    return { baseCase, scenarios, tornado };
+  }
+  // ─── Helpers ─────────────────────────────────────────────────────
+  median(values) {
+    if (values.length === 0) return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+  }
+};
+
+// src/governanceEnhancer.ts
+var DEFAULT_GE_CONFIG = {
+  circuitBreakerThreshold: 5,
+  circuitBreakerTimeoutMs: 3e4,
+  halfOpenSuccessThreshold: 3,
+  degradationChain: [
+    {
+      id: "full",
+      name: "Full Capability",
+      order: 4,
+      capabilities: ["all"],
+      restrictions: []
+    },
+    {
+      id: "reduced",
+      name: "Reduced Capability",
+      order: 3,
+      capabilities: ["read", "compute", "cache"],
+      restrictions: ["write", "external_api"]
+    },
+    {
+      id: "minimal",
+      name: "Minimal Capability",
+      order: 2,
+      capabilities: ["read", "cache"],
+      restrictions: ["write", "compute", "external_api"]
+    },
+    {
+      id: "readonly",
+      name: "Read-Only Mode",
+      order: 1,
+      capabilities: ["read"],
+      restrictions: ["write", "compute", "external_api", "cache"]
+    }
+  ],
+  maxPolicyVersions: 10
+};
+function simpleHash2(input) {
+  let hash = 0;
+  for (let i = 0; i < input.length; i++) {
+    hash = (hash << 5) - hash + input.charCodeAt(i);
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(16).padStart(8, "0");
+}
+var GovernanceEnhancer = class {
+  currentPolicy = null;
+  policyHistory = [];
+  circuitBreakers = /* @__PURE__ */ new Map();
+  currentDegradationLevel = "full";
+  config;
+  constructor(config) {
+    this.config = { ...DEFAULT_GE_CONFIG, ...config };
+  }
+  // ─── Policy Hot-Reload ───────────────────────────────────────────
+  /**
+   * Load a new policy version (hot-reload)
+   */
+  async loadPolicy(version, rules) {
+    const hash = simpleHash2(JSON.stringify(rules));
+    const oldVersion = this.currentPolicy?.version;
+    const newPolicy = {
+      version,
+      rules: rules.sort((a, b) => b.priority - a.priority),
+      activatedAt: Date.now(),
+      hash
+    };
+    if (this.currentPolicy) {
+      this.policyHistory.push(this.currentPolicy);
+      if (this.policyHistory.length > this.config.maxPolicyVersions) {
+        this.policyHistory = this.policyHistory.slice(-this.config.maxPolicyVersions);
+      }
+    }
+    this.currentPolicy = newPolicy;
+    if (this.config.onPolicyChange && oldVersion) {
+      try {
+        await this.config.onPolicyChange(oldVersion, version);
+      } catch {
+      }
+    }
+    if (this.config.onAudit) {
+      try {
+        await this.config.onAudit({
+          type: "policy_loaded",
+          data: { version, ruleCount: rules.length, hash, previousVersion: oldVersion }
+        });
+      } catch {
+      }
+    }
+    return { success: true, previousVersion: oldVersion, newVersion: version };
+  }
+  /**
+   * Rollback to a previous policy version
+   */
+  async rollbackPolicy(version) {
+    const target = this.policyHistory.find((p) => p.version === version);
+    if (!target) return false;
+    if (this.currentPolicy) {
+      this.policyHistory.push(this.currentPolicy);
+    }
+    this.currentPolicy = { ...target, activatedAt: Date.now() };
+    return true;
+  }
+  /**
+   * Evaluate a governance decision
+   */
+  async evaluate(context) {
+    if (!this.currentPolicy) {
+      return {
+        allowed: false,
+        action: "deny",
+        reason: "No policy loaded",
+        policyVersion: "none"
+      };
+    }
+    const cbState = this.getCircuitBreakerState(context.resource);
+    if (cbState === "OPEN") {
+      return {
+        allowed: false,
+        action: "deny",
+        circuitState: "OPEN",
+        reason: `Circuit breaker OPEN for ${context.resource}`,
+        policyVersion: this.currentPolicy.version
+      };
+    }
+    for (const rule of this.currentPolicy.rules) {
+      if (!rule.enabled) continue;
+      const matches = this.evaluateCondition(rule.condition, context);
+      if (!matches) continue;
+      const decision = {
+        allowed: rule.action === "allow",
+        action: rule.action,
+        ruleId: rule.id,
+        ruleName: rule.name,
+        circuitState: cbState,
+        policyVersion: this.currentPolicy.version,
+        reason: `Rule ${rule.name} matched: ${rule.action}`
+      };
+      if (rule.action === "degrade" && rule.degradeTo) {
+        decision.degradationLevel = rule.degradeTo;
+        decision.allowed = true;
+        this.currentDegradationLevel = rule.degradeTo;
+      }
+      if (this.config.onAudit) {
+        try {
+          await this.config.onAudit({
+            type: "governance_decision",
+            data: {
+              action: context.action,
+              resource: context.resource,
+              decision: rule.action,
+              ruleId: rule.id,
+              policyVersion: this.currentPolicy.version
+            }
+          });
+        } catch {
+        }
+      }
+      return decision;
+    }
+    return {
+      allowed: true,
+      action: "allow",
+      reason: "No matching rule, default allow",
+      policyVersion: this.currentPolicy.version,
+      circuitState: cbState
+    };
+  }
+  // ─── Circuit Breaker ─────────────────────────────────────────────
+  /**
+   * Record a success for circuit breaker
+   */
+  recordSuccess(resource) {
+    const cb = this.getOrCreateCircuitBreaker(resource);
+    cb.successCount++;
+    cb.lastSuccessAt = Date.now();
+    if (cb.state === "HALF_OPEN") {
+      if (cb.successCount >= this.config.halfOpenSuccessThreshold) {
+        cb.state = "CLOSED";
+        cb.failureCount = 0;
+        cb.halfOpenAttempts = 0;
+      }
+    }
+  }
+  /**
+   * Record a failure for circuit breaker
+   */
+  recordFailure(resource) {
+    const cb = this.getOrCreateCircuitBreaker(resource);
+    cb.failureCount++;
+    cb.lastFailureAt = Date.now();
+    if (cb.state === "CLOSED" && cb.failureCount >= this.config.circuitBreakerThreshold) {
+      cb.state = "OPEN";
+      cb.openedAt = Date.now();
+    } else if (cb.state === "HALF_OPEN") {
+      cb.state = "OPEN";
+      cb.openedAt = Date.now();
+      cb.halfOpenAttempts++;
+    }
+  }
+  /**
+   * Get circuit breaker state for a resource
+   */
+  getCircuitBreakerState(resource) {
+    const cb = this.circuitBreakers.get(resource);
+    if (!cb) return "CLOSED";
+    if (cb.state === "OPEN") {
+      const elapsed = Date.now() - cb.openedAt;
+      if (elapsed >= this.config.circuitBreakerTimeoutMs) {
+        cb.state = "HALF_OPEN";
+        cb.successCount = 0;
+      }
+    }
+    return cb.state;
+  }
+  // ─── Degradation Chain ───────────────────────────────────────────
+  /**
+   * Get current degradation level
+   */
+  getCurrentDegradationLevel() {
+    return this.config.degradationChain.find((d) => d.id === this.currentDegradationLevel);
+  }
+  /**
+   * Degrade to next level
+   */
+  degradeOneLevel() {
+    const current = this.config.degradationChain.find((d) => d.id === this.currentDegradationLevel);
+    if (!current) return null;
+    const nextLevel = this.config.degradationChain.filter((d) => d.order < current.order).sort((a, b) => b.order - a.order)[0];
+    if (nextLevel) {
+      this.currentDegradationLevel = nextLevel.id;
+      return nextLevel;
+    }
+    return null;
+  }
+  /**
+   * Restore to full capability
+   */
+  restoreFullCapability() {
+    this.currentDegradationLevel = "full";
+  }
+  /**
+   * Check if a capability is available at current degradation level
+   */
+  isCapabilityAvailable(capability) {
+    const level = this.getCurrentDegradationLevel();
+    if (!level) return false;
+    return level.capabilities.includes("all") || level.capabilities.includes(capability);
+  }
+  // ─── Status ──────────────────────────────────────────────────────
+  /**
+   * Get full governance status
+   */
+  getStatus() {
+    return {
+      policyVersion: this.currentPolicy?.version ?? null,
+      ruleCount: this.currentPolicy?.rules.length ?? 0,
+      degradationLevel: this.currentDegradationLevel,
+      circuitBreakers: Array.from(this.circuitBreakers.values()),
+      policyHistoryCount: this.policyHistory.length
+    };
+  }
+  // ─── Internal ────────────────────────────────────────────────────
+  evaluateCondition(condition, context) {
+    if (condition === "*") return true;
+    if (condition.startsWith("action:")) {
+      return context.action === condition.substring(7);
+    }
+    if (condition.startsWith("resource:")) {
+      return context.resource.includes(condition.substring(9));
+    }
+    if (condition.startsWith("agent:")) {
+      return context.agentId === condition.substring(6);
+    }
+    return false;
+  }
+  getOrCreateCircuitBreaker(resource) {
+    let cb = this.circuitBreakers.get(resource);
+    if (!cb) {
+      cb = {
+        name: resource,
+        state: "CLOSED",
+        failureCount: 0,
+        successCount: 0,
+        lastFailureAt: 0,
+        lastSuccessAt: 0,
+        openedAt: 0,
+        halfOpenAttempts: 0
+      };
+      this.circuitBreakers.set(resource, cb);
+    }
+    return cb;
+  }
+};
+
+// src/contextAccelerator.ts
+var DEFAULT_CA_CONFIG = {
+  maxCacheEntries: 500,
+  defaultTtlMs: 3e5,
+  // 5 minutes
+  tokenBudget: 8e3,
+  compressionTarget: 0.5,
+  priorityWeights: {
+    critical: 100,
+    high: 75,
+    medium: 50,
+    low: 25
+  }
+};
+function estimateTokens(text) {
+  return Math.ceil(text.length / 3.5);
+}
+function defaultCompressor(content, targetTokens) {
+  const currentTokens = estimateTokens(content);
+  if (currentTokens <= targetTokens) return content;
+  const ratio = targetTokens / currentTokens;
+  const targetLength = Math.floor(content.length * ratio);
+  if (targetLength < 50) return content.substring(0, 50) + "...";
+  return content.substring(0, targetLength) + "...[compressed]";
+}
+var ContextAccelerator = class {
+  cache = /* @__PURE__ */ new Map();
+  prefetchRules = /* @__PURE__ */ new Map();
+  config;
+  stats = {
+    totalHits: 0,
+    totalMisses: 0,
+    totalEvictions: 0,
+    totalCompressions: 0,
+    totalAssemblies: 0
+  };
+  constructor(config) {
+    this.config = { ...DEFAULT_CA_CONFIG, ...config };
+  }
+  /**
+   * Put a fragment into cache
+   */
+  put(fragment) {
+    this.evictExpired();
+    if (this.cache.size >= this.config.maxCacheEntries) {
+      this.evictLRU();
+    }
+    this.cache.set(fragment.id, {
+      fragment,
+      accessCount: 0,
+      lastAccessedAt: Date.now(),
+      createdAt: Date.now(),
+      expiresAt: Date.now() + (fragment.ttlMs || this.config.defaultTtlMs)
+    });
+  }
+  /**
+   * Get a fragment from cache
+   */
+  get(id) {
+    const entry = this.cache.get(id);
+    if (!entry) {
+      this.stats.totalMisses++;
+      return null;
+    }
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(id);
+      this.stats.totalMisses++;
+      return null;
+    }
+    entry.accessCount++;
+    entry.lastAccessedAt = Date.now();
+    this.stats.totalHits++;
+    return entry.fragment;
+  }
+  /**
+   * Assemble context from fragments within token budget
+   */
+  async assemble(fragmentIds, additionalFragments, budgetOverride) {
+    const startTime = Date.now();
+    const budget = budgetOverride ?? this.config.tokenBudget;
+    let cacheHits = 0;
+    let cacheMisses = 0;
+    const allFragments = [];
+    for (const id of fragmentIds) {
+      const fragment = this.get(id);
+      if (fragment) {
+        allFragments.push(fragment);
+        cacheHits++;
+      } else {
+        cacheMisses++;
+      }
+    }
+    if (additionalFragments) {
+      allFragments.push(...additionalFragments);
+    }
+    const weights = this.config.priorityWeights;
+    allFragments.sort((a, b) => {
+      const wDiff = (weights[b.priority] ?? 0) - (weights[a.priority] ?? 0);
+      if (wDiff !== 0) return wDiff;
+      return b.timestamp - a.timestamp;
+    });
+    const selected = [];
+    let totalTokens = 0;
+    let droppedCount = 0;
+    let compressedCount = 0;
+    for (const fragment of allFragments) {
+      if (totalTokens >= budget) {
+        droppedCount++;
+        continue;
+      }
+      const remaining = budget - totalTokens;
+      if (fragment.tokenCount <= remaining) {
+        selected.push(fragment);
+        totalTokens += fragment.tokenCount;
+      } else if (fragment.priority === "critical" || fragment.priority === "high") {
+        const compressor = this.config.compressor ?? defaultCompressor;
+        const compressed = compressor(fragment.content, remaining);
+        const compressedTokens = estimateTokens(compressed);
+        selected.push({
+          ...fragment,
+          content: compressed,
+          tokenCount: compressedTokens,
+          compressed: true
+        });
+        totalTokens += compressedTokens;
+        compressedCount++;
+        this.stats.totalCompressions++;
+      } else {
+        droppedCount++;
+      }
+    }
+    this.stats.totalAssemblies++;
+    const result = {
+      fragments: selected,
+      totalTokens,
+      budgetUsed: budget > 0 ? totalTokens / budget : 0,
+      droppedCount,
+      compressedCount,
+      cacheHits,
+      cacheMisses,
+      assemblyTimeMs: Date.now() - startTime
+    };
+    if (this.config.onAudit) {
+      try {
+        await this.config.onAudit({
+          type: "context_assembled",
+          data: {
+            totalTokens,
+            budgetUsed: result.budgetUsed,
+            fragmentCount: selected.length,
+            droppedCount,
+            compressedCount,
+            cacheHits,
+            cacheMisses,
+            assemblyTimeMs: result.assemblyTimeMs
+          }
+        });
+      } catch {
+      }
+    }
+    return result;
+  }
+  /**
+   * Register a prefetch rule
+   */
+  addPrefetchRule(rule) {
+    this.prefetchRules.set(rule.id, rule);
+  }
+  /**
+   * Execute prefetch based on task type
+   */
+  async prefetch(taskType, fragmentLoader) {
+    const matchingRules = Array.from(this.prefetchRules.values()).filter(
+      (r) => r.enabled && taskType.includes(r.trigger)
+    );
+    if (matchingRules.length === 0) return 0;
+    const idsToFetch = /* @__PURE__ */ new Set();
+    for (const rule of matchingRules) {
+      for (const id of rule.fragmentIds) {
+        if (!this.cache.has(id)) {
+          idsToFetch.add(id);
+        }
+      }
+    }
+    if (idsToFetch.size === 0) return 0;
+    const fragments = await fragmentLoader(Array.from(idsToFetch));
+    for (const f of fragments) {
+      this.put(f);
+    }
+    return fragments.length;
+  }
+  /**
+   * Invalidate cache entries
+   */
+  invalidate(ids) {
+    let count = 0;
+    for (const id of ids) {
+      if (this.cache.delete(id)) count++;
+    }
+    return count;
+  }
+  /**
+   * Get cache stats
+   */
+  getStats() {
+    const total = this.stats.totalHits + this.stats.totalMisses;
+    return {
+      cacheSize: this.cache.size,
+      maxSize: this.config.maxCacheEntries,
+      hitRate: total > 0 ? this.stats.totalHits / total : 0,
+      ...this.stats,
+      prefetchRuleCount: this.prefetchRules.size
+    };
+  }
+  /**
+   * Clear all cache
+   */
+  clear() {
+    this.cache.clear();
+  }
+  // ─── Internal ────────────────────────────────────────────────────
+  evictExpired() {
+    const now = Date.now();
+    for (const [id, entry] of this.cache) {
+      if (now > entry.expiresAt) {
+        this.cache.delete(id);
+        this.stats.totalEvictions++;
+      }
+    }
+  }
+  evictLRU() {
+    let oldestId = null;
+    let oldestAccess = Infinity;
+    for (const [id, entry] of this.cache) {
+      if (entry.lastAccessedAt < oldestAccess) {
+        oldestAccess = entry.lastAccessedAt;
+        oldestId = id;
+      }
+    }
+    if (oldestId) {
+      this.cache.delete(oldestId);
+      this.stats.totalEvictions++;
+    }
+  }
+};
+
 // src/index.ts
 var DEFAULT_RULES = [
   // --- HTTP Proxy: Dangerous outbound calls ---
@@ -2489,16 +3689,26 @@ var index_default = PolicyEngine;
 export {
   AdaptiveThresholdManager,
   AutoHardenEngine,
+  ContextAccelerator,
   CostGateEnhancedEngine,
+  DEFAULT_CA_CONFIG,
+  DEFAULT_GE_CONFIG,
+  DEFAULT_HARD_RULES,
   DEFAULT_RULES,
+  DEFAULT_SCORING_WEIGHTS,
+  DEFAULT_TSA_CONFIG,
   EvolutionChannelEngine,
   FeatureSwitchesManager,
+  GovernanceEnhancer,
   MultiLevelBudgetEngine,
   PolicyEngine,
   PricingRulesEngine,
   RecalculationEngine,
   SOVR_FEATURE_SWITCHES,
   SemanticDriftDetectorEngine,
+  TimeSeriesAggregator,
+  TwoPhaseRouter,
+  ValuationModel,
   compileFromJSON,
   compileRuleSet,
   createAutoHardenEngine,