@sovr/engine 3.4.0 → 3.6.0

package/dist/index.js

@@ -22,16 +22,30 @@ var index_exports = {};
 __export(index_exports, {
   AdaptiveThresholdManager: () => AdaptiveThresholdManager,
   AutoHardenEngine: () => AutoHardenEngine,
+  ContextAccelerator: () => ContextAccelerator,
+  ContributionSettlementEngine: () => ContributionSettlementEngine,
   CostGateEnhancedEngine: () => CostGateEnhancedEngine,
+  DEFAULT_CA_CONFIG: () => DEFAULT_CA_CONFIG,
+  DEFAULT_GE_CONFIG: () => DEFAULT_GE_CONFIG,
+  DEFAULT_HARD_RULES: () => DEFAULT_HARD_RULES,
   DEFAULT_RULES: () => DEFAULT_RULES,
+  DEFAULT_SCORING_WEIGHTS: () => DEFAULT_SCORING_WEIGHTS,
+  DEFAULT_TSA_CONFIG: () => DEFAULT_TSA_CONFIG,
   EvolutionChannelEngine: () => EvolutionChannelEngine,
   FeatureSwitchesManager: () => FeatureSwitchesManager,
+  GovernanceEnhancer: () => GovernanceEnhancer,
   MultiLevelBudgetEngine: () => MultiLevelBudgetEngine,
+  OverrideDriftAnalyzer: () => OverrideDriftAnalyzer,
   PolicyEngine: () => PolicyEngine,
   PricingRulesEngine: () => PricingRulesEngine,
   RecalculationEngine: () => RecalculationEngine,
   SOVR_FEATURE_SWITCHES: () => SOVR_FEATURE_SWITCHES,
+  SelfConstraintEngine: () => SelfConstraintEngine,
   SemanticDriftDetectorEngine: () => SemanticDriftDetectorEngine,
+  TimeSeriesAggregator: () => TimeSeriesAggregator,
+  TrendAlertEngine: () => TrendAlertEngine,
+  TwoPhaseRouter: () => TwoPhaseRouter,
+  ValuationModel: () => ValuationModel,
   compileFromJSON: () => compileFromJSON,
   compileRuleSet: () => compileRuleSet,
   createAutoHardenEngine: () => createAutoHardenEngine,
@@ -2054,6 +2068,2264 @@ 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/trendAlertEngine.ts
+var DEFAULT_THRESHOLDS2 = [
+  {
+    alert_type: "BLOCK_RATE_SURGE",
+    metric_name: "block_rate",
+    baseline_window_hours: 24,
+    surge_multiplier: 2,
+    absolute_threshold: 0.5,
+    severity: "CRITICAL",
+    protective_actions: ["TIGHTEN_THRESHOLD", "NOTIFY_ONLY"],
+    cooldown_seconds: 300,
+    enabled: true
+  },
+  {
+    alert_type: "OVERRIDE_RATE_SURGE",
+    metric_name: "override_rate",
+    baseline_window_hours: 24,
+    surge_multiplier: 3,
+    absolute_threshold: 0.3,
+    severity: "CRITICAL",
+    protective_actions: ["TIGHTEN_THRESHOLD", "FORCE_HUMAN_GATE"],
+    cooldown_seconds: 300,
+    enabled: true
+  },
+  {
+    alert_type: "UNKNOWN_REASON_CODE",
+    metric_name: "unknown_reason_rate",
+    baseline_window_hours: 1,
+    surge_multiplier: 1.5,
+    absolute_threshold: 0.1,
+    severity: "WARN",
+    protective_actions: ["NOTIFY_ONLY"],
+    cooldown_seconds: 600,
+    enabled: true
+  },
+  {
+    alert_type: "APPROVAL_QUEUE_BACKLOG",
+    metric_name: "pending_approval_count",
+    baseline_window_hours: 1,
+    surge_multiplier: 5,
+    absolute_threshold: 50,
+    severity: "CRITICAL",
+    protective_actions: ["DEGRADE", "NOTIFY_ONLY"],
+    cooldown_seconds: 180,
+    enabled: true
+  },
+  {
+    alert_type: "CONFIDENCE_DROP",
+    metric_name: "avg_confidence",
+    baseline_window_hours: 24,
+    surge_multiplier: 0.5,
+    // 低于基线的比例
+    absolute_threshold: 0.3,
+    severity: "WARN",
+    protective_actions: ["TIGHTEN_THRESHOLD"],
+    cooldown_seconds: 600,
+    enabled: true
+  },
+  {
+    alert_type: "ERROR_RATE_SURGE",
+    metric_name: "error_rate",
+    baseline_window_hours: 1,
+    surge_multiplier: 3,
+    absolute_threshold: 0.2,
+    severity: "EMERGENCY",
+    protective_actions: ["KILL_SWITCH"],
+    cooldown_seconds: 60,
+    enabled: true
+  }
+];
+var TrendAlertEngine = class {
+  thresholds;
+  alertHistory = [];
+  lastAlertTime = /* @__PURE__ */ new Map();
+  systemState;
+  metricsBuffer = [];
+  constructor(customThresholds) {
+    this.thresholds = customThresholds || DEFAULT_THRESHOLDS2;
+    this.systemState = {
+      kill_switch: { enabled: false, reason: null, enabled_at: null, enabled_by: "system", auto_triggered: false },
+      degrade: { active: false, level: "LIGHT", reason: "", activated_at: null, auto_recover_at: null },
+      tightened_threshold_multiplier: 1,
+      force_human_gate: false
+    };
+  }
+  // ---- 核心: 评估趋势 ----
+  evaluate(metrics, tenantId = "default") {
+    const alerts = [];
+    this.metricsBuffer = metrics;
+    for (const threshold of this.thresholds) {
+      if (!threshold.enabled) continue;
+      const metric = metrics.find((m) => m.metric_name === threshold.metric_name);
+      if (!metric) continue;
+      const lastAlert = this.lastAlertTime.get(threshold.alert_type);
+      if (lastAlert && Date.now() - lastAlert < threshold.cooldown_seconds * 1e3) {
+        continue;
+      }
+      const triggered = this.checkThreshold(metric, threshold);
+      if (!triggered) continue;
+      const surgeRatio = metric.baseline_value > 0 ? metric.current_value / metric.baseline_value : metric.current_value;
+      const alert = {
+        alert_id: `alert_${threshold.alert_type}_${Date.now()}`,
+        alert_type: threshold.alert_type,
+        severity: threshold.severity,
+        metric_name: threshold.metric_name,
+        current_value: metric.current_value,
+        baseline_value: metric.baseline_value,
+        threshold_value: threshold.absolute_threshold,
+        surge_ratio: Math.round(surgeRatio * 100) / 100,
+        protective_actions_taken: [],
+        message: this.formatAlertMessage(threshold, metric, surgeRatio),
+        tenant_id: tenantId,
+        created_at: Date.now(),
+        acknowledged: false,
+        acknowledged_by: null,
+        acknowledged_at: null
+      };
+      for (const action of threshold.protective_actions) {
+        this.executeProtectiveAction(action, alert);
+        alert.protective_actions_taken.push(action);
+      }
+      alerts.push(alert);
+      this.alertHistory.push(alert);
+      this.lastAlertTime.set(threshold.alert_type, Date.now());
+    }
+    return alerts;
+  }
+  // ---- Cron 评估入口 (DegradeEvaluator) ----
+  cronEvaluate(getMetrics, tenantId = "default") {
+    const metrics = getMetrics();
+    const alerts = this.evaluate(metrics, tenantId);
+    this.checkAutoRecover();
+    return { alerts, state: this.getSystemState() };
+  }
+  // ---- 保护动作执行 ----
+  executeProtectiveAction(action, alert) {
+    switch (action) {
+      case "DEGRADE":
+        this.activateDegrade(alert);
+        break;
+      case "TIGHTEN_THRESHOLD":
+        this.tightenThreshold(alert);
+        break;
+      case "KILL_SWITCH":
+        this.activateKillSwitch(alert);
+        break;
+      case "FORCE_HUMAN_GATE":
+        this.systemState.force_human_gate = true;
+        break;
+      case "NOTIFY_ONLY":
+        break;
+    }
+  }
+  activateDegrade(alert) {
+    const level = alert.severity === "EMERGENCY" ? "SEVERE" : alert.severity === "CRITICAL" ? "MODERATE" : "LIGHT";
+    this.systemState.degrade = {
+      active: true,
+      level,
+      reason: `Auto-degrade triggered by ${alert.alert_type}: ${alert.message}`,
+      activated_at: Date.now(),
+      auto_recover_at: Date.now() + 30 * 60 * 1e3
+      // 30分钟后自动恢复
+    };
+  }
+  tightenThreshold(alert) {
+    this.systemState.tightened_threshold_multiplier = Math.min(
+      this.systemState.tightened_threshold_multiplier * 1.2,
+      2
+    );
+  }
+  activateKillSwitch(alert) {
+    this.systemState.kill_switch = {
+      enabled: true,
+      reason: `Auto Kill-Switch triggered by ${alert.alert_type}: ${alert.message}`,
+      enabled_at: Date.now(),
+      enabled_by: "trend_alert_engine",
+      auto_triggered: true
+    };
+  }
+  // ---- 阈值检查 ----
+  checkThreshold(metric, threshold) {
+    if (threshold.alert_type === "CONFIDENCE_DROP") {
+      return metric.current_value < threshold.absolute_threshold || metric.baseline_value > 0 && metric.current_value < metric.baseline_value * threshold.surge_multiplier;
+    }
+    if (threshold.alert_type === "APPROVAL_QUEUE_BACKLOG") {
+      return metric.current_value > threshold.absolute_threshold;
+    }
+    const surgeTriggered = metric.baseline_value > 0 && metric.current_value > metric.baseline_value * threshold.surge_multiplier;
+    const absoluteTriggered = metric.current_value > threshold.absolute_threshold;
+    return surgeTriggered || absoluteTriggered;
+  }
+  // ---- 自动恢复 ----
+  checkAutoRecover() {
+    if (this.systemState.degrade.active && this.systemState.degrade.auto_recover_at) {
+      if (Date.now() >= this.systemState.degrade.auto_recover_at) {
+        this.systemState.degrade = {
+          active: false,
+          level: "LIGHT",
+          reason: "Auto-recovered after cooldown",
+          activated_at: null,
+          auto_recover_at: null
+        };
+      }
+    }
+  }
+  // ---- 手动操作 ----
+  acknowledgeAlert(alertId, acknowledgedBy) {
+    const alert = this.alertHistory.find((a) => a.alert_id === alertId);
+    if (!alert) return false;
+    alert.acknowledged = true;
+    alert.acknowledged_by = acknowledgedBy;
+    alert.acknowledged_at = Date.now();
+    return true;
+  }
+  disableKillSwitch(reason, actor) {
+    if (!this.systemState.kill_switch.enabled) return false;
+    this.systemState.kill_switch = {
+      enabled: false,
+      reason: `Disabled by ${actor}: ${reason}`,
+      enabled_at: null,
+      enabled_by: actor,
+      auto_triggered: false
+    };
+    return true;
+  }
+  resetDegrade() {
+    this.systemState.degrade = {
+      active: false,
+      level: "LIGHT",
+      reason: "Manual reset",
+      activated_at: null,
+      auto_recover_at: null
+    };
+    this.systemState.tightened_threshold_multiplier = 1;
+    this.systemState.force_human_gate = false;
+  }
+  // ---- 查询 ----
+  getSystemState() {
+    return { ...this.systemState };
+  }
+  getAlertHistory(limit = 50) {
+    return this.alertHistory.slice(-limit);
+  }
+  getActiveAlerts() {
+    return this.alertHistory.filter((a) => !a.acknowledged);
+  }
+  getMetricsBuffer() {
+    return [...this.metricsBuffer];
+  }
+  // ---- 辅助 ----
+  formatAlertMessage(threshold, metric, surgeRatio) {
+    return `[${threshold.severity}] ${threshold.alert_type}: ${metric.metric_name} = ${metric.current_value.toFixed(3)} (baseline: ${metric.baseline_value.toFixed(3)}, surge: ${surgeRatio.toFixed(1)}x, threshold: ${threshold.absolute_threshold})`;
+  }
+};
+
+// src/selfConstraintEngine.ts
+var DEFAULT_THRESHOLDS3 = {
+  risk_density: 0.75,
+  conflict_rate: 0.6,
+  confidence_drop: 0.2,
+  error_rate: 0.15,
+  latency_p99_ms: 5e3,
+  consecutive_failures: 5
+};
+var NORMAL_FLAGS = {
+  enable_advanced_features: true,
+  enable_auto_approve: true,
+  enable_batch_operations: true,
+  enable_external_api_calls: true,
+  enable_write_operations: true,
+  require_human_gate: false,
+  require_dual_review: false,
+  max_concurrent_decisions: 100,
+  decision_delay_ms: 0
+};
+var CAUTIOUS_FLAGS = {
+  enable_advanced_features: true,
+  enable_auto_approve: false,
+  // 关闭自动审批
+  enable_batch_operations: true,
+  enable_external_api_calls: true,
+  enable_write_operations: true,
+  require_human_gate: false,
+  require_dual_review: false,
+  max_concurrent_decisions: 50,
+  decision_delay_ms: 500
+  // 500ms 延迟
+};
+var RESTRICTED_FLAGS = {
+  enable_advanced_features: false,
+  // 关闭高级功能
+  enable_auto_approve: false,
+  enable_batch_operations: false,
+  // 关闭批量操作
+  enable_external_api_calls: true,
+  enable_write_operations: true,
+  require_human_gate: true,
+  // 强制人工门禁
+  require_dual_review: false,
+  max_concurrent_decisions: 10,
+  decision_delay_ms: 2e3
+  // 2s 延迟
+};
+var LOCKDOWN_FLAGS = {
+  enable_advanced_features: false,
+  enable_auto_approve: false,
+  enable_batch_operations: false,
+  enable_external_api_calls: false,
+  // 关闭外部调用
+  enable_write_operations: false,
+  // 关闭写操作
+  require_human_gate: true,
+  require_dual_review: true,
+  // 双人审核
+  max_concurrent_decisions: 1,
+  decision_delay_ms: 5e3
+  // 5s 延迟
+};
+var LEVEL_FLAGS_MAP = {
+  NORMAL: NORMAL_FLAGS,
+  CAUTIOUS: CAUTIOUS_FLAGS,
+  RESTRICTED: RESTRICTED_FLAGS,
+  LOCKDOWN: LOCKDOWN_FLAGS
+};
+var SelfConstraintEngine = class {
+  config;
+  state;
+  constructor(config) {
+    this.config = {
+      thresholds: config?.thresholds || DEFAULT_THRESHOLDS3,
+      flags: config?.flags || NORMAL_FLAGS,
+      auto_recover_after_minutes: config?.auto_recover_after_minutes || 30,
+      evaluation_interval_seconds: config?.evaluation_interval_seconds || 60
+    };
+    this.state = {
+      current_level: "NORMAL",
+      active_modes: [],
+      flags: { ...NORMAL_FLAGS },
+      activated_at: null,
+      auto_recover_at: null,
+      last_evaluation_at: 0,
+      evaluation_count: 0,
+      constraint_history: []
+    };
+  }
+  // ---- 核心: 评估自我约束 ----
+  evaluate(metrics) {
+    const triggers = [];
+    const modes = /* @__PURE__ */ new Set();
+    triggers.push({
+      metric_name: "risk_density",
+      current_value: metrics.risk_density,
+      threshold_value: this.config.thresholds.risk_density,
+      exceeded: metrics.risk_density >= this.config.thresholds.risk_density
+    });
+    if (metrics.risk_density >= this.config.thresholds.risk_density) {
+      modes.add("CAPABILITY_DOWN");
+      modes.add("PERMISSION_DOWN");
+    }
+    triggers.push({
+      metric_name: "conflict_rate",
+      current_value: metrics.conflict_rate,
+      threshold_value: this.config.thresholds.conflict_rate,
+      exceeded: metrics.conflict_rate >= this.config.thresholds.conflict_rate
+    });
+    if (metrics.conflict_rate >= this.config.thresholds.conflict_rate) {
+      modes.add("SPEED_DOWN");
+      modes.add("PERMISSION_DOWN");
+    }
+    const confidenceDrop = metrics.prev_avg_confidence > 0 ? (metrics.prev_avg_confidence - metrics.avg_confidence) / metrics.prev_avg_confidence : 0;
+    triggers.push({
+      metric_name: "confidence_drop",
+      current_value: confidenceDrop,
+      threshold_value: this.config.thresholds.confidence_drop,
+      exceeded: confidenceDrop >= this.config.thresholds.confidence_drop
+    });
+    if (confidenceDrop >= this.config.thresholds.confidence_drop) {
+      modes.add("SPEED_DOWN");
+    }
+    triggers.push({
+      metric_name: "error_rate",
+      current_value: metrics.error_rate,
+      threshold_value: this.config.thresholds.error_rate,
+      exceeded: metrics.error_rate >= this.config.thresholds.error_rate
+    });
+    if (metrics.error_rate >= this.config.thresholds.error_rate) {
+      modes.add("CAPABILITY_DOWN");
+    }
+    triggers.push({
+      metric_name: "latency_p99_ms",
+      current_value: metrics.latency_p99_ms,
+      threshold_value: this.config.thresholds.latency_p99_ms,
+      exceeded: metrics.latency_p99_ms >= this.config.thresholds.latency_p99_ms
+    });
+    if (metrics.latency_p99_ms >= this.config.thresholds.latency_p99_ms) {
+      modes.add("SPEED_DOWN");
+    }
+    triggers.push({
+      metric_name: "consecutive_failures",
+      current_value: metrics.consecutive_failures,
+      threshold_value: this.config.thresholds.consecutive_failures,
+      exceeded: metrics.consecutive_failures >= this.config.thresholds.consecutive_failures
+    });
+    if (metrics.consecutive_failures >= this.config.thresholds.consecutive_failures) {
+      modes.add("CAPABILITY_DOWN");
+      modes.add("PERMISSION_DOWN");
+    }
+    const triggeredCount = triggers.filter((t) => t.exceeded).length;
+    const level = this.calculateLevel(triggeredCount, metrics.system_pressure);
+    const activeModes = Array.from(modes);
+    const flagsApplied = LEVEL_FLAGS_MAP[level];
+    this.applyConstraint(level, activeModes, flagsApplied);
+    const decision = {
+      decision_id: `sc_${Date.now()}_${this.state.evaluation_count}`,
+      timestamp: Date.now(),
+      level,
+      modes_activated: activeModes,
+      triggers,
+      flags_applied: flagsApplied,
+      reason_code: activeModes.length > 0 ? "SELF_CONSTRAINT_ACTIVATED" : "NORMAL",
+      auto_recover_at: level !== "NORMAL" ? Date.now() + this.config.auto_recover_after_minutes * 60 * 1e3 : null
+    };
+    this.state.constraint_history.push(decision);
+    if (this.state.constraint_history.length > 100) {
+      this.state.constraint_history = this.state.constraint_history.slice(-100);
+    }
+    this.state.evaluation_count++;
+    this.state.last_evaluation_at = Date.now();
+    return decision;
+  }
+  // ---- 约束级别计算 ----
+  calculateLevel(triggeredCount, systemPressure) {
+    const score = triggeredCount + systemPressure * 3;
+    if (score >= 5) return "LOCKDOWN";
+    if (score >= 3) return "RESTRICTED";
+    if (score >= 1) return "CAUTIOUS";
+    return "NORMAL";
+  }
+  // ---- 应用约束 ----
+  applyConstraint(level, modes, flags) {
+    const wasNormal = this.state.current_level === "NORMAL";
+    this.state.current_level = level;
+    this.state.active_modes = modes;
+    this.state.flags = { ...flags };
+    if (level !== "NORMAL" && wasNormal) {
+      this.state.activated_at = Date.now();
+      this.state.auto_recover_at = Date.now() + this.config.auto_recover_after_minutes * 60 * 1e3;
+    } else if (level === "NORMAL") {
+      this.state.activated_at = null;
+      this.state.auto_recover_at = null;
+    }
+  }
+  // ---- 自动恢复检查 ----
+  checkAutoRecover() {
+    if (this.state.current_level === "NORMAL") return false;
+    if (!this.state.auto_recover_at) return false;
+    if (Date.now() >= this.state.auto_recover_at) {
+      this.reset();
+      return true;
+    }
+    return false;
+  }
+  // ---- 手动操作 ----
+  reset() {
+    this.state.current_level = "NORMAL";
+    this.state.active_modes = [];
+    this.state.flags = { ...NORMAL_FLAGS };
+    this.state.activated_at = null;
+    this.state.auto_recover_at = null;
+  }
+  forceLevel(level) {
+    const flags = LEVEL_FLAGS_MAP[level];
+    this.applyConstraint(level, level === "NORMAL" ? [] : ["CAPABILITY_DOWN", "PERMISSION_DOWN"], flags);
+  }
+  // ---- 决策前检查 (Gate 集成) ----
+  preDecisionCheck(action, resource) {
+    const flags = this.state.flags;
+    if (!flags.enable_write_operations && this.isWriteAction(action)) {
+      return {
+        allowed: false,
+        delay_ms: 0,
+        requires_human: true,
+        requires_dual_review: flags.require_dual_review,
+        reason: `Write operations disabled at ${this.state.current_level} level`
+      };
+    }
+    if (!flags.enable_external_api_calls && this.isExternalAction(action)) {
+      return {
+        allowed: false,
+        delay_ms: 0,
+        requires_human: true,
+        requires_dual_review: flags.require_dual_review,
+        reason: `External API calls disabled at ${this.state.current_level} level`
+      };
+    }
+    if (!flags.enable_batch_operations && this.isBatchAction(action)) {
+      return {
+        allowed: false,
+        delay_ms: 0,
+        requires_human: true,
+        requires_dual_review: false,
+        reason: `Batch operations disabled at ${this.state.current_level} level`
+      };
+    }
+    return {
+      allowed: true,
+      delay_ms: flags.decision_delay_ms,
+      requires_human: flags.require_human_gate,
+      requires_dual_review: flags.require_dual_review,
+      reason: this.state.current_level === "NORMAL" ? "OK" : `Constrained at ${this.state.current_level} level`
+    };
+  }
+  // ---- 查询 ----
+  getState() {
+    return {
+      ...this.state,
+      flags: { ...this.state.flags },
+      active_modes: [...this.state.active_modes],
+      constraint_history: [...this.state.constraint_history]
+    };
+  }
+  getCurrentLevel() {
+    return this.state.current_level;
+  }
+  getFlags() {
+    return { ...this.state.flags };
+  }
+  isConstrained() {
+    return this.state.current_level !== "NORMAL";
+  }
+  // ---- 辅助 ----
+  isWriteAction(action) {
+    const writePatterns = ["write", "create", "update", "delete", "insert", "modify", "patch", "put"];
+    return writePatterns.some((p) => action.toLowerCase().includes(p));
+  }
+  isExternalAction(action) {
+    const externalPatterns = ["external", "api_call", "webhook", "http", "fetch", "request"];
+    return externalPatterns.some((p) => action.toLowerCase().includes(p));
+  }
+  isBatchAction(action) {
+    const batchPatterns = ["batch", "bulk", "mass", "multi"];
+    return batchPatterns.some((p) => action.toLowerCase().includes(p));
+  }
+};
+
+// src/contributionSettlement.ts
+var DEFAULT_SCORE_CONFIG = {
+  version: "1.0.0",
+  weight_risk: 0.35,
+  weight_cost: 0.25,
+  weight_human: 0.2,
+  weight_stability: 0.2,
+  weight_penalty: 1,
+  caps: {
+    max_single_event: 100,
+    max_risk_positive_when_risk_up: false
+  },
+  guardrails: [
+    "RISK_UP_BLOCKS_POSITIVE",
+    "EVIDENCE_DOWNGRADE_NEGATIVE",
+    "OVERRIDE_INCREASE_PENALTY"
+  ],
+  approved_by: "system",
+  approved_at: Date.now()
+};
+var MVP_ATTRIBUTION_RULES = [
+  {
+    condition: "RULE_TRIGGERED_BLOCK_WARN",
+    target_entity_type: "rule",
+    target_entity_field: "rule_id",
+    weight: 1
+  },
+  {
+    condition: "EVIDENCE_UPGRADED_ALLOW",
+    target_entity_type: "tool",
+    target_entity_field: "evidence_source",
+    weight: 0.8
+  },
+  {
+    condition: "MODEL_ROUTE_CHEAPER_SAME_RESULT",
+    target_entity_type: "model",
+    target_entity_field: "modelops_route_id",
+    weight: 0.7
+  },
+  {
+    condition: "CACHE_HIT_SKIP_TOOL",
+    target_entity_type: "system",
+    target_entity_field: "context_accelerator",
+    weight: 0.6
+  },
+  {
+    condition: "HUMAN_OVERRIDE_CORRECTION",
+    target_entity_type: "human",
+    target_entity_field: "actor_id",
+    weight: 0.5
+  }
+];
+var BUILTIN_PENALTY_CHECKS = [
+  {
+    name: "OVERRIDE_INCREASE",
+    detect: (_events, ctx) => {
+      if (ctx.override_count_delta > 0) {
+        return ctx.override_count_delta * 5;
+      }
+      return 0;
+    }
+  },
+  {
+    name: "REPLAY_FAIL_INCREASE",
+    detect: (_events, ctx) => {
+      if (ctx.replay_fail_delta > 0) {
+        return ctx.replay_fail_delta * 10;
+      }
+      return 0;
+    }
+  },
+  {
+    name: "RISK_REGRESSION",
+    detect: (_events, ctx) => {
+      if (ctx.risk_regression) {
+        return 50;
+      }
+      return 0;
+    }
+  },
+  {
+    name: "EVIDENCE_DOWNGRADE",
+    detect: (_events, ctx) => {
+      if (ctx.evidence_downgrade) {
+        return 30;
+      }
+      return 0;
+    }
+  },
+  {
+    name: "SELF_MANUFACTURE_DETECT",
+    detect: (events, _ctx) => {
+      const entityMap = /* @__PURE__ */ new Map();
+      for (const e of events) {
+        const key = `${e.entity_type}:${e.entity_id}`;
+        const entry = entityMap.get(key) || { negative: 0, positive: 0 };
+        if (e.delta_value < 0) entry.negative += Math.abs(e.delta_value);
+        else entry.positive += e.delta_value;
+        entityMap.set(key, entry);
+      }
+      let penalty = 0;
+      for (const [, entry] of entityMap) {
+        if (entry.negative > 20 && entry.positive > 20) {
+          const ratio = Math.min(entry.negative, entry.positive) / Math.max(entry.negative, entry.positive);
+          if (ratio > 0.7) {
+            penalty += 25;
+          }
+        }
+      }
+      return penalty;
+    }
+  }
+];
+var ContributionSettlementEngine = class {
+  config;
+  attributionRules;
+  penaltyChecks;
+  eventStore = [];
+  scoreStore = [];
+  constructor(config, customRules, customPenalties) {
+    this.config = { ...DEFAULT_SCORE_CONFIG, ...config };
+    this.attributionRules = customRules || MVP_ATTRIBUTION_RULES;
+    this.penaltyChecks = [...BUILTIN_PENALTY_CHECKS, ...customPenalties || []];
+  }
+  // ---- 事件记录 ----
+  recordEvent(event) {
+    if (Math.abs(event.delta_value) > this.config.caps.max_single_event) {
+      event.delta_value = event.delta_value > 0 ? this.config.caps.max_single_event : -this.config.caps.max_single_event;
+    }
+    const exists = this.eventStore.find((e) => e.event_id === event.event_id);
+    if (exists) return exists;
+    this.eventStore.push(event);
+    return event;
+  }
+  // ---- 归因 ----
+  attribute(traceId, condition, entityType, entityId) {
+    const rule = this.attributionRules.find((r) => r.condition === condition);
+    if (!rule) return null;
+    const event = {
+      event_id: `attr_${traceId}_${Date.now()}`,
+      trace_id: traceId,
+      decision_id: traceId,
+      tenant_id: "default",
+      entity_type: entityType,
+      entity_id: entityId,
+      dimension: this.inferDimension(condition),
+      delta_value: rule.weight * 10,
+      // 基础分 * 权重
+      delta_confidence: rule.weight,
+      baseline_ref: "current",
+      evidence_bundle_hash: "",
+      created_at: Date.now()
+    };
+    return this.recordEvent(event);
+  }
+  // ---- 窗口结算 ----
+  settle(context) {
+    const windowEvents = this.eventStore.filter(
+      (e) => e.tenant_id === context.tenant_id && e.created_at >= context.window_start && e.created_at <= context.window_end
+    );
+    const entityGroups = /* @__PURE__ */ new Map();
+    for (const e of windowEvents) {
+      const key = `${e.entity_type}:${e.entity_id}`;
+      const group = entityGroups.get(key) || [];
+      group.push(e);
+      entityGroups.set(key, group);
+    }
+    const scores = [];
+    for (const [key, events] of entityGroups) {
+      const [entityType, entityId] = key.split(":");
+      let scoreRisk = 0, scoreCost = 0, scoreHuman = 0, scoreStability = 0;
+      let totalConfidence = 0;
+      for (const e of events) {
+        const val = e.delta_value * e.delta_confidence;
+        switch (e.dimension) {
+          case "RISK":
+            scoreRisk += val;
+            break;
+          case "COST":
+            scoreCost += val;
+            break;
+          case "HUMAN":
+            scoreHuman += val;
+            break;
+          case "STABILITY":
+            scoreStability += val;
+            break;
+        }
+        totalConfidence += e.delta_confidence;
+      }
+      if (!this.config.caps.max_risk_positive_when_risk_up && context.risk_regression) {
+        scoreRisk = Math.min(scoreRisk, 0);
+        scoreCost = Math.min(scoreCost, 0);
+        scoreHuman = Math.min(scoreHuman, 0);
+        scoreStability = Math.min(scoreStability, 0);
+      }
+      let penaltyTotal = 0;
+      for (const check of this.penaltyChecks) {
+        penaltyTotal += check.detect(events, context);
+      }
+      const scoreTotal = this.config.weight_risk * scoreRisk + this.config.weight_cost * scoreCost + this.config.weight_human * scoreHuman + this.config.weight_stability * scoreStability - this.config.weight_penalty * penaltyTotal;
+      const avgConfidence = events.length > 0 ? totalConfidence / events.length : 0;
+      const score = {
+        score_id: `score_${entityType}_${entityId}_${context.window_start}`,
+        window_start: context.window_start,
+        window_end: context.window_end,
+        tenant_id: context.tenant_id,
+        entity_type: entityType,
+        entity_id: entityId,
+        score_risk: Math.round(scoreRisk * 100) / 100,
+        score_cost: Math.round(scoreCost * 100) / 100,
+        score_human: Math.round(scoreHuman * 100) / 100,
+        score_stability: Math.round(scoreStability * 100) / 100,
+        score_total: Math.round(scoreTotal * 100) / 100,
+        penalty_total: Math.round(penaltyTotal * 100) / 100,
+        confidence: Math.round(avgConfidence * 100) / 100,
+        score_config_version: this.config.version,
+        created_at: Date.now()
+      };
+      scores.push(score);
+      this.scoreStore.push(score);
+    }
+    return scores;
+  }
+  // ---- 控制面联动 ----
+  getResourceAllocation(entityType, entityId) {
+    const recentScores = this.scoreStore.filter(
+      (s) => s.entity_type === entityType && s.entity_id === entityId
+    );
+    if (recentScores.length === 0) {
+      return {
+        token_budget_multiplier: 1,
+        concurrency_quota_multiplier: 1,
+        auto_approve_eligible: false,
+        requires_dual_review: false
+      };
+    }
+    const latestScore = recentScores[recentScores.length - 1];
+    const total = latestScore.score_total;
+    return {
+      token_budget_multiplier: total > 50 ? 1.5 : total > 0 ? 1 : 0.5,
+      concurrency_quota_multiplier: total > 50 ? 1.3 : total > 0 ? 1 : 0.7,
+      auto_approve_eligible: total > 80 && latestScore.penalty_total === 0,
+      requires_dual_review: total < -20 || latestScore.penalty_total > 30
+    };
+  }
+  // ---- 审计抽查 ----
+  auditSample(entityType, entityId, sampleSize = 3) {
+    const entityEvents = this.eventStore.filter(
+      (e) => e.entity_type === entityType && e.entity_id === entityId
+    );
+    const shuffled = [...entityEvents].sort(() => Math.random() - 0.5);
+    return shuffled.slice(0, Math.min(sampleSize, shuffled.length));
+  }
+  // ---- 辅助 ----
+  inferDimension(condition) {
+    if (condition.includes("RULE") || condition.includes("BLOCK")) return "RISK";
+    if (condition.includes("COST") || condition.includes("CACHE") || condition.includes("CHEAPER")) return "COST";
+    if (condition.includes("HUMAN") || condition.includes("OVERRIDE")) return "HUMAN";
+    return "STABILITY";
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  getEventCount() {
+    return this.eventStore.length;
+  }
+  getScoreCount() {
+    return this.scoreStore.length;
+  }
+};
+
+// src/overrideDriftAnalyzer.ts
+var DEFAULT_CONFIG6 = {
+  baseline_window_hours: 168,
+  // 7 天基线
+  analysis_window_hours: 24,
+  // 24 小时分析窗口
+  rate_drift_threshold: 0.3,
+  // override 率偏离 30%
+  concentration_threshold: 0.5,
+  // 单一实体占比超 50%
+  risk_drift_threshold: 0.4,
+  // 高风险 override 占比偏离 40%
+  temporal_drift_threshold: 0.3,
+  // 时间分布偏离 30%
+  composite_alert_threshold: 0.5,
+  // 综合漂移指数超 0.5 告警
+  min_sample_size: 10
+  // 最小样本量
+};
+var OverrideDriftAnalyzer = class {
+  config;
+  events = [];
+  baselineWindow = null;
+  alerts = [];
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG6, ...config };
+  }
+  // ---- 事件记录 ----
+  recordOverride(event) {
+    if (this.events.find((e) => e.event_id === event.event_id)) return;
+    this.events.push(event);
+  }
+  // ---- 窗口统计 ----
+  computeWindow(start, end, totalDecisions) {
+    const windowEvents = this.events.filter(
+      (e) => e.created_at >= start && e.created_at <= end
+    );
+    const byActor = /* @__PURE__ */ new Map();
+    const byRule = /* @__PURE__ */ new Map();
+    const byRiskLevel = { LOW: 0, MEDIUM: 0, HIGH: 0, CRITICAL: 0 };
+    const byHour = new Array(24).fill(0);
+    for (const e of windowEvents) {
+      byActor.set(e.actor_id, (byActor.get(e.actor_id) || 0) + 1);
+      byRule.set(e.rule_id, (byRule.get(e.rule_id) || 0) + 1);
+      byRiskLevel[e.risk_level] = (byRiskLevel[e.risk_level] || 0) + 1;
+      const hour = new Date(e.created_at).getHours();
+      byHour[hour]++;
+    }
+    const total = totalDecisions || Math.max(windowEvents.length * 5, 1);
+    return {
+      window_start: start,
+      window_end: end,
+      total_decisions: total,
+      total_overrides: windowEvents.length,
+      override_rate: total > 0 ? windowEvents.length / total : 0,
+      by_actor: byActor,
+      by_rule: byRule,
+      by_risk_level: byRiskLevel,
+      by_hour: byHour
+    };
+  }
+  // ---- 基线计算 ----
+  updateBaseline(totalDecisions) {
+    const now = Date.now();
+    const start = now - this.config.baseline_window_hours * 60 * 60 * 1e3;
+    this.baselineWindow = this.computeWindow(start, now, totalDecisions);
+    return this.baselineWindow;
+  }
+  // ---- 漂移指数计算 ----
+  calculateDriftIndex(currentWindow, totalDecisions) {
+    const now = Date.now();
+    const current = currentWindow || this.computeWindow(
+      now - this.config.analysis_window_hours * 60 * 60 * 1e3,
+      now,
+      totalDecisions
+    );
+    if (!this.baselineWindow) {
+      this.updateBaseline(totalDecisions);
+    }
+    const baseline = this.baselineWindow;
+    const rateDrift = baseline.override_rate > 0 ? Math.abs(current.override_rate - baseline.override_rate) / baseline.override_rate : current.override_rate > 0 ? 1 : 0;
+    const actorConcentration = this.calculateConcentration(current.by_actor, current.total_overrides);
+    const baselineActorConc = this.calculateConcentration(baseline.by_actor, baseline.total_overrides);
+    const concentrationDrift = Math.abs(actorConcentration - baselineActorConc);
+    const currentHighRisk = ((current.by_risk_level["HIGH"] || 0) + (current.by_risk_level["CRITICAL"] || 0)) / Math.max(current.total_overrides, 1);
+    const baselineHighRisk = ((baseline.by_risk_level["HIGH"] || 0) + (baseline.by_risk_level["CRITICAL"] || 0)) / Math.max(baseline.total_overrides, 1);
+    const riskDrift = Math.abs(currentHighRisk - baselineHighRisk);
+    const temporalDrift = this.calculateTemporalDrift(current.by_hour, baseline.by_hour);
+    const composite = rateDrift * 0.35 + concentrationDrift * 0.25 + riskDrift * 0.25 + temporalDrift * 0.15;
+    const trend = this.determineTrend(composite);
+    return {
+      value: Math.min(Math.round(composite * 1e3) / 1e3, 1),
+      rate_drift: Math.round(rateDrift * 1e3) / 1e3,
+      concentration_drift: Math.round(concentrationDrift * 1e3) / 1e3,
+      risk_drift: Math.round(riskDrift * 1e3) / 1e3,
+      temporal_drift: Math.round(temporalDrift * 1e3) / 1e3,
+      trend
+    };
+  }
+  // ---- 分析 & 告警 ----
+  analyze(totalDecisions) {
+    const driftIndex = this.calculateDriftIndex(void 0, totalDecisions);
+    if (driftIndex.value < this.config.composite_alert_threshold) {
+      return null;
+    }
+    const patterns = this.detectPatterns(driftIndex);
+    const recommendations = this.generateRecommendations(driftIndex, patterns);
+    const severity = driftIndex.value >= 0.8 ? "CRITICAL" : driftIndex.value >= 0.5 ? "WARN" : "INFO";
+    const alert = {
+      alert_id: `da_${Date.now()}`,
+      drift_index: driftIndex,
+      severity,
+      message: `Override drift detected: composite index = ${driftIndex.value} (${driftIndex.trend})`,
+      patterns_detected: patterns,
+      recommendations,
+      created_at: Date.now()
+    };
+    this.alerts.push(alert);
+    return alert;
+  }
+  // ---- 模式检测 ----
+  detectPatterns(driftIndex) {
+    const patterns = [];
+    if (driftIndex.rate_drift > this.config.rate_drift_threshold) {
+      patterns.push({
+        pattern_type: "RATE_SPIKE",
+        description: `Override rate increased by ${(driftIndex.rate_drift * 100).toFixed(1)}% from baseline`,
+        evidence: { rate_drift: driftIndex.rate_drift },
+        confidence: Math.min(driftIndex.rate_drift, 1)
+      });
+    }
+    if (driftIndex.concentration_drift > this.config.concentration_threshold) {
+      patterns.push({
+        pattern_type: "ACTOR_CONCENTRATION",
+        description: "Override activity concentrated on fewer actors than baseline",
+        evidence: { concentration_drift: driftIndex.concentration_drift },
+        confidence: Math.min(driftIndex.concentration_drift, 1)
+      });
+    }
+    if (driftIndex.risk_drift > this.config.risk_drift_threshold) {
+      patterns.push({
+        pattern_type: "RISK_ESCALATION",
+        description: `High-risk override proportion shifted by ${(driftIndex.risk_drift * 100).toFixed(1)}%`,
+        evidence: { risk_drift: driftIndex.risk_drift },
+        confidence: Math.min(driftIndex.risk_drift, 1)
+      });
+    }
+    if (driftIndex.temporal_drift > this.config.temporal_drift_threshold) {
+      patterns.push({
+        pattern_type: "TIME_ANOMALY",
+        description: "Override time distribution deviates from baseline pattern",
+        evidence: { temporal_drift: driftIndex.temporal_drift },
+        confidence: Math.min(driftIndex.temporal_drift, 1)
+      });
+    }
+    return patterns;
+  }
+  // ---- 建议生成 ----
+  generateRecommendations(driftIndex, patterns) {
+    const recs = [];
+    if (patterns.some((p) => p.pattern_type === "RATE_SPIKE")) {
+      recs.push("Review recent policy changes that may have increased false positives");
+      recs.push("Check if new rules are overly restrictive, causing excessive overrides");
+    }
+    if (patterns.some((p) => p.pattern_type === "ACTOR_CONCENTRATION")) {
+      recs.push("Investigate concentrated override activity for potential abuse");
+      recs.push("Consider implementing per-actor override quotas");
+    }
+    if (patterns.some((p) => p.pattern_type === "RISK_ESCALATION")) {
+      recs.push("Audit high-risk overrides for potential security implications");
+      recs.push("Consider requiring dual approval for high-risk overrides");
+    }
+    if (patterns.some((p) => p.pattern_type === "TIME_ANOMALY")) {
+      recs.push("Check for automated override scripts running at unusual hours");
+      recs.push("Review access patterns during off-hours");
+    }
+    if (driftIndex.value >= 0.8) {
+      recs.push("CRITICAL: Consider activating self-constraint engine to restrict override capability");
+    }
+    return recs;
+  }
+  // ---- 辅助计算 ----
+  calculateConcentration(distribution, total) {
+    if (total === 0) return 0;
+    let herfindahl = 0;
+    for (const [, count] of distribution) {
+      const share = count / total;
+      herfindahl += share * share;
+    }
+    return herfindahl;
+  }
+  calculateTemporalDrift(current, baseline) {
+    const currentTotal = current.reduce((a, b) => a + b, 0) || 1;
+    const baselineTotal = baseline.reduce((a, b) => a + b, 0) || 1;
+    let divergence = 0;
+    for (let i = 0; i < 24; i++) {
+      const p = current[i] / currentTotal;
+      const q = baseline[i] / baselineTotal || 1 / 24;
+      if (p > 0) {
+        divergence += p * Math.log(p / q);
+      }
+    }
+    return Math.min(divergence / 2, 1);
+  }
+  determineTrend(composite) {
+    const recentAlerts = this.alerts.slice(-5);
+    if (recentAlerts.length < 2) return "STABLE";
+    const values = recentAlerts.map((a) => a.drift_index.value);
+    const diffs = values.slice(1).map((v, i) => v - values[i]);
+    const avgDiff = diffs.reduce((a, b) => a + b, 0) / diffs.length;
+    const variance = diffs.reduce((a, b) => a + (b - avgDiff) ** 2, 0) / diffs.length;
+    if (variance > 0.1) return "VOLATILE";
+    if (avgDiff > 0.05) return "RISING";
+    if (avgDiff < -0.05) return "FALLING";
+    return "STABLE";
+  }
+  // ---- 查询 ----
+  getAlerts(limit = 20) {
+    return this.alerts.slice(-limit);
+  }
+  getEventCount() {
+    return this.events.length;
+  }
+  getLatestDriftIndex(totalDecisions) {
+    return this.calculateDriftIndex(void 0, totalDecisions);
+  }
+  getStats() {
+    const now = Date.now();
+    const currentWindow = this.computeWindow(
+      now - this.config.analysis_window_hours * 60 * 60 * 1e3,
+      now
+    );
+    return {
+      total_events: this.events.length,
+      total_alerts: this.alerts.length,
+      baseline_override_rate: this.baselineWindow?.override_rate || 0,
+      current_override_rate: currentWindow.override_rate
+    };
+  }
+};
+
 // src/index.ts
 var DEFAULT_RULES = [
   // --- HTTP Proxy: Dangerous outbound calls ---
@@ -2545,16 +4817,30 @@ var index_default = PolicyEngine;
 0 && (module.exports = {
   AdaptiveThresholdManager,
   AutoHardenEngine,
+  ContextAccelerator,
+  ContributionSettlementEngine,
   CostGateEnhancedEngine,
+  DEFAULT_CA_CONFIG,
+  DEFAULT_GE_CONFIG,
+  DEFAULT_HARD_RULES,
   DEFAULT_RULES,
+  DEFAULT_SCORING_WEIGHTS,
+  DEFAULT_TSA_CONFIG,
   EvolutionChannelEngine,
   FeatureSwitchesManager,
+  GovernanceEnhancer,
   MultiLevelBudgetEngine,
+  OverrideDriftAnalyzer,
   PolicyEngine,
   PricingRulesEngine,
   RecalculationEngine,
   SOVR_FEATURE_SWITCHES,
+  SelfConstraintEngine,
   SemanticDriftDetectorEngine,
+  TimeSeriesAggregator,
+  TrendAlertEngine,
+  TwoPhaseRouter,
+  ValuationModel,
   compileFromJSON,
   compileRuleSet,
   createAutoHardenEngine,