@sovr/engine 3.5.0 → 3.6.0

package/dist/index.js

@@ -23,6 +23,7 @@ __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,
@@ -34,12 +35,15 @@ __export(index_exports, {
   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,
@@ -3264,6 +3268,1064 @@ var ContextAccelerator = class {
   }
 };
 
+// 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 ---
@@ -3756,6 +4818,7 @@ var index_default = PolicyEngine;
   AdaptiveThresholdManager,
   AutoHardenEngine,
   ContextAccelerator,
+  ContributionSettlementEngine,
   CostGateEnhancedEngine,
   DEFAULT_CA_CONFIG,
   DEFAULT_GE_CONFIG,
@@ -3767,12 +4830,15 @@ var index_default = PolicyEngine;
   FeatureSwitchesManager,
   GovernanceEnhancer,
   MultiLevelBudgetEngine,
+  OverrideDriftAnalyzer,
   PolicyEngine,
   PricingRulesEngine,
   RecalculationEngine,
   SOVR_FEATURE_SWITCHES,
+  SelfConstraintEngine,
   SemanticDriftDetectorEngine,
   TimeSeriesAggregator,
+  TrendAlertEngine,
   TwoPhaseRouter,
   ValuationModel,
   compileFromJSON,