@sovr/engine 3.3.0 → 3.5.0

package/dist/index.d.mts

@@ -349,6 +349,1527 @@ declare class PricingRulesEngine {
     private globMatch;
 }
 
+/**
+ * @sovr/engine — Recalculation Engine (Pure Memory Mode)
+ *
+ * Aggregation layer recalculation capabilities:
+ * - G3: Recalculation triggers (manual/automatic)
+ * - G4: Consistency verification (compare pre/post values)
+ * - G5: Incremental recalculation (from checkpoint)
+ * - G6: Recalculation audit (via onAudit callback)
+ *
+ * Zero external dependencies. Audit via callback injection.
+ */
+type RecalcTaskStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+type RecalcTriggerType = 'manual' | 'scheduled' | 'drift_detected' | 'data_correction' | 'policy_change';
+type RecalcGranularity = '5m' | '1h' | '1d' | 'all';
+interface RecalcTask {
+    id: string;
+    tenantId: string;
+    triggerType: RecalcTriggerType;
+    triggeredBy: string;
+    reason: string;
+    fromTs: number;
+    toTs: number;
+    granularity: RecalcGranularity;
+    incremental: boolean;
+    incrementalCheckpoint?: string;
+    status: RecalcTaskStatus;
+    startedAt?: number;
+    completedAt?: number;
+    progress: number;
+    bucketsProcessed: number;
+    rowsUpserted: number;
+    consistencyResult?: ConsistencyResult;
+    error?: string;
+    createdAt: number;
+    traceId: string;
+}
+interface ConsistencyResult {
+    id: string;
+    taskId: string;
+    status: 'consistent' | 'inconsistent' | 'partial';
+    totalComparisons: number;
+    matchCount: number;
+    mismatchCount: number;
+    consistencyRate: number;
+    mismatches: ConsistencyMismatch[];
+    verifiedAt: number;
+    verificationHash: string;
+}
+interface ConsistencyMismatch {
+    metric: string;
+    bucket: string;
+    currentValue: number;
+    recalculatedValue: number;
+    deviation: number;
+    deviationPercent: number;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+}
+interface AggregateSnapshot {
+    id: string;
+    tenantId: string;
+    snapshotType: 'pre_recalc' | 'post_recalc' | 'scheduled';
+    taskId?: string;
+    metrics: Record<string, number>;
+    hash: string;
+    createdAt: number;
+}
+type RecalcHandler = (task: RecalcTask) => Promise<{
+    bucketsProcessed: number;
+    rowsUpserted: number;
+    metrics: Record<string, number>;
+}>;
+interface RecalcEngineConfig {
+    maxRangeDays: number;
+    onAudit?: (event: {
+        type: string;
+        details: Record<string, unknown>;
+        timestamp: number;
+    }) => void;
+}
+declare class RecalculationEngine {
+    private tasks;
+    private consistencyResults;
+    private snapshots;
+    private handlers;
+    private config;
+    constructor(config?: Partial<RecalcEngineConfig>);
+    /** G3: Trigger recalculation */
+    triggerRecalculation(input: {
+        tenantId: string;
+        triggerType: RecalcTriggerType;
+        triggeredBy: string;
+        reason: string;
+        fromTs: number;
+        toTs: number;
+        granularity?: RecalcGranularity;
+        incremental?: boolean;
+        incrementalCheckpoint?: string;
+    }): RecalcTask;
+    /** Execute recalculation task */
+    executeTask(taskId: string): Promise<RecalcTask>;
+    /** G4: Verify consistency */
+    verifyConsistency(taskId: string, preSnapshot: AggregateSnapshot, postSnapshot: AggregateSnapshot, recalculatedMetrics?: Record<string, number>): ConsistencyResult;
+    /** G5: Incremental recalculation */
+    triggerIncremental(input: {
+        tenantId: string;
+        triggeredBy: string;
+        reason: string;
+        granularity?: RecalcGranularity;
+    }): RecalcTask;
+    /** Create aggregate snapshot */
+    createSnapshot(tenantId: string, snapshotType: AggregateSnapshot['snapshotType'], taskId?: string, metrics?: Record<string, number>): AggregateSnapshot;
+    /** Register recalculation handler */
+    registerHandler(granularity: RecalcGranularity, handler: RecalcHandler): void;
+    /** Query functions */
+    getTask(taskId: string): RecalcTask | undefined;
+    getTasks(tenantId: string, limit?: number): RecalcTask[];
+    getConsistencyResult(taskId: string): ConsistencyResult | undefined;
+    getSnapshot(snapshotId: string): AggregateSnapshot | undefined;
+    cancelTask(taskId: string): boolean;
+    private audit;
+}
+declare function createRecalculationEngine(config?: Partial<RecalcEngineConfig>): RecalculationEngine;
+
+/**
+ * @sovr/engine — AutoHarden Module (Pure Memory Mode)
+ *
+ * Automatic security hardening when adversarial threats detected:
+ * - B7: Auto-harden capability
+ * - Gate level upgrade, rate limit reduction, enhanced audit
+ * - Configurable measures with auto-rollback
+ *
+ * Zero external dependencies. Audit via callback injection.
+ */
+type HardenLevel = 'normal' | 'elevated' | 'hardened' | 'lockdown';
+type HardenMeasureType = 'gate_level_upgrade' | 'rate_limit_reduce' | 'enhanced_audit' | 'ip_block' | 'session_invalidate' | 'feature_disable' | 'alert_admin';
+interface HardenMeasure {
+    id: string;
+    type: HardenMeasureType;
+    description: string;
+    applied: boolean;
+    appliedAt?: number;
+    rolledBackAt?: number;
+}
+interface HardenEvent {
+    id: string;
+    tenantId: string;
+    triggeredBy: string;
+    reason: string;
+    previousLevel: HardenLevel;
+    newLevel: HardenLevel;
+    measures: HardenMeasure[];
+    createdAt: number;
+    rolledBack: boolean;
+    rolledBackAt?: number;
+    traceId: string;
+}
+interface HardenConfig {
+    enabled: boolean;
+    levelMeasures: Record<HardenLevel, HardenMeasureType[]>;
+    autoRollbackMs: number;
+    rateLimitReductionFactor: number;
+    notifyAdmin: boolean;
+    onNotifyAdmin?: (event: HardenEvent) => Promise<void>;
+    onAudit?: (event: {
+        type: string;
+        details: Record<string, unknown>;
+        timestamp: number;
+    }) => void;
+}
+interface HardenState {
+    currentLevel: HardenLevel;
+    lastEvent?: HardenEvent;
+    activeMeasures: HardenMeasure[];
+    hardenedSince?: number;
+    expectedRollbackAt?: number;
+}
+declare class AutoHardenEngine {
+    private states;
+    private history;
+    private config;
+    private rollbackTimers;
+    private maxHistory;
+    constructor(config?: Partial<HardenConfig>);
+    /** Get tenant harden state */
+    getState(tenantId: string): HardenState;
+    /** Get current harden level */
+    getLevel(tenantId: string): HardenLevel;
+    /** Auto-harden (main entry) */
+    harden(input: {
+        tenantId: string;
+        triggeredBy: string;
+        reason: string;
+        targetLevel?: HardenLevel;
+        manipulationScore?: number;
+        reasonCodes?: string[];
+    }): Promise<HardenEvent>;
+    /** Manual rollback */
+    rollback(tenantId: string, rolledBackBy: string, reason?: string): Promise<HardenEvent>;
+    /** Update config */
+    updateConfig(config: Partial<HardenConfig>): HardenConfig;
+    /** Get config */
+    getConfig(): HardenConfig;
+    /** Get history */
+    getHistory(tenantId?: string, limit?: number): HardenEvent[];
+    /** Get all active hardened states */
+    getActiveStates(): Array<{
+        tenantId: string;
+        state: HardenState;
+    }>;
+    /** Cleanup timers */
+    destroy(): void;
+    private determineLevel;
+    private applyMeasures;
+    private getMeasureDescription;
+    private scheduleAutoRollback;
+    private audit;
+}
+declare function createAutoHardenEngine(config?: Partial<HardenConfig>): AutoHardenEngine;
+
+/**
+ * SOVR Cost Estimator
+ * 成本预估精确化引擎 — 补齐 F3 缺口
+ *
+ * 功能：
+ * 1. Token 级成本预估（基于模型定价表）
+ * 2. 工具调用成本预估
+ * 3. 人工审批成本预估（基于费率）
+ * 4. 总成本预估（模型 + 工具 + 人工）
+ * 5. 预估准确度追踪
+ *
+ * 设计原则:
+ * - 模型定价表可配置、可更新
+ * - 支持多种计费模式（按 token、按调用、按时间）
+ * - 预估结果包含置信区间
+ * - 与 CostGate 协作
+ */
+/** 模型定价 */
+interface ModelPricing {
+    /** 模型 ID */
+    modelId: string;
+    /** 模型名称 */
+    modelName: string;
+    /** 输入 token 单价（美元/1K tokens） */
+    inputPricePerKToken: number;
+    /** 输出 token 单价（美元/1K tokens） */
+    outputPricePerKToken: number;
+    /** 缓存 token 单价（如有） */
+    cachedInputPricePerKToken?: number;
+    /** 最大上下文长度 */
+    maxContextLength: number;
+    /** 最后更新 */
+    updatedAt: Date;
+}
+/** 工具定价 */
+interface ToolPricing {
+    /** 工具 ID */
+    toolId: string;
+    /** 工具名称 */
+    toolName: string;
+    /** 每次调用成本（美元） */
+    costPerCall: number;
+    /** 乘算因子（如有额外成本） */
+    multiplier: number;
+    /** 最后更新 */
+    updatedAt: Date;
+}
+/** 成本预估请求 */
+interface CostEstimateRequest {
+    /** 模型 ID */
+    modelId: string;
+    /** 预估输入 token 数 */
+    estimatedInputTokens: number;
+    /** 预估输出 token 数 */
+    estimatedOutputTokens: number;
+    /** 工具调用列表 */
+    toolCalls?: Array<{
+        toolId: string;
+        estimatedCalls: number;
+    }>;
+    /** 是否需要人工审批 */
+    requiresHumanReview?: boolean;
+    /** 人工审批级别 */
+    humanReviewLevel?: 'standard' | 'senior' | 'executive';
+}
+/** 成本预估结果 */
+interface CostEstimate {
+    /** 预估 ID */
+    id: string;
+    /** 模型成本 */
+    modelCost: {
+        inputCost: number;
+        outputCost: number;
+        total: number;
+    };
+    /** 工具成本 */
+    toolCost: {
+        items: Array<{
+            toolId: string;
+            calls: number;
+            costPerCall: number;
+            total: number;
+        }>;
+        total: number;
+    };
+    /** 人工审批成本 */
+    humanCost: {
+        level: string;
+        hourlyRate: number;
+        estimatedMinutes: number;
+        total: number;
+    } | null;
+    /** 总成本 */
+    totalCost: number;
+    /** 置信区间 */
+    confidence: {
+        low: number;
+        high: number;
+        level: number;
+    };
+    /** 预估时间 */
+    estimatedAt: Date;
+}
+/** 预估准确度记录 */
+interface EstimateAccuracy {
+    estimateId: string;
+    estimatedCost: number;
+    actualCost: number;
+    deviation: number;
+    deviationPercent: number;
+    recordedAt: Date;
+}
+/**
+ * 预估成本
+ */
+declare function estimateCost(request: CostEstimateRequest): CostEstimate;
+/**
+ * 记录实际成本（用于准确度追踪）
+ */
+declare function recordActualCost(estimateId: string, actualCost: number): EstimateAccuracy | null;
+/**
+ * 更新模型定价
+ */
+declare function updateModelPricing(pricing: ModelPricing): void;
+/**
+ * 更新工具定价
+ */
+declare function updateToolPricing(pricing: ToolPricing): void;
+/**
+ * 获取模型定价表
+ */
+declare function getModelPricingTable(): ModelPricing[];
+/**
+ * 获取工具定价表
+ */
+declare function getToolPricingTable(): ToolPricing[];
+/**
+ * 获取预估准确度统计
+ */
+declare function getAccuracyStats(): {
+    totalRecords: number;
+    avgDeviation: number;
+    avgDeviationPercent: number;
+    confidenceLevel: number;
+};
+
+/**
+ * server/sovr/semanticDriftDetector.ts
+ *
+ * 语义漂移检测器 — 补齐 K10 缺口
+ *
+ * 功能：
+ * - 策略语义指纹计算（基于规则结构的哈希）
+ * - 版本间语义差异检测
+ * - 漂移评分（0-1，0=完全一致，1=完全不同）
+ * - 漂移告警（超过阈值时触发）
+ * - 漂移审计链
+ *
+ * 设计原则：纯逻辑模块，无外部依赖
+ */
+interface SemanticFingerprint {
+    version: string;
+    hash: string;
+    ruleCount: number;
+    allowCount: number;
+    denyCount: number;
+    reviewCount: number;
+    resourceSet: string[];
+    actionSet: string[];
+    conditionDepth: number;
+    timestamp: number;
+}
+interface DriftResult {
+    fromVersion: string;
+    toVersion: string;
+    driftScore: number;
+    ruleCountDelta: number;
+    addedRules: string[];
+    removedRules: string[];
+    modifiedRules: string[];
+    decisionChanges: {
+        ruleId: string;
+        from: string;
+        to: string;
+    }[];
+    newResources: string[];
+    removedResources: string[];
+    severity: 'none' | 'low' | 'medium' | 'high' | 'critical';
+    timestamp: number;
+}
+interface PolicySnapshot {
+    version: string;
+    rules: PolicyRuleForDrift[];
+    metadata?: Record<string, unknown>;
+}
+interface PolicyRuleForDrift {
+    id: string;
+    action: string;
+    resource: string;
+    decision: 'ALLOW' | 'DENY' | 'REVIEW';
+    conditions?: Record<string, unknown>;
+    priority: number;
+}
+interface DriftConfig {
+    lowThreshold: number;
+    mediumThreshold: number;
+    highThreshold: number;
+    criticalThreshold: number;
+    onDriftDetected?: (result: DriftResult) => void;
+    onAudit?: (event: {
+        type: string;
+        details: Record<string, unknown>;
+        timestamp: number;
+    }) => void;
+}
+declare class SemanticDriftDetectorEngine {
+    private fingerprints;
+    private history;
+    private config;
+    constructor(config?: Partial<DriftConfig>);
+    /**
+     * 计算策略语义指纹
+     */
+    computeFingerprint(snapshot: PolicySnapshot): SemanticFingerprint;
+    /**
+     * 检测两个版本间的语义漂移
+     */
+    detectDrift(from: PolicySnapshot, to: PolicySnapshot): DriftResult;
+    /**
+     * 获取漂移历史
+     */
+    getDriftHistory(): DriftResult[];
+    /**
+     * 获取指纹
+     */
+    getFingerprint(version: string): SemanticFingerprint | null;
+    /**
+     * 获取漂移趋势
+     */
+    getDriftTrend(): {
+        version: string;
+        driftScore: number;
+        timestamp: number;
+    }[];
+    private hashRules;
+    private ruleChanged;
+    private maxConditionDepth;
+    private objectDepth;
+}
+declare function createSemanticDriftDetector(config?: Partial<DriftConfig>): SemanticDriftDetectorEngine;
+
+/**
+ * server/sovr/costGateEnhanced.ts
+ *
+ * 经济约束层增强 — 补齐 E2/E4/E5/E6/E7/E9/E10 缺口
+ *
+ * 功能：
+ * - E2: 成本汇总表（1h/24h/7d 滑动窗口）
+ * - E4: BUDGET_EXCEEDED 标准原因码
+ * - E5: 成本超限审计事件
+ * - E6: Cockpit 成本仪表板数据源
+ * - E7: getDailyCostStats API
+ * - E9: 工具调用成本代理（按工具计费）
+ * - E10: 人工审批时成本计算
+ *
+ * 设计原则：纯逻辑模块，审计通过回调注入
+ */
+interface CostRecord {
+    id: string;
+    tenantId: string;
+    agentId: string;
+    action: string;
+    toolName?: string;
+    costUsd: number;
+    tokenCount?: number;
+    modelName?: string;
+    timestamp: number;
+    category: CostCategory;
+    metadata?: Record<string, unknown>;
+}
+type CostCategory = 'llm_inference' | 'tool_call' | 'human_review' | 'storage' | 'network' | 'compute' | 'other';
+interface CostSummary {
+    period: '1h' | '24h' | '7d' | '30d';
+    totalCostUsd: number;
+    byCategory: Record<CostCategory, number>;
+    byAgent: Record<string, number>;
+    byTool: Record<string, number>;
+    recordCount: number;
+    avgCostPerAction: number;
+    peakHour?: number;
+    startTime: number;
+    endTime: number;
+}
+interface DailyCostStats {
+    date: string;
+    totalCostUsd: number;
+    byCategory: Record<CostCategory, number>;
+    actionCount: number;
+    uniqueAgents: number;
+    budgetUtilization: number;
+}
+interface BudgetExceededEvent {
+    code: 'BUDGET_EXCEEDED';
+    tenantId: string;
+    agentId: string;
+    action: string;
+    currentCostUsd: number;
+    budgetLimitUsd: number;
+    overage: number;
+    period: string;
+    timestamp: number;
+    severity: 'warning' | 'critical' | 'blocked';
+}
+interface ToolCostConfig {
+    toolName: string;
+    baseCostUsd: number;
+    perCallCostUsd: number;
+    perTokenCostUsd?: number;
+    maxCostPerCallUsd?: number;
+}
+interface HumanReviewCost {
+    reviewId: string;
+    reviewerType: 'human' | 'escalated';
+    waitTimeMs: number;
+    reviewTimeMs: number;
+    costUsd: number;
+    hourlyRateUsd: number;
+}
+interface CostGateEnhancedConfig {
+    defaultBudgetUsd: number;
+    warningThreshold: number;
+    criticalThreshold: number;
+    humanReviewHourlyRateUsd: number;
+    toolCosts: ToolCostConfig[];
+    onAudit?: (event: CostAuditEvent) => void;
+    onBudgetExceeded?: (event: BudgetExceededEvent) => void;
+}
+interface CostAuditEvent {
+    type: 'cost_recorded' | 'budget_warning' | 'budget_critical' | 'budget_exceeded' | 'summary_generated';
+    tenantId: string;
+    details: Record<string, unknown>;
+    timestamp: number;
+}
+declare class CostGateEnhancedEngine {
+    private records;
+    private budgets;
+    private config;
+    private toolCostMap;
+    constructor(config?: Partial<CostGateEnhancedConfig>);
+    /**
+     * E2: 记录成本并生成汇总
+     */
+    recordCost(record: CostRecord): BudgetExceededEvent | null;
+    /**
+     * E2: 获取成本汇总（滑动窗口）
+     */
+    getCostSummary(tenantId: string, period: CostSummary['period']): CostSummary;
+    /**
+     * E7: getDailyCostStats — 按天统计
+     */
+    getDailyCostStats(tenantId: string, days?: number): DailyCostStats[];
+    /**
+     * E9: 计算工具调用成本
+     */
+    calculateToolCost(toolName: string, tokenCount?: number): number;
+    /**
+     * E10: 计算人工审批成本
+     */
+    calculateHumanReviewCost(waitTimeMs: number, reviewTimeMs: number): HumanReviewCost;
+    /**
+     * 设置租户预算
+     */
+    setBudget(tenantId: string, budgetUsd: number): void;
+    /**
+     * 获取租户预算使用率
+     */
+    getBudgetUtilization(tenantId: string): {
+        used: number;
+        limit: number;
+        utilization: number;
+    };
+    private checkBudget;
+    private audit;
+}
+declare function createCostGateEnhanced(config?: Partial<CostGateEnhancedConfig>): CostGateEnhancedEngine;
+
+/**
+ * server/sovr/budgetMultiLevel.ts
+ *
+ * 多层预算引擎 — 补齐 F6/F7/F8 缺口
+ *
+ * 功能：
+ * - F6: 多层预算（组织 → 团队 → 项目 → Agent 四级）
+ * - F7: 预算告警（阈值触发 + 趋势预测）
+ * - F8: 成本报告（多维度分析 + 导出）
+ *
+ * 设计原则：纯逻辑模块，告警通过回调注入
+ */
+type BudgetLevel = 'organization' | 'team' | 'project' | 'agent';
+interface BudgetNode {
+    id: string;
+    name: string;
+    level: BudgetLevel;
+    parentId: string | null;
+    budgetUsd: number;
+    spentUsd: number;
+    children: string[];
+    alertRules: AlertRule[];
+    metadata?: Record<string, unknown>;
+}
+interface AlertRule {
+    id: string;
+    threshold: number;
+    severity: 'info' | 'warning' | 'critical';
+    action: 'notify' | 'throttle' | 'block';
+    cooldownMs: number;
+    lastTriggeredAt?: number;
+}
+interface BudgetAlert {
+    ruleId: string;
+    nodeId: string;
+    nodeName: string;
+    level: BudgetLevel;
+    severity: AlertRule['severity'];
+    action: AlertRule['action'];
+    utilization: number;
+    budgetUsd: number;
+    spentUsd: number;
+    remainingUsd: number;
+    predictedExhaustionDate?: string;
+    timestamp: number;
+}
+interface CostReport {
+    reportId: string;
+    generatedAt: number;
+    period: {
+        start: number;
+        end: number;
+    };
+    totalBudgetUsd: number;
+    totalSpentUsd: number;
+    utilization: number;
+    byLevel: Record<BudgetLevel, {
+        budget: number;
+        spent: number;
+        count: number;
+    }>;
+    topSpenders: {
+        id: string;
+        name: string;
+        level: BudgetLevel;
+        spent: number;
+    }[];
+    alerts: BudgetAlert[];
+    trend: {
+        date: string;
+        spent: number;
+    }[];
+}
+interface MultiLevelBudgetConfig {
+    defaultAlertRules: AlertRule[];
+    trendWindowDays: number;
+    onAlert?: (alert: BudgetAlert) => void;
+    onAudit?: (event: {
+        type: string;
+        details: Record<string, unknown>;
+        timestamp: number;
+    }) => void;
+}
+declare class MultiLevelBudgetEngine {
+    private nodes;
+    private spendHistory;
+    private config;
+    constructor(config?: Partial<MultiLevelBudgetConfig>);
+    /**
+     * F6: 创建预算节点
+     */
+    createNode(node: Omit<BudgetNode, 'spentUsd' | 'children' | 'alertRules'> & {
+        alertRules?: AlertRule[];
+    }): BudgetNode;
+    /**
+     * F6: 记录支出（向上冒泡到所有父级）
+     */
+    recordSpend(nodeId: string, amount: number): BudgetAlert[];
+    /**
+     * F6: 获取节点预算状态（含子节点汇总）
+     */
+    getNodeStatus(nodeId: string): {
+        node: BudgetNode;
+        utilization: number;
+        childrenSpent: number;
+        remaining: number;
+    } | null;
+    /**
+     * F7: 预测预算耗尽日期
+     */
+    predictExhaustion(nodeId: string): string | null;
+    /**
+     * F8: 生成成本报告
+     */
+    generateReport(rootNodeId?: string): CostReport;
+    /**
+     * 获取所有节点
+     */
+    listNodes(level?: BudgetLevel): BudgetNode[];
+    private checkAlerts;
+    private getChildrenSpent;
+    private getSubtree;
+    private generateTrend;
+}
+declare function createMultiLevelBudget(config?: Partial<MultiLevelBudgetConfig>): MultiLevelBudgetEngine;
+
+/**
+ * server/sovr/evolutionChannel.ts
+ *
+ * 受控演化通道 — 补齐 B8 缺口
+ *
+ * 功能：
+ * - 策略版本管理（版本化策略发布）
+ * - 灰度发布（canary release for policies）
+ * - A/B 测试策略（双策略并行评估）
+ * - 回滚机制（一键回退到上一版本）
+ * - 演化审计（所有策略变更记录）
+ *
+ * 设计原则：纯逻辑模块，无数据库依赖
+ */
+interface PolicyVersion$1 {
+    id: string;
+    version: string;
+    name: string;
+    rules: PolicyRule$1[];
+    createdAt: number;
+    createdBy: string;
+    status: 'draft' | 'canary' | 'active' | 'deprecated' | 'rollback';
+    canaryPercent: number;
+    metadata?: Record<string, unknown>;
+}
+interface PolicyRule$1 {
+    id: string;
+    action: string;
+    resource: string;
+    decision: 'ALLOW' | 'DENY' | 'REVIEW';
+    conditions?: Record<string, unknown>;
+    priority: number;
+}
+interface EvolutionEvent {
+    type: 'publish' | 'canary_start' | 'canary_promote' | 'canary_rollback' | 'deprecate' | 'ab_test_start' | 'ab_test_end';
+    policyId: string;
+    version: string;
+    timestamp: number;
+    actor: string;
+    details?: Record<string, unknown>;
+}
+interface ABTestConfig {
+    id: string;
+    controlVersionId: string;
+    treatmentVersionId: string;
+    trafficSplit: number;
+    startedAt: number;
+    metrics: ABTestMetrics;
+    status: 'running' | 'completed' | 'aborted';
+}
+interface ABTestMetrics {
+    controlDecisions: number;
+    treatmentDecisions: number;
+    controlAllowRate: number;
+    treatmentAllowRate: number;
+    controlAvgLatencyMs: number;
+    treatmentAvgLatencyMs: number;
+}
+interface EvolutionConfig {
+    maxVersions: number;
+    canaryMinDurationMs: number;
+    autoPromoteThreshold: number;
+    onAudit?: (event: EvolutionEvent) => void;
+}
+declare class EvolutionChannelEngine {
+    private versions;
+    private activeVersionId;
+    private canaryVersionId;
+    private abTests;
+    private config;
+    constructor(config?: Partial<EvolutionConfig>);
+    /**
+     * 发布新策略版本
+     */
+    publish(version: PolicyVersion$1): PolicyVersion$1;
+    /**
+     * 启动灰度发布
+     */
+    startCanary(versionId: string, percent: number, actor: string): boolean;
+    /**
+     * 灰度晋升为正式版本
+     */
+    promoteCanary(actor: string): boolean;
+    /**
+     * 灰度回滚
+     */
+    rollbackCanary(actor: string): boolean;
+    /**
+     * 路由决策：根据灰度百分比选择策略版本
+     */
+    resolveVersion(requestHash?: number): PolicyVersion$1 | null;
+    /**
+     * 启动 A/B 测试
+     */
+    startABTest(testId: string, controlId: string, treatmentId: string, trafficSplit: number, actor: string): ABTestConfig | null;
+    /**
+     * A/B 测试路由
+     */
+    resolveABTest(testId: string, requestHash?: number): {
+        version: PolicyVersion$1;
+        group: 'control' | 'treatment';
+    } | null;
+    /**
+     * 结束 A/B 测试
+     */
+    endABTest(testId: string, actor: string): ABTestConfig | null;
+    /**
+     * 获取所有版本
+     */
+    listVersions(): PolicyVersion$1[];
+    /**
+     * 获取当前 active 版本
+     */
+    getActiveVersion(): PolicyVersion$1 | null;
+    private cleanupOldVersions;
+    private audit;
+}
+declare function createEvolutionChannel(config?: Partial<EvolutionConfig>): EvolutionChannelEngine;
+
+/**
+ * SOVR Two-Phase Router Engine
+ * 补齐 N4 两阶段路由 + N5 可解释路由(原因代码) + N6 MVP分层路由(3层)
+ *
+ * 纯内存引擎，无外部依赖
+ *
+ * 架构:
+ * Phase 1: Eligibility (资格筛选) — 硬性规则过滤
+ * Phase 2: Scoring (评分排序) — 软性指标加权
+ *
+ * MVP 3层分层:
+ * - cheap: 低成本模型 (GPT-3.5, Claude Haiku)
+ * - balanced: 平衡模型 (GPT-4o-mini, Claude Sonnet)
+ * - powerful: 高能力模型 (GPT-4o, Claude Opus, o1)
+ */
+type ModelTier = 'cheap' | 'balanced' | 'powerful';
+interface ModelCandidate {
+    id: string;
+    name: string;
+    provider: string;
+    tier: ModelTier;
+    costPer1kTokens: number;
+    maxContextTokens: number;
+    avgLatencyMs: number;
+    capabilities: string[];
+    enabled: boolean;
+    weight: number;
+    metadata?: Record<string, unknown>;
+}
+interface RoutingRequest {
+    taskType: string;
+    requiredCapabilities: string[];
+    estimatedTokens: number;
+    maxCostUsd?: number;
+    maxLatencyMs?: number;
+    preferredTier?: ModelTier;
+    riskLevel: 'low' | 'medium' | 'high' | 'critical';
+    userId?: string;
+    metadata?: Record<string, unknown>;
+}
+type ReasonCode = 'ELIGIBLE' | 'DISABLED' | 'CAPABILITY_MISSING' | 'CONTEXT_TOO_LARGE' | 'COST_EXCEEDS_BUDGET' | 'LATENCY_EXCEEDS_LIMIT' | 'RISK_TIER_MISMATCH' | 'HARD_RULE_BLOCKED';
+interface EligibilityResult {
+    candidateId: string;
+    eligible: boolean;
+    reasonCode: ReasonCode;
+    reasonDetail: string;
+}
+interface ScoringResult {
+    candidateId: string;
+    score: number;
+    breakdown: {
+        costScore: number;
+        latencyScore: number;
+        capabilityScore: number;
+        weightScore: number;
+        tierMatchScore: number;
+    };
+}
+interface RoutingDecision {
+    selectedModelId: string;
+    selectedModelName: string;
+    tier: ModelTier;
+    phase1Results: EligibilityResult[];
+    phase2Results: ScoringResult[];
+    reasonChain: string[];
+    totalCandidates: number;
+    eligibleCandidates: number;
+    decisionTimeMs: number;
+    fallbackUsed: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface HardRule {
+    id: string;
+    name: string;
+    condition: (request: RoutingRequest, candidate: ModelCandidate) => boolean;
+    reasonCode: ReasonCode;
+    reasonTemplate: string;
+    enabled: boolean;
+}
+interface ScoringWeights {
+    cost: number;
+    latency: number;
+    capability: number;
+    weight: number;
+    tierMatch: number;
+}
+interface TwoPhaseRouterConfig {
+    models: ModelCandidate[];
+    hardRules: HardRule[];
+    scoringWeights: ScoringWeights;
+    defaultTier: ModelTier;
+    fallbackModelId?: string;
+    onDecision?: (decision: RoutingDecision) => void | Promise<void>;
+    onAudit?: (event: {
+        type: string;
+        data: Record<string, unknown>;
+    }) => void | Promise<void>;
+}
+declare const DEFAULT_HARD_RULES: HardRule[];
+declare const DEFAULT_SCORING_WEIGHTS: ScoringWeights;
+declare class TwoPhaseRouter {
+    private config;
+    constructor(config: TwoPhaseRouterConfig);
+    /**
+     * Phase 1: Eligibility — 硬性规则过滤
+     */
+    private evaluateEligibility;
+    /**
+     * Phase 2: Scoring — 软性指标加权评分
+     */
+    private evaluateScoring;
+    /**
+     * Main routing decision
+     */
+    route(request: RoutingRequest): Promise<RoutingDecision>;
+    /**
+     * Get models by tier
+     */
+    getModelsByTier(tier: ModelTier): ModelCandidate[];
+    /**
+     * Update model status
+     */
+    updateModel(modelId: string, updates: Partial<ModelCandidate>): boolean;
+    /**
+     * Add a new hard rule
+     */
+    addHardRule(rule: HardRule): void;
+    /**
+     * Get routing explanation for a specific request (dry run)
+     */
+    explain(request: RoutingRequest): Promise<{
+        decision: RoutingDecision;
+        explanation: string;
+    }>;
+}
+
+/**
+ * SOVR Time Series Aggregator
+ * 补齐 PDF3 时间序列聚合方案中的:
+ * - 幂等聚合 (idempotent aggregation with dedup)
+ * - P95 延迟计算
+ * - 时间窗口聚合 (tumbling + sliding)
+ * - 增量聚合 (不需要全量重算)
+ *
+ * 纯内存引擎，无外部依赖
+ */
+type WindowType = 'tumbling' | 'sliding';
+type AggregationType = 'count' | 'sum' | 'avg' | 'min' | 'max' | 'p50' | 'p95' | 'p99' | 'rate';
+interface DataPoint {
+    id: string;
+    timestamp: number;
+    value: number;
+    labels?: Record<string, string>;
+}
+interface AggregationWindow {
+    windowId: string;
+    windowType: WindowType;
+    startMs: number;
+    endMs: number;
+    count: number;
+    sum: number;
+    min: number;
+    max: number;
+    values: number[];
+    seenIds: Set<string>;
+}
+interface AggregationResult {
+    windowId: string;
+    windowType: WindowType;
+    startMs: number;
+    endMs: number;
+    metrics: {
+        count: number;
+        sum: number;
+        avg: number;
+        min: number;
+        max: number;
+        p50: number;
+        p95: number;
+        p99: number;
+        rate: number;
+    };
+    dedupCount: number;
+}
+interface TimeSeriesAggregatorConfig {
+    /** Window size in ms */
+    windowSizeMs: number;
+    /** Window type */
+    windowType: WindowType;
+    /** Slide interval for sliding windows (ms), ignored for tumbling */
+    slideIntervalMs?: number;
+    /** Max windows to keep in memory */
+    maxWindows: number;
+    /** Max values per window (for percentile calc memory) */
+    maxValuesPerWindow: number;
+    /** Audit callback */
+    onAudit?: (event: {
+        type: string;
+        data: Record<string, unknown>;
+    }) => void | Promise<void>;
+    /** Window closed callback */
+    onWindowClosed?: (result: AggregationResult) => void | Promise<void>;
+}
+declare const DEFAULT_TSA_CONFIG: TimeSeriesAggregatorConfig;
+declare class TimeSeriesAggregator {
+    private windows;
+    private closedResults;
+    private config;
+    private totalDedups;
+    constructor(config?: Partial<TimeSeriesAggregatorConfig>);
+    /**
+     * Ingest a data point (idempotent — duplicates are rejected)
+     */
+    ingest(point: DataPoint): Promise<{
+        accepted: boolean;
+        windowId: string;
+        duplicate: boolean;
+    }>;
+    /**
+     * Ingest multiple points (batch)
+     */
+    ingestBatch(points: DataPoint[]): Promise<{
+        accepted: number;
+        duplicates: number;
+        errors: number;
+    }>;
+    /**
+     * Get aggregation result for a specific window
+     */
+    getWindowResult(windowId: string): AggregationResult | null;
+    /**
+     * Get current (latest) window result
+     */
+    getCurrentResult(): AggregationResult | null;
+    /**
+     * Get results for a time range
+     */
+    getResultsInRange(startMs: number, endMs: number): AggregationResult[];
+    /**
+     * Close current window and emit result
+     */
+    closeWindow(windowId: string): Promise<AggregationResult | null>;
+    /**
+     * Get overall stats
+     */
+    getStats(): {
+        activeWindows: number;
+        closedWindows: number;
+        totalDedups: number;
+        totalDataPoints: number;
+    };
+    /**
+     * Reset all windows
+     */
+    reset(): void;
+    private getWindowId;
+    private createWindow;
+    private computeResult;
+    private evictOldWindows;
+}
+
+/**
+ * SOVR Valuation Model Engine
+ * 补齐 PDF1 千亿美金估值研究:
+ * - TAM/SAM/SOM 市场规模计算
+ * - 多维度估值模型 (DCF, Comparable, Network Effect)
+ * - 增长预测与敏感性分析
+ * - 单位经济学 (Unit Economics)
+ *
+ * 纯内存引擎，无外部依赖
+ */
+interface MarketSize {
+    tam: number;
+    sam: number;
+    som: number;
+    year: number;
+    growthRate: number;
+    assumptions: string[];
+}
+interface UnitEconomics {
+    arpu: number;
+    cac: number;
+    ltv: number;
+    ltvCacRatio: number;
+    paybackMonths: number;
+    grossMargin: number;
+    churnRate: number;
+    expansionRate: number;
+}
+interface DCFInput {
+    projectedRevenues: number[];
+    growthRates: number[];
+    discountRate: number;
+    terminalGrowthRate: number;
+    operatingMargin: number;
+    taxRate: number;
+    capexRatio: number;
+}
+interface DCFResult {
+    presentValue: number;
+    terminalValue: number;
+    enterpriseValue: number;
+    freeCashFlows: number[];
+    discountedCashFlows: number[];
+    impliedMultiple: number;
+}
+interface ComparableInput {
+    revenue: number;
+    ebitda: number;
+    users: number;
+    growthRate: number;
+    comparables: Array<{
+        name: string;
+        evRevenue: number;
+        evEbitda: number;
+        evUser: number;
+        growthRate: number;
+    }>;
+}
+interface ComparableResult {
+    revenueMultipleValuation: number;
+    ebitdaMultipleValuation: number;
+    perUserValuation: number;
+    averageValuation: number;
+    medianMultiple: number;
+    growthAdjustedValuation: number;
+}
+interface NetworkEffectInput {
+    currentUsers: number;
+    projectedUsers: number[];
+    valuePerConnection: number;
+    networkDensity: number;
+    metcalfeExponent: number;
+}
+interface NetworkEffectResult {
+    currentNetworkValue: number;
+    projectedValues: number[];
+    metcalfeValue: number;
+    adjustedValue: number;
+}
+interface SensitivityResult {
+    baseCase: number;
+    scenarios: Array<{
+        name: string;
+        value: number;
+        delta: number;
+        variables: Record<string, number>;
+    }>;
+    tornado: Array<{
+        variable: string;
+        lowValue: number;
+        highValue: number;
+        range: number;
+    }>;
+}
+interface ValuationModelConfig {
+    onAudit?: (event: {
+        type: string;
+        data: Record<string, unknown>;
+    }) => void | Promise<void>;
+}
+declare class ValuationModel {
+    private config;
+    constructor(config?: ValuationModelConfig);
+    /**
+     * Calculate TAM/SAM/SOM
+     */
+    calculateMarketSize(input: {
+        totalMarketUsd: number;
+        serviceablePercent: number;
+        obtainablePercent: number;
+        growthRate: number;
+        year: number;
+        assumptions: string[];
+    }): MarketSize;
+    /**
+     * Calculate Unit Economics
+     */
+    calculateUnitEconomics(input: {
+        arpu: number;
+        cac: number;
+        grossMargin: number;
+        churnRate: number;
+        expansionRate: number;
+    }): UnitEconomics;
+    /**
+     * DCF Valuation
+     */
+    calculateDCF(input: DCFInput): DCFResult;
+    /**
+     * Comparable Company Valuation
+     */
+    calculateComparable(input: ComparableInput): ComparableResult;
+    /**
+     * Network Effect Valuation (Metcalfe's Law)
+     */
+    calculateNetworkEffect(input: NetworkEffectInput): NetworkEffectResult;
+    /**
+     * Sensitivity Analysis
+     */
+    runSensitivity(baseInput: DCFInput, variables: Array<{
+        name: string;
+        low: number;
+        high: number;
+        field: keyof DCFInput;
+    }>): SensitivityResult;
+    private median;
+}
+
+/**
+ * SOVR Governance Enhancer
+ * 补齐 PDF6/7 路由治理增强计划:
+ * - 策略热更新 (hot-reload policies without restart)
+ * - 降级链 (cascading degradation with fallback chain)
+ * - 熔断器 (circuit breaker with half-open state)
+ * - 治理规则版本管理
+ *
+ * 纯内存引擎，无外部依赖
+ */
+type CircuitState = 'CLOSED' | 'OPEN' | 'HALF_OPEN';
+interface PolicyVersion {
+    version: string;
+    rules: GovernanceRule[];
+    activatedAt: number;
+    hash: string;
+    metadata?: Record<string, unknown>;
+}
+interface GovernanceRule {
+    id: string;
+    name: string;
+    condition: string;
+    action: 'allow' | 'deny' | 'degrade' | 'escalate';
+    priority: number;
+    enabled: boolean;
+    degradeTo?: string;
+    metadata?: Record<string, unknown>;
+}
+interface DegradationLevel {
+    id: string;
+    name: string;
+    order: number;
+    capabilities: string[];
+    restrictions: string[];
+}
+interface CircuitBreakerState {
+    name: string;
+    state: CircuitState;
+    failureCount: number;
+    successCount: number;
+    lastFailureAt: number;
+    lastSuccessAt: number;
+    openedAt: number;
+    halfOpenAttempts: number;
+}
+interface GovernanceDecision {
+    allowed: boolean;
+    action: string;
+    ruleId?: string;
+    ruleName?: string;
+    degradationLevel?: string;
+    circuitState?: CircuitState;
+    reason: string;
+    policyVersion: string;
+}
+interface GovernanceEnhancerConfig {
+    /** Circuit breaker: failures before opening */
+    circuitBreakerThreshold: number;
+    /** Circuit breaker: time in OPEN before trying HALF_OPEN (ms) */
+    circuitBreakerTimeoutMs: number;
+    /** Circuit breaker: successes in HALF_OPEN before closing */
+    halfOpenSuccessThreshold: number;
+    /** Degradation chain (ordered from full to minimal) */
+    degradationChain: DegradationLevel[];
+    /** Max policy versions to keep */
+    maxPolicyVersions: number;
+    /** Audit callback */
+    onAudit?: (event: {
+        type: string;
+        data: Record<string, unknown>;
+    }) => void | Promise<void>;
+    /** Policy change callback */
+    onPolicyChange?: (oldVersion: string, newVersion: string) => void | Promise<void>;
+}
+declare const DEFAULT_GE_CONFIG: GovernanceEnhancerConfig;
+declare class GovernanceEnhancer {
+    private currentPolicy;
+    private policyHistory;
+    private circuitBreakers;
+    private currentDegradationLevel;
+    private config;
+    constructor(config?: Partial<GovernanceEnhancerConfig>);
+    /**
+     * Load a new policy version (hot-reload)
+     */
+    loadPolicy(version: string, rules: GovernanceRule[]): Promise<{
+        success: boolean;
+        previousVersion?: string;
+        newVersion: string;
+    }>;
+    /**
+     * Rollback to a previous policy version
+     */
+    rollbackPolicy(version: string): Promise<boolean>;
+    /**
+     * Evaluate a governance decision
+     */
+    evaluate(context: {
+        action: string;
+        resource: string;
+        agentId: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<GovernanceDecision>;
+    /**
+     * Record a success for circuit breaker
+     */
+    recordSuccess(resource: string): void;
+    /**
+     * Record a failure for circuit breaker
+     */
+    recordFailure(resource: string): void;
+    /**
+     * Get circuit breaker state for a resource
+     */
+    getCircuitBreakerState(resource: string): CircuitState;
+    /**
+     * Get current degradation level
+     */
+    getCurrentDegradationLevel(): DegradationLevel | undefined;
+    /**
+     * Degrade to next level
+     */
+    degradeOneLevel(): DegradationLevel | null;
+    /**
+     * Restore to full capability
+     */
+    restoreFullCapability(): void;
+    /**
+     * Check if a capability is available at current degradation level
+     */
+    isCapabilityAvailable(capability: string): boolean;
+    /**
+     * Get full governance status
+     */
+    getStatus(): {
+        policyVersion: string | null;
+        ruleCount: number;
+        degradationLevel: string;
+        circuitBreakers: CircuitBreakerState[];
+        policyHistoryCount: number;
+    };
+    private evaluateCondition;
+    private getOrCreateCircuitBreaker;
+}
+
+/**
+ * SOVR Context Accelerator
+ * 补齐 PDF8 上下文加速器设计任务:
+ * - 上下文缓存 (LRU with TTL)
+ * - 上下文预热 (prefetch pipeline)
+ * - 上下文压缩 (token budget optimization)
+ * - 上下文优先级排序
+ *
+ * 纯内存引擎，无外部依赖
+ */
+type ContextPriority = 'critical' | 'high' | 'medium' | 'low';
+interface ContextFragment {
+    id: string;
+    content: string;
+    tokenCount: number;
+    priority: ContextPriority;
+    source: string;
+    timestamp: number;
+    ttlMs: number;
+    compressed: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface CacheEntry {
+    fragment: ContextFragment;
+    accessCount: number;
+    lastAccessedAt: number;
+    createdAt: number;
+    expiresAt: number;
+}
+interface AssembledContext {
+    fragments: ContextFragment[];
+    totalTokens: number;
+    budgetUsed: number;
+    droppedCount: number;
+    compressedCount: number;
+    cacheHits: number;
+    cacheMisses: number;
+    assemblyTimeMs: number;
+}
+interface PrefetchRule {
+    id: string;
+    trigger: string;
+    fragmentIds: string[];
+    enabled: boolean;
+}
+interface ContextAcceleratorConfig {
+    /** Max cache entries */
+    maxCacheEntries: number;
+    /** Default TTL for cache entries (ms) */
+    defaultTtlMs: number;
+    /** Token budget for assembled context */
+    tokenBudget: number;
+    /** Compression ratio target (0-1) */
+    compressionTarget: number;
+    /** Priority weights for sorting */
+    priorityWeights: Record<ContextPriority, number>;
+    /** Audit callback */
+    onAudit?: (event: {
+        type: string;
+        data: Record<string, unknown>;
+    }) => void | Promise<void>;
+    /** Custom compressor function */
+    compressor?: (content: string, targetTokens: number) => string;
+}
+declare const DEFAULT_CA_CONFIG: ContextAcceleratorConfig;
+declare class ContextAccelerator {
+    private cache;
+    private prefetchRules;
+    private config;
+    private stats;
+    constructor(config?: Partial<ContextAcceleratorConfig>);
+    /**
+     * Put a fragment into cache
+     */
+    put(fragment: ContextFragment): void;
+    /**
+     * Get a fragment from cache
+     */
+    get(id: string): ContextFragment | null;
+    /**
+     * Assemble context from fragments within token budget
+     */
+    assemble(fragmentIds: string[], additionalFragments?: ContextFragment[], budgetOverride?: number): Promise<AssembledContext>;
+    /**
+     * Register a prefetch rule
+     */
+    addPrefetchRule(rule: PrefetchRule): void;
+    /**
+     * Execute prefetch based on task type
+     */
+    prefetch(taskType: string, fragmentLoader: (ids: string[]) => Promise<ContextFragment[]>): Promise<number>;
+    /**
+     * Invalidate cache entries
+     */
+    invalidate(ids: string[]): number;
+    /**
+     * Get cache stats
+     */
+    getStats(): {
+        cacheSize: number;
+        maxSize: number;
+        hitRate: number;
+        totalHits: number;
+        totalMisses: number;
+        totalEvictions: number;
+        totalCompressions: number;
+        totalAssemblies: number;
+        prefetchRuleCount: number;
+    };
+    /**
+     * Clear all cache
+     */
+    clear(): void;
+    private evictExpired;
+    private evictLRU;
+}
+
 /**
  * @sovr/engine — Unified Policy Engine
  *
@@ -565,4 +2086,4 @@ declare class PolicyEngine {
     }): void;
 }
 
-export { AdaptiveThresholdManager, type AdaptiveThresholdOptions, type AdjustmentResult, type AuditEvent, type Channel, type ComparisonNode, type CompiledExpression, DEFAULT_RULES, type DecisionFeedback, type EngineConfig, type EngineTier, type EngineTierLimits, type EvalContext, type EvalRequest, type EvalResult, type ExecContext, type ExprTreePolicyRule, type ExpressionNode, type FeatureSwitchDef, type FeatureSwitchState, FeatureSwitchesManager, type FeatureSwitchesOptions, type FunctionNode, type HttpContext, type LiteralNode, type LogicalNode, type McpContext, type NotNode, PolicyEngine, type PolicyRule, type PricingEvalRequest, type PricingEvalResult, type PricingRule, PricingRulesEngine, type RiskLevel, type RuleCondition, type RuleEvalResult, SOVR_FEATURE_SWITCHES, type SqlContext, type ThresholdConfig, type VariableNode, type Verdict, compileFromJSON, compileRuleSet, PolicyEngine as default, evaluateRules, registerFunction };
+export { type ABTestConfig, AdaptiveThresholdManager, type AdaptiveThresholdOptions, type AdjustmentResult, type AggregateSnapshot, type AggregationResult, type AggregationType, type AggregationWindow, type AssembledContext, type AuditEvent, AutoHardenEngine, type BudgetAlert, type BudgetLevel, type BudgetNode, type CacheEntry, type Channel, type CircuitBreakerState, type CircuitState, type ComparableInput, type ComparableResult, type ComparisonNode, type CompiledExpression, type ConsistencyMismatch, type ConsistencyResult, ContextAccelerator, type ContextAcceleratorConfig, type ContextFragment, type ContextPriority, type CostAuditEvent, type CostCategory, type CostEstimate, type CostEstimateRequest, type CostGateEnhancedConfig, CostGateEnhancedEngine, type CostRecord, type CostReport, type CostSummary, type DCFInput, type DCFResult, DEFAULT_CA_CONFIG, DEFAULT_GE_CONFIG, DEFAULT_HARD_RULES, DEFAULT_RULES, DEFAULT_SCORING_WEIGHTS, DEFAULT_TSA_CONFIG, type DataPoint, type DecisionFeedback, type DegradationLevel, type DriftConfig, type DriftResult, type EligibilityResult, type EngineConfig, type EngineTier, type EngineTierLimits, type EstimateAccuracy, type EvalContext, type EvalRequest, type EvalResult, EvolutionChannelEngine, type EvolutionConfig, type EvolutionEvent, type ExecContext, type ExprTreePolicyRule, type ExpressionNode, type FeatureSwitchDef, type FeatureSwitchState, FeatureSwitchesManager, type FeatureSwitchesOptions, type FunctionNode, type PolicyVersion as GovPolicyVersion, type GovernanceDecision, GovernanceEnhancer, type GovernanceEnhancerConfig, type GovernanceRule, type HardRule, type HardenConfig, type HardenEvent, type HardenLevel, type HardenMeasure, type HardenMeasureType, type HardenState, type HttpContext, type LiteralNode, type LogicalNode, type MarketSize, type McpContext, type ModelCandidate, type ModelPricing, type ModelTier, type MultiLevelBudgetConfig, MultiLevelBudgetEngine, type NetworkEffectInput, type NetworkEffectResult, type NotNode, PolicyEngine, type PolicyRule, type PolicySnapshot, type PolicyVersion$1 as PolicyVersion, type PrefetchRule, type PricingEvalRequest, type PricingEvalResult, type PricingRule, PricingRulesEngine, type ReasonCode, type RecalcEngineConfig, type RecalcGranularity, type RecalcHandler, type RecalcTask, type RecalcTaskStatus, type RecalcTriggerType, RecalculationEngine, type RiskLevel, type RoutingDecision, type RoutingRequest, type RuleCondition, type RuleEvalResult, SOVR_FEATURE_SWITCHES, type ScoringResult, type ScoringWeights, SemanticDriftDetectorEngine, type SemanticFingerprint, type SensitivityResult, type SqlContext, type ThresholdConfig, TimeSeriesAggregator, type TimeSeriesAggregatorConfig, type ToolPricing, TwoPhaseRouter, type TwoPhaseRouterConfig, type UnitEconomics, ValuationModel, type ValuationModelConfig, type VariableNode, type Verdict, type WindowType, compileFromJSON, compileRuleSet, createAutoHardenEngine, createCostGateEnhanced, createEvolutionChannel, createMultiLevelBudget, createRecalculationEngine, createSemanticDriftDetector, PolicyEngine as default, estimateCost, evaluateRules, getAccuracyStats, getModelPricingTable, getToolPricingTable, recordActualCost, registerFunction, updateModelPricing, updateToolPricing };