@toyako/hive 1.0.0

package/src/trace/gate/DeviationDetectionEngine.ts

@@ -0,0 +1,182 @@
+/**
+ * Deviation Detection Engine — v5.2
+ * 
+ * 计算 deviationScore = f(planned, actual)
+ * 
+ * Types of deviation:
+ * - ORDER_DEVIATION
+ * - INPUT_DEVIATION
+ * - OUTPUT_DEVIATION
+ * - LAYER_DEVIATION
+ * - SKIPPED_NODE
+ * - EXTRA_NODE
+ */
+
+import { ExecutionTracePlan, TraceNode } from "./ExecutionTracePlan";
+
+// Deviation Report
+export interface DeviationReport {
+  hasDeviation: boolean;
+  score: number;
+  deviations: Deviation[];
+  recommendation: "CONTINUE" | "RETRY" | "REPLAN" | "ABORT";
+}
+
+// Deviation
+export interface Deviation {
+  type: "ORDER_DEVIATION" | "INPUT_DEVIATION" | "OUTPUT_DEVIATION" | "LAYER_DEVIATION" | "SKIPPED_NODE" | "EXTRA_NODE";
+  severity: "low" | "medium" | "high" | "critical";
+  description: string;
+  nodeId?: string;
+}
+
+export class DeviationDetectionEngine {
+  private threshold: number;
+
+  constructor(threshold: number = 0.5) {
+    this.threshold = threshold;
+  }
+
+  /**
+   * 检测偏差
+   */
+  detect(
+    plan: ExecutionTracePlan,
+    actualExecution: { nodeId: string; input: any; output: any; layer: string }[]
+  ): DeviationReport {
+    const deviations: Deviation[] = [];
+
+    // 检查顺序偏差
+    const orderDeviations = this.checkOrderDeviation(plan, actualExecution);
+    deviations.push(...orderDeviations);
+
+    // 检查跳过的节点
+    const skippedNodes = this.checkSkippedNodes(plan, actualExecution);
+    deviations.push(...skippedNodes);
+
+    // 检查多余的节点
+    const extraNodes = this.checkExtraNodes(plan, actualExecution);
+    deviations.push(...extraNodes);
+
+    // 计算总分
+    const score = this.calculateScore(deviations);
+
+    // 决定建议
+    const recommendation = this.makeRecommendation(score, deviations);
+
+    return {
+      hasDeviation: deviations.length > 0,
+      score,
+      deviations,
+      recommendation
+    };
+  }
+
+  /**
+   * 检查顺序偏差
+   */
+  private checkOrderDeviation(
+    plan: ExecutionTracePlan,
+    actual: { nodeId: string }[]
+  ): Deviation[] {
+    const deviations: Deviation[] = [];
+    const expectedOrder = plan.expectedNodeOrder;
+
+    for (let i = 0; i < Math.min(expectedOrder.length, actual.length); i++) {
+      if (expectedOrder[i] !== actual[i].nodeId) {
+        deviations.push({
+          type: "ORDER_DEVIATION",
+          severity: "high",
+          description: `Position ${i}: expected ${expectedOrder[i]}, got ${actual[i].nodeId}`,
+          nodeId: actual[i].nodeId
+        });
+      }
+    }
+
+    return deviations;
+  }
+
+  /**
+   * 检查跳过的节点
+   */
+  private checkSkippedNodes(
+    plan: ExecutionTracePlan,
+    actual: { nodeId: string }[]
+  ): Deviation[] {
+    const deviations: Deviation[] = [];
+    const actualIds = new Set(actual.map(a => a.nodeId));
+
+    for (const expected of plan.expectedNodeOrder) {
+      if (!actualIds.has(expected)) {
+        if (!plan.constraints.allowedDeviations.includes(expected)) {
+          deviations.push({
+            type: "SKIPPED_NODE",
+            severity: "critical",
+            description: `Required node ${expected} was skipped`,
+            nodeId: expected
+          });
+        }
+      }
+    }
+
+    return deviations;
+  }
+
+  /**
+   * 检查多余的节点
+   */
+  private checkExtraNodes(
+    plan: ExecutionTracePlan,
+    actual: { nodeId: string }[]
+  ): Deviation[] {
+    const deviations: Deviation[] = [];
+    const expectedIds = new Set(plan.expectedNodeOrder);
+
+    for (const node of actual) {
+      if (!expectedIds.has(node.nodeId)) {
+        deviations.push({
+          type: "EXTRA_NODE",
+          severity: "medium",
+          description: `Unexpected node ${node.nodeId} executed`,
+          nodeId: node.nodeId
+        });
+      }
+    }
+
+    return deviations;
+  }
+
+  /**
+   * 计算分数
+   */
+  private calculateScore(deviations: Deviation[]): number {
+    if (deviations.length === 0) return 0;
+
+    let score = 0;
+    for (const dev of deviations) {
+      switch (dev.severity) {
+        case "critical": score += 1.0; break;
+        case "high": score += 0.7; break;
+        case "medium": score += 0.4; break;
+        case "low": score += 0.1; break;
+      }
+    }
+
+    return Math.min(1.0, score);
+  }
+
+  /**
+   * 做出建议
+   */
+  private makeRecommendation(
+    score: number,
+    deviations: Deviation[]
+  ): DeviationReport["recommendation"] {
+    const hasCritical = deviations.some(d => d.severity === "critical");
+
+    if (hasCritical) return "ABORT";
+    if (score > this.threshold) return "REPLAN";
+    if (score > 0) return "RETRY";
+    return "CONTINUE";
+  }
+}

package/src/trace/gate/ExecutionTracePlan.ts

@@ -0,0 +1,108 @@
+/**
+ * Execution Trace Plan (ETP) — v5.2
+ * 
+ * Trace is no longer output.
+ * Trace is the contract of execution.
+ * 
+ * If execution deviates from trace → system MUST block, retry, or replan.
+ */
+
+// Trace Node
+export interface TraceNode {
+  id: string;
+  layer: string;
+  expectedInput: any;
+  expectedOutputSchema: any;
+}
+
+// Trace Edge
+export interface TraceEdge {
+  from: string;
+  to: string;
+}
+
+// Validation Rule
+export interface ValidationRule {
+  type: string;
+  condition: string;
+  action: "BLOCK" | "RETRY" | "REPLAN";
+}
+
+// Execution Trace Plan
+export interface ExecutionTracePlan {
+  executionId: string;
+  intent: any;
+  causalGraph: {
+    nodes: TraceNode[];
+    edges: TraceEdge[];
+  };
+  executionStages: string[];
+  expectedNodeOrder: string[];
+  constraints: {
+    mustExecuteInOrder: boolean;
+    allowedDeviations: string[];
+    forbiddenSkips: string[];
+  };
+  validationRules: ValidationRule[];
+  failureRecoveryPolicy: {
+    retryAllowed: boolean;
+    maxRetries: number;
+    fallbackPlan: string;
+  };
+}
+
+export class ExecutionTracePlanGenerator {
+  /**
+   * 生成追踪计划
+   */
+  generate(intent: any, dag: any): ExecutionTracePlan {
+    const executionId = `etp-${Date.now()}`;
+    
+    // 从 DAG 生成追踪节点
+    const nodes: TraceNode[] = (dag.nodes || []).map((nodeId: string) => ({
+      id: nodeId,
+      layer: this.inferLayer(nodeId),
+      expectedInput: {},
+      expectedOutputSchema: {}
+    }));
+
+    // 从 DAG 生成追踪边
+    const edges: TraceEdge[] = (dag.edges || []).map((edge: [string, string]) => ({
+      from: edge[0],
+      to: edge[1]
+    }));
+
+    return {
+      executionId,
+      intent,
+      causalGraph: { nodes, edges },
+      executionStages: ["intent", "product", "architecture", "planning", "runtime", "governance", "observation"],
+      expectedNodeOrder: nodes.map(n => n.id),
+      constraints: {
+        mustExecuteInOrder: true,
+        allowedDeviations: [],
+        forbiddenSkips: nodes.map(n => n.id)
+      },
+      validationRules: [
+        { type: "ORDER", condition: "strict", action: "BLOCK" },
+        { type: "INPUT", condition: "match", action: "RETRY" },
+        { type: "OUTPUT", condition: "match", action: "REPLAN" }
+      ],
+      failureRecoveryPolicy: {
+        retryAllowed: true,
+        maxRetries: 3,
+        fallbackPlan: "REPLAN"
+      }
+    };
+  }
+
+  /**
+   * 推断层
+   */
+  private inferLayer(nodeId: string): string {
+    if (nodeId.includes("hermes") || nodeId.includes("planner")) return "Planning";
+    if (nodeId.includes("worker")) return "Runtime";
+    if (nodeId.includes("reviewer")) return "Governance";
+    return "Runtime";
+  }
+}

package/src/trace/gate/TraceExecutionGate.ts

@@ -0,0 +1,163 @@
+/**
+ * Trace Execution Gate — v5.2
+ * 
+ * Every runtime step MUST pass through Execution Gate.
+ * 
+ * Rules:
+ * 1. Step Validation - verify node exists in ETP, is next expected, input matches
+ * 2. Order Enforcement - block if deviates, trigger replan/recovery
+ * 3. Contract Enforcement - match input/output schema, layer attribution
+ * 
+ * Trace defines reality.
+ * Runtime only obeys reality.
+ */
+
+import { ExecutionTracePlan, TraceNode } from "./ExecutionTracePlan";
+
+// Gate Result
+export interface GateResult {
+  allowed: boolean;
+  reason: string;
+  deviationType?: string;
+}
+
+// Deviation Score
+export interface DeviationScore {
+  score: number;
+  type: "ORDER_DEVIATION" | "INPUT_DEVIATION" | "OUTPUT_DEVIATION" | "LAYER_DEVIATION" | "SKIPPED_NODE" | "EXTRA_NODE";
+  details: string;
+}
+
+export class TraceExecutionGate {
+  private plan: ExecutionTracePlan;
+  private executedNodes: string[] = [];
+  private currentIndex: number = 0;
+
+  constructor(plan: ExecutionTracePlan) {
+    this.plan = plan;
+  }
+
+  /**
+   * 验证节点是否可执行
+   */
+  validateNode(nodeId: string, input: any): GateResult {
+    // Rule 1: Step Validation
+    const nodeExists = this.plan.causalGraph.nodes.find(n => n.id === nodeId);
+    if (!nodeExists) {
+      return {
+        allowed: false,
+        reason: `Node ${nodeId} not found in Execution Trace Plan`,
+        deviationType: "EXTRA_NODE"
+      };
+    }
+
+    // Rule 2: Order Enforcement
+    if (this.plan.constraints.mustExecuteInOrder) {
+      const expectedNode = this.plan.expectedNodeOrder[this.currentIndex];
+      if (nodeId !== expectedNode) {
+        return {
+          allowed: false,
+          reason: `Expected node ${expectedNode}, got ${nodeId}`,
+          deviationType: "ORDER_DEVIATION"
+        };
+      }
+    }
+
+    // Rule 3: Contract Enforcement (simplified)
+    // In real implementation, validate against expectedInput schema
+
+    return { allowed: true, reason: "Node validated" };
+  }
+
+  /**
+   * 记录节点执行
+   */
+  recordExecution(nodeId: string): void {
+    this.executedNodes.push(nodeId);
+    this.currentIndex++;
+  }
+
+  /**
+   * 计算偏差分数
+   */
+  calculateDeviation(actualNodeId: string): DeviationScore {
+    const expectedNodeId = this.plan.expectedNodeOrder[this.currentIndex];
+
+    if (actualNodeId !== expectedNodeId) {
+      return {
+        score: 1.0,
+        type: "ORDER_DEVIATION",
+        details: `Expected ${expectedNodeId}, got ${actualNodeId}`
+      };
+    }
+
+    return {
+      score: 0,
+      type: "ORDER_DEVIATION",
+      details: "No deviation"
+    };
+  }
+
+  /**
+   * 验证追踪完整性
+   */
+  verifyIntegrity(): { valid: boolean; issues: string[] } {
+    const issues: string[] = [];
+
+    // 检查缺失节点
+    for (const expected of this.plan.expectedNodeOrder) {
+      if (!this.executedNodes.includes(expected)) {
+        issues.push(`Missing node: ${expected}`);
+      }
+    }
+
+    // 检查多余节点
+    for (const executed of this.executedNodes) {
+      if (!this.plan.expectedNodeOrder.includes(executed)) {
+        issues.push(`Extra node: ${executed}`);
+      }
+    }
+
+    // 检查环
+    const visited = new Set<string>();
+    for (const edge of this.plan.causalGraph.edges) {
+      if (visited.has(edge.to)) {
+        issues.push(`Cycle detected at ${edge.to}`);
+      }
+      visited.add(edge.to);
+    }
+
+    return {
+      valid: issues.length === 0,
+      issues
+    };
+  }
+
+  /**
+   * 获取状态
+   */
+  getStatus(): {
+    totalNodes: number;
+    executedNodes: number;
+    remainingNodes: number;
+    progress: number;
+  } {
+    const total = this.plan.expectedNodeOrder.length;
+    const executed = this.executedNodes.length;
+
+    return {
+      totalNodes: total,
+      executedNodes: executed,
+      remainingNodes: total - executed,
+      progress: total > 0 ? executed / total : 0
+    };
+  }
+
+  /**
+   * 重置
+   */
+  reset(): void {
+    this.executedNodes = [];
+    this.currentIndex = 0;
+  }
+}

package/src/trace/gate/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Trace-Driven Execution Gate System — v5.2
+ * 
+ * Trace is no longer output.
+ * Trace is the contract of execution.
+ * 
+ * Trace defines reality.
+ * Runtime only obeys reality.
+ * 
+ * If it is not in the trace, it must not happen.
+ */
+
+export { ExecutionTracePlan, ExecutionTracePlanGenerator, TraceNode, TraceEdge } from "./ExecutionTracePlan";
+export { TraceExecutionGate, GateResult, DeviationScore } from "./TraceExecutionGate";
+export { DeviationDetectionEngine, DeviationReport, Deviation } from "./DeviationDetectionEngine";

package/src/trace/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Execution Trace & Causal Engineering Layer — v5.1
+ * 
+ * No execution without causality.
+ * No result without traceability.
+ * No layer without accountability.
+ * 
+ * If it is not traceable, it did not happen.
+ */
+
+export { ExecutionTraceModel, ExecutionTrace, LayerTrace, NodeExecutionTrace, FailureAnalysisTrace } from "./ExecutionTraceModel";
+export { CausalEngine, CausalExplanation } from "./CausalEngine";
+export { KnowledgeInfluenceTracker, KnowledgeInfluence } from "./KnowledgeInfluenceTracker";

package/src/trace/proof/ExecutionProofSystem.ts

@@ -0,0 +1,232 @@
+/**
+ * Execution Proof System — v5.4
+ * 
+ * System must evolve from Engineering Reality System to Verifiable Execution System.
+ * 
+ * Core Principle:
+ * If it cannot be proven, it did not happen.
+ * 
+ * Every execution must produce a Proof Artifact.
+ * 
+ * Trace explains what happened.
+ * Flexibility explains why it deviated.
+ * Proof guarantees it is correct.
+ * 
+ * Without proof, execution is not real.
+ */
+
+import * as crypto from "crypto";
+
+// Violation Proof
+export interface ViolationProof {
+  type: string;
+  layer: string;
+  expected: any;
+  actual: any;
+  rootCause: string;
+  irreversibility: boolean;
+}
+
+// Node Proof
+export interface NodeProof {
+  nodeId: string;
+  inputHash: string;
+  outputHash: string;
+  constraintValidation: boolean;
+  executionTime: number;
+  deviation: number;
+  deterministic: boolean;
+}
+
+// Execution Proof
+export interface ExecutionProof {
+  executionId: string;
+
+  traceHash: string;
+  planHash: string;
+  runtimeHash: string;
+
+  inputFingerprint: string;
+
+  constraintProof: {
+    hardConstraintsSatisfied: boolean;
+    softConstraintScore: number;
+    violations: ViolationProof[];
+  };
+
+  executionReplay: {
+    deterministicSeed: string;
+    replayable: boolean;
+  };
+
+  nodeProofs: NodeProof[];
+
+  deviationProof: {
+    totalDeviations: number;
+    approvedDeviations: number;
+    rejectedDeviations: number;
+  };
+
+  causalProof: {
+    layerAttribution: Record<string, string>;
+    causalityChain: string[];
+  };
+
+  finalVerdict: {
+    validExecution: boolean;
+    confidence: number;
+  };
+}
+
+export class ExecutionProofSystem {
+  /**
+   * 生成执行证明
+   */
+  generateProof(context: {
+    executionId: string;
+    input: any;
+    trace: any;
+    plan: any;
+    runtime: any;
+    nodeExecutions: any[];
+    deviations: any[];
+    violations: any[];
+    causalityChain: string[];
+  }): ExecutionProof {
+    // 计算哈希
+    const inputFingerprint = this.hash(JSON.stringify(context.input));
+    const traceHash = this.hash(JSON.stringify(context.trace));
+    const planHash = this.hash(JSON.stringify(context.plan));
+    const runtimeHash = this.hash(JSON.stringify(context.runtime));
+
+    // 生成节点证明
+    const nodeProofs: NodeProof[] = context.nodeExecutions.map(ne => ({
+      nodeId: ne.nodeId,
+      inputHash: this.hash(JSON.stringify(ne.input)),
+      outputHash: this.hash(JSON.stringify(ne.output)),
+      constraintValidation: ne.status === "completed",
+      executionTime: ne.duration,
+      deviation: ne.deviation || 0,
+      deterministic: true
+    }));
+
+    // 生成违规证明
+    const violationProofs: ViolationProof[] = context.violations.map(v => ({
+      type: v.type,
+      layer: v.layer,
+      expected: v.expected,
+      actual: v.actual,
+      rootCause: v.rootCause || "Unknown",
+      irreversibility: v.irreversibility || false
+    }));
+
+    // 计算约束证明
+    const hardSatisfied = violationProofs.filter(v => v.type === "HARD").length === 0;
+    const softScore = 1.0 - (violationProofs.filter(v => v.type === "SOFT").length * 0.1);
+
+    // 计算偏差证明
+    const totalDevs = context.deviations.length;
+    const approvedDevs = context.deviations.filter(d => d.approved).length;
+
+    // 计算最终判决
+    const validExecution = hardSatisfied && nodeProofs.every(n => n.deterministic);
+    const confidence = validExecution ? Math.min(1.0, softScore) : 0;
+
+    return {
+      executionId: context.executionId,
+      traceHash,
+      planHash,
+      runtimeHash,
+      inputFingerprint,
+      constraintProof: {
+        hardConstraintsSatisfied: hardSatisfied,
+        softConstraintScore: softScore,
+        violations: violationProofs
+      },
+      executionReplay: {
+        deterministicSeed: inputFingerprint,
+        replayable: validExecution
+      },
+      nodeProofs,
+      deviationProof: {
+        totalDeviations: totalDevs,
+        approvedDeviations: approvedDevs,
+        rejectedDeviations: totalDevs - approvedDevs
+      },
+      causalProof: {
+        layerAttribution: this.buildLayerAttribution(context.nodeExecutions),
+        causalityChain: context.causalityChain
+      },
+      finalVerdict: {
+        validExecution,
+        confidence
+      }
+    };
+  }
+
+  /**
+   * 验证证明
+   */
+  verifyProof(proof: ExecutionProof): { valid: boolean; issues: string[] } {
+    const issues: string[] = [];
+
+    // 验证哈希
+    if (!proof.traceHash || !proof.planHash || !proof.runtimeHash) {
+      issues.push("Missing required hashes");
+    }
+
+    // 验证约束
+    if (!proof.constraintProof.hardConstraintsSatisfied) {
+      issues.push("HARD constraints not satisfied");
+    }
+
+    // 验证确定性
+    const nonDeterministic = proof.nodeProofs.filter(n => !n.deterministic);
+    if (nonDeterministic.length > 0) {
+      issues.push(`Non-deterministic nodes: ${nonDeterministic.map(n => n.nodeId).join(", ")}`);
+    }
+
+    // 验证可重放性
+    if (!proof.executionReplay.replayable) {
+      issues.push("Execution not replayable");
+    }
+
+    return {
+      valid: issues.length === 0,
+      issues
+    };
+  }
+
+  /**
+   * 计算信任度
+   */
+  calculateTrust(proof: ExecutionProof): number {
+    const proofCompleteness = this.calculateProofCompleteness(proof);
+    const determinism = proof.nodeProofs.filter(n => n.deterministic).length / Math.max(1, proof.nodeProofs.length);
+    const constraintSatisfaction = proof.constraintProof.hardConstraintsSatisfied ? 1.0 : 0;
+
+    return (proofCompleteness * 0.4) + (determinism * 0.3) + (constraintSatisfaction * 0.3);
+  }
+
+  private hash(content: string): string {
+    return crypto.createHash("sha256").update(content).digest("hex");
+  }
+
+  private buildLayerAttribution(nodeExecutions: any[]): Record<string, string> {
+    const attribution: Record<string, string> = {};
+    for (const ne of nodeExecutions) {
+      attribution[ne.nodeId] = ne.layer || "Runtime";
+    }
+    return attribution;
+  }
+
+  private calculateProofCompleteness(proof: ExecutionProof): number {
+    let score = 0;
+    if (proof.traceHash) score += 0.2;
+    if (proof.planHash) score += 0.2;
+    if (proof.runtimeHash) score += 0.2;
+    if (proof.nodeProofs.length > 0) score += 0.2;
+    if (proof.causalProof.causalityChain.length > 0) score += 0.2;
+    return score;
+  }
+}