@toyako/hive 1.0.0

package/src/runtime/v2.1/der/FaultInjectionLayer.ts

@@ -0,0 +1,181 @@
+/**
+ * Fault Injection Layer — DER Extension
+ * 
+ * 铁律：不改变核心确定性逻辑，只扩展验证层
+ * 
+ * 职责：
+ * - delay injection
+ * - partial failure simulation
+ * - retry storms
+ * - queue reordering
+ */
+
+// 故障注入配置
+export interface FaultInjectionConfig {
+  enabled: boolean;
+  delayInjection: {
+    enabled: boolean;
+    probability: number;  // 0-1
+    maxDelay: number;     // ms
+  };
+  partialFailure: {
+    enabled: boolean;
+    probability: number;  // 0-1
+  };
+  retryStorms: {
+    enabled: boolean;
+    maxRetries: number;
+    probability: number;  // 0-1
+  };
+  queueReordering: {
+    enabled: boolean;
+    probability: number;  // 0-1
+  };
+}
+
+// 故障注入结果
+export interface FaultInjectionResult {
+  totalRuns: number;
+  delaysInjected: number;
+  failuresInjected: number;
+  retryStormsTriggered: number;
+  queueReorderings: number;
+}
+
+export class FaultInjectionLayer {
+  private config: FaultInjectionConfig;
+
+  constructor(config: Partial<FaultInjectionConfig> = {}) {
+    this.config = {
+      enabled: true,
+      delayInjection: {
+        enabled: true,
+        probability: 0.1,
+        maxDelay: 50
+      },
+      partialFailure: {
+        enabled: true,
+        probability: 0.05
+      },
+      retryStorms: {
+        enabled: true,
+        maxRetries: 5,
+        probability: 0.02
+      },
+      queueReordering: {
+        enabled: true,
+        probability: 0.1
+      },
+      ...config
+    };
+  }
+
+  /**
+   * 执行带故障注入的测试
+   */
+  async execute<T>(
+    executor: () => Promise<T>,
+    runs: number
+  ): Promise<{ results: T[]; faults: FaultInjectionResult }> {
+    const results: T[] = [];
+    let delaysInjected = 0;
+    let failuresInjected = 0;
+    let retryStormsTriggered = 0;
+    let queueReorderings = 0;
+
+    for (let i = 0; i < runs; i++) {
+      const result = await this.executeWithFaults(executor, i, {
+        delaysInjected,
+        failuresInjected,
+        retryStormsTriggered,
+        queueReorderings
+      });
+
+      if (result.injected.delay) delaysInjected++;
+      if (result.injected.failure) failuresInjected++;
+      if (result.injected.retryStorm) retryStormsTriggered++;
+      if (result.injected.reordering) queueReorderings++;
+
+      results.push(result.value);
+    }
+
+    return {
+      results,
+      faults: {
+        totalRuns: runs,
+        delaysInjected,
+        failuresInjected,
+        retryStormsTriggered,
+        queueReorderings
+      }
+    };
+  }
+
+  /**
+   * 带故障注入的执行
+   */
+  private async executeWithFaults<T>(
+    executor: () => Promise<T>,
+    index: number,
+    counters: { delaysInjected: number; failuresInjected: number; retryStormsTriggered: number; queueReorderings: number }
+  ): Promise<{ value: T; injected: { delay: boolean; failure: boolean; retryStorm: boolean; reordering: boolean } }> {
+    const injected = { delay: false, failure: false, retryStorm: false, reordering: false };
+
+    // 延迟注入
+    if (this.config.delayInjection.enabled && Math.random() < this.config.delayInjection.probability) {
+      const delay = Math.random() * this.config.delayInjection.maxDelay;
+      await this.delay(delay);
+      injected.delay = true;
+    }
+
+    // 队列重排
+    if (this.config.queueReordering.enabled && Math.random() < this.config.queueReordering.probability) {
+      await this.delay(Math.random() * 5);
+      injected.reordering = true;
+    }
+
+    // 部分失败模拟
+    if (this.config.partialFailure.enabled && Math.random() < this.config.partialFailure.probability) {
+      // 模拟失败后重试
+      try {
+        throw new Error("Injected failure");
+      } catch {
+        // 重试
+        injected.failure = true;
+      }
+    }
+
+    // 重试风暴
+    if (this.config.retryStorms.enabled && Math.random() < this.config.retryStorms.probability) {
+      let retries = 0;
+      while (retries < this.config.retryStorms.maxRetries) {
+        try {
+          const result = await executor();
+          return { value: result, injected: { ...injected, retryStorm: true } };
+        } catch {
+          retries++;
+          await this.delay(1);
+        }
+      }
+      injected.retryStorm = true;
+    }
+
+    // 正常执行
+    const result = await executor();
+    return { value: result, injected };
+  }
+
+  /**
+   * 延迟
+   */
+  private delay(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * 获取配置
+   */
+  getConfig(): FaultInjectionConfig {
+    return { ...this.config };
+  }
+}

package/src/runtime/v2.1/der/StressMetrics.ts

@@ -0,0 +1,170 @@
+/**
+ * Stress Metrics — DER Extension
+ * 
+ * 收集混沌和故障注入下的指标
+ * 
+ * 输出指标：
+ * - divergence rate under chaos
+ * - trace stability under load
+ * - proof consistency under stress
+ */
+
+// 压力指标
+export interface StressMetrics {
+  // 混沌下的分歧率
+  chaosDivergence: {
+    totalRuns: number;
+    divergentRuns: number;
+    divergenceRate: number;
+  };
+
+  // 负载下的追踪稳定性
+  traceStability: {
+    totalTraces: number;
+    stableTraces: number;
+    stabilityRate: number;
+  };
+
+  // 压力下的证明一致性
+  proofConsistency: {
+    totalProofs: number;
+    consistentProofs: number;
+    consistencyRate: number;
+  };
+
+  // 混沌执行统计
+  chaosStats: {
+    schedulingJitterApplied: number;
+    workerInterleavings: number;
+    avgLatency: number;
+    maxLatency: number;
+  };
+
+  // 故障注入统计
+  faultStats: {
+    delaysInjected: number;
+    failuresInjected: number;
+    retryStormsTriggered: number;
+    queueReorderings: number;
+  };
+}
+
+export class StressMetricsCollector {
+  private results: any[] = [];
+  private traces: any[][] = [];
+  private proofs: string[] = [];
+
+  /**
+   * 记录执行结果
+   */
+  record(result: any, trace: any[], proof: string): void {
+    this.results.push(result);
+    this.traces.push(trace);
+    this.proofs.push(proof);
+  }
+
+  /**
+   * 计算压力指标
+   */
+  calculate(): StressMetrics {
+    if (this.results.length === 0) {
+      return this.emptyMetrics();
+    }
+
+    const base = this.results[0];
+    let divergentRuns = 0;
+    let stableTraces = 0;
+    let consistentProofs = 0;
+
+    for (let i = 0; i < this.results.length; i++) {
+      // 检查结果一致性
+      if (!this.deepEqual(this.results[i], base)) {
+        divergentRuns++;
+      }
+
+      // 检查追踪稳定性
+      if (this.traces[i] && this.traces[i].length > 0) {
+        stableTraces++;
+      }
+
+      // 检查证明一致性
+      if (this.proofs[i] === this.proofs[0]) {
+        consistentProofs++;
+      }
+    }
+
+    return {
+      chaosDivergence: {
+        totalRuns: this.results.length,
+        divergentRuns,
+        divergenceRate: divergentRuns / this.results.length
+      },
+      traceStability: {
+        totalTraces: this.traces.length,
+        stableTraces,
+        stabilityRate: stableTraces / this.traces.length
+      },
+      proofConsistency: {
+        totalProofs: this.proofs.length,
+        consistentProofs,
+        consistencyRate: consistentProofs / this.proofs.length
+      },
+      chaosStats: {
+        schedulingJitterApplied: 0,
+        workerInterleavings: 0,
+        avgLatency: 0,
+        maxLatency: 0
+      },
+      faultStats: {
+        delaysInjected: 0,
+        failuresInjected: 0,
+        retryStormsTriggered: 0,
+        queueReorderings: 0
+      }
+    };
+  }
+
+  /**
+   * 重置
+   */
+  reset(): void {
+    this.results = [];
+    this.traces = [];
+    this.proofs = [];
+  }
+
+  /**
+   * 深度比较
+   */
+  private deepEqual(a: any, b: any): boolean {
+    if (a === b) return true;
+    if (a === null || b === null) return false;
+    if (typeof a !== typeof b) return false;
+    if (typeof a !== "object") return false;
+
+    const keysA = Object.keys(a).sort();
+    const keysB = Object.keys(b).sort();
+
+    if (keysA.length !== keysB.length) return false;
+
+    for (let i = 0; i < keysA.length; i++) {
+      if (keysA[i] !== keysB[i]) return false;
+      if (!this.deepEqual(a[keysA[i]], b[keysB[i]])) return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * 空指标
+   */
+  private emptyMetrics(): StressMetrics {
+    return {
+      chaosDivergence: { totalRuns: 0, divergentRuns: 0, divergenceRate: 0 },
+      traceStability: { totalTraces: 0, stableTraces: 0, stabilityRate: 0 },
+      proofConsistency: { totalProofs: 0, consistentProofs: 0, consistencyRate: 0 },
+      chaosStats: { schedulingJitterApplied: 0, workerInterleavings: 0, avgLatency: 0, maxLatency: 0 },
+      faultStats: { delaysInjected: 0, failuresInjected: 0, retryStormsTriggered: 0, queueReorderings: 0 }
+    };
+  }
+}

package/src/runtime/v2.1/index.ts

@@ -0,0 +1,101 @@
+/**
+ * Runtime v2.1 — Control Plane
+ * 
+ * Dual-Layer Deterministic Runtime System (DL-DRS)
+ * with Contract-Governed Execution Semantics
+ */
+
+// Contract Layer
+export {
+  Plan,
+  Step,
+  Edge,
+  NormalizedPlan,
+  DAG,
+  ExecutionContract,
+  ShadowContractLayer
+} from "./contract/ShadowContractLayer";
+
+// Bridge
+export {
+  ExecutionBridgeConfig,
+  BridgeResult,
+  ExecutionBridge
+} from "./bridge/ExecutionBridge";
+
+// Decision Layer
+export {
+  ShadowDecision,
+  ArbitrationConfig,
+  ShadowDecisionLayer
+} from "./decision/ShadowDecisionLayer";
+
+// Observability
+export {
+  TraceEvent,
+  CausalNode,
+  DivergenceReport,
+  ShadowObservabilityLayer
+} from "./observability/ShadowObservabilityLayer";
+
+// Control Plane
+export {
+  ControlPlaneFlags,
+  DualExecutionResult,
+  ControlPlane
+} from "./ControlPlane";
+
+// Re-export v2 components
+export { RuntimeCore } from "../v2/RuntimeCore";
+export { RuntimeQueue } from "../v2/queue/RuntimeQueue";
+
+// Validation
+export {
+  ValidationMetrics,
+  ValidationReport,
+  ValidationConfig,
+  ValidationEngine
+} from "./validation/ValidationEngine";
+
+export {
+  DashboardData,
+  ValidationDashboard
+} from "./validation/ValidationDashboard";
+
+export {
+  DivergenceType,
+  DivergenceDetail,
+  DivergenceAnalyzer
+} from "./validation/DivergenceAnalyzer";
+
+export {
+  CutoverStatus,
+  CutoverReport,
+  CutoverGate
+} from "./validation/CutoverGate";
+
+// DER (Deterministic Evaluation Runtime)
+export {
+  RunRecord,
+  TraceRecord,
+  VerificationResult,
+  DER
+} from "./der/DER";
+
+// DER Extensions
+export {
+  ChaosConfig,
+  ChaosResult,
+  ChaosExecutionMode
+} from "./der/ChaosExecutionMode";
+
+export {
+  FaultInjectionConfig,
+  FaultInjectionResult,
+  FaultInjectionLayer
+} from "./der/FaultInjectionLayer";
+
+export {
+  StressMetrics,
+  StressMetricsCollector
+} from "./der/StressMetrics";

package/src/runtime/v2.1/observability/ShadowObservabilityLayer.ts

@@ -0,0 +1,226 @@
+/**
+ * Shadow Observability Layer — v2.1
+ * 
+ * 影子观测系统
+ * 
+ * 职责：
+ * - 记录 v2.1 全链路但不影响 v2.0
+ * - trace collection
+ * - causal graph construction
+ * - replay support
+ * 
+ * 规则：
+ * ❌ Observability must NOT affect execution
+ */
+
+// Trace Event
+export interface TraceEvent {
+  traceId: string;
+  contractId: string;
+  source: "v2.0" | "v2.1-shadow";
+  type: "DECISION" | "CONTRACT" | "BRIDGE" | "EXECUTION" | "ERROR";
+  payload: any;
+  timestamp: number;
+}
+
+// Causal Graph Node
+export interface CausalNode {
+  id: string;
+  type: string;
+  parentId?: string;
+  timestamp: number;
+  metadata?: Record<string, any>;
+}
+
+// Divergence Report
+export interface DivergenceReport {
+  contractId: string;
+  type: "ORDER_MISMATCH" | "STEP_LOSS" | "EXTRA_EXECUTION" | "RECOVERY_DIFFERENCE";
+  description: string;
+  v2_0_state: any;
+  v2_1_state: any;
+  timestamp: number;
+}
+
+export class ShadowObservabilityLayer {
+  private traces: TraceEvent[] = [];
+  private causalGraph: CausalNode[] = [];
+  private divergences: DivergenceReport[] = [];
+
+  /**
+   * 记录 Trace Event
+   */
+  recordTrace(event: Omit<TraceEvent, "timestamp">): TraceEvent {
+    const fullEvent: TraceEvent = {
+      ...event,
+      timestamp: Date.now()
+    };
+
+    this.traces.push(fullEvent);
+
+    // 构建因果图
+    this.addToCausalGraph(fullEvent);
+
+    return fullEvent;
+  }
+
+  /**
+   * 记录决策追踪
+   */
+  recordDecision(contractId: string, decision: any): TraceEvent {
+    return this.recordTrace({
+      traceId: `trace-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      contractId,
+      source: "v2.1-shadow",
+      type: "DECISION",
+      payload: decision
+    });
+  }
+
+  /**
+   * 记录 Contract 生成
+   */
+  recordContract(contractId: string, contract: any): TraceEvent {
+    return this.recordTrace({
+      traceId: `trace-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      contractId,
+      source: "v2.1-shadow",
+      type: "CONTRACT",
+      payload: contract
+    });
+  }
+
+  /**
+   * 记录 Bridge 映射
+   */
+  recordBridge(contractId: string, mapping: any): TraceEvent {
+    return this.recordTrace({
+      traceId: `trace-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      contractId,
+      source: "v2.1-shadow",
+      type: "BRIDGE",
+      payload: mapping
+    });
+  }
+
+  /**
+   * 记录执行追踪
+   */
+  recordExecution(contractId: string, execution: any): TraceEvent {
+    return this.recordTrace({
+      traceId: `trace-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      contractId,
+      source: "v2.1-shadow",
+      type: "EXECUTION",
+      payload: execution
+    });
+  }
+
+  /**
+   * 记录错误
+   */
+  recordError(contractId: string, error: any): TraceEvent {
+    return this.recordTrace({
+      traceId: `trace-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      contractId,
+      source: "v2.1-shadow",
+      type: "ERROR",
+      payload: error
+    });
+  }
+
+  /**
+   * 记录 Divergence
+   */
+  recordDivergence(report: Omit<DivergenceReport, "timestamp">): DivergenceReport {
+    const fullReport: DivergenceReport = {
+      ...report,
+      timestamp: Date.now()
+    };
+
+    this.divergences.push(fullReport);
+    return fullReport;
+  }
+
+  /**
+   * 获取 Contract 的所有追踪
+   */
+  getTracesByContract(contractId: string): TraceEvent[] {
+    return this.traces.filter(t => t.contractId === contractId);
+  }
+
+  /**
+   * 获取因果图
+   */
+  getCausalGraph(contractId?: string): CausalNode[] {
+    if (contractId) {
+      return this.causalGraph.filter(n => n.metadata?.contractId === contractId);
+    }
+    return [...this.causalGraph];
+  }
+
+  /**
+   * 获取 Divergence 报告
+   */
+  getDivergences(contractId?: string): DivergenceReport[] {
+    if (contractId) {
+      return this.divergences.filter(d => d.contractId === contractId);
+    }
+    return [...this.divergences];
+  }
+
+  /**
+   * 重放追踪
+   */
+  replay(contractId: string): TraceEvent[] {
+    return this.getTracesByContract(contractId)
+      .sort((a, b) => a.timestamp - b.timestamp);
+  }
+
+  /**
+   * 获取统计
+   */
+  getStats(): {
+    totalTraces: number;
+    totalDivergences: number;
+    tracesByType: Record<string, number>;
+  } {
+    const tracesByType: Record<string, number> = {};
+    for (const trace of this.traces) {
+      tracesByType[trace.type] = (tracesByType[trace.type] || 0) + 1;
+    }
+
+    return {
+      totalTraces: this.traces.length,
+      totalDivergences: this.divergences.length,
+      tracesByType
+    };
+  }
+
+  /**
+   * 添加到因果图
+   */
+  private addToCausalGraph(event: TraceEvent): void {
+    const node: CausalNode = {
+      id: event.traceId,
+      type: event.type,
+      timestamp: event.timestamp,
+      metadata: {
+        contractId: event.contractId,
+        source: event.source
+      }
+    };
+
+    // 找到父节点（同一 contract 的上一个事件）
+    const contractTraces = this.traces.filter(
+      t => t.contractId === event.contractId && t.timestamp < event.timestamp
+    );
+
+    if (contractTraces.length > 0) {
+      const parent = contractTraces[contractTraces.length - 1];
+      node.parentId = parent.traceId;
+    }
+
+    this.causalGraph.push(node);
+  }
+}