@toyako/hive 1.0.0

package/src/trace/proof/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Execution Proof System — v5.4
+ * 
+ * If it cannot be proven, it did not happen.
+ * 
+ * Trace explains what happened.
+ * Flexibility explains why it deviated.
+ * Proof guarantees it is correct.
+ */
+
+export {
+  ViolationProof,
+  NodeProof,
+  ExecutionProof,
+  ExecutionProofSystem
+} from "./ExecutionProofSystem";

package/src/types/index.ts

@@ -0,0 +1,286 @@
+// ─── Task ────────────────────────────────────────────
+
+export type TaskStatus =
+  | "PENDING"
+  | "EXECUTING"
+  | "REVIEWING"
+  | "REVISION_REQUIRED"
+  | "COMPLETED"
+  | "FAILED"
+  | "ESCALATED";  // NEW: for escalation path
+
+export interface Task {
+  id: string;
+  instruction: string;
+  executor: string;
+  reviewer: string;
+  status: TaskStatus;
+  revisionCount: number;
+  maxRevision: number;
+  timeout: number; // ms
+  workingDirectory: string;
+  createdAt: number;
+  updatedAt: number;
+  result?: any;
+  reviewResult?: ReviewResult;
+  // v2.0 additions
+  conversationId?: string;       // links to conversation
+  agentChain?: string[];         // ordered list of agents that processed this task
+  escalationPolicy?: EscalationPolicy;
+}
+
+export interface TaskCreateOptions {
+  instruction: string;
+  executor: string;
+  reviewer: string;
+  workingDirectory?: string;
+  maxRevision?: number;
+  timeout?: number;
+  // v2.0 additions
+  conversationId?: string;
+  escalationPolicy?: EscalationPolicy;
+  timeBudget?: TaskTimeBudget;
+}
+
+// ─── Review ──────────────────────────────────────────
+
+export interface ReviewResult {
+  decision: "PASS" | "FAIL";
+  score: number;
+  issues: string[];
+  // v2.0: structured issues
+  structuredIssues?: ReviewIssue[];
+  suggestions?: string[];
+  context?: string;
+}
+
+export interface ReviewIssue {
+  severity: "critical" | "major" | "minor" | "info";
+  category: "logic" | "style" | "performance" | "security" | "test";
+  description: string;
+  file?: string;
+  line?: number;
+  suggestedFix?: string;
+}
+
+// ─── Agent Message ───────────────────────────────────
+
+export type MessageType =
+  | "TASK"
+  | "RESULT"
+  | "REVIEW"
+  | "REVISION"
+  | "ERROR"
+  // v2.0 additions
+  | "DELEGATE"
+  | "ESCALATE"
+  | "CONTEXT"
+  | "PING"
+  | "PONG"
+  | "CONVERSATION_START"
+  | "CONVERSATION_END"
+  | "CONVERSATION_MESSAGE";
+
+export interface AgentMessage {
+  id: string;
+  taskId: string;
+  from: string;
+  to: string;
+  type: MessageType;
+  payload: any;
+  timestamp: number;
+}
+
+// v2.0: Enhanced message envelope
+export interface MessageEnvelope {
+  id: string;
+  taskId: string;
+  conversationId: string;
+  from: string;
+  to: string;
+  type: MessageType;
+  payload: any;
+  metadata: MessageMetadata;
+  timestamp: number;
+}
+
+export interface MessageMetadata {
+  hopCount: number;
+  maxHops: number;
+  replyTo?: string;
+  deadline?: number;
+  priority: number;
+  // Tracking
+  routingPath: string[];     // list of agents this message has passed through
+}
+
+// ─── Agent Adapter ───────────────────────────────────
+
+export type AgentRole =
+  | "planner"
+  | "executor"
+  | "reviewer"
+  | "coordinator"
+  | "custom"
+  | "developer";  // v1.1 backward compat (same as executor)
+
+export interface AgentAdapter {
+  name: string;
+  role: AgentRole;
+  capabilities: string[];
+  version?: string;  // NEW: adapter version
+
+  detect(): Promise<boolean>;
+  health(): Promise<boolean>;
+  execute(task: Task, instruction?: string): Promise<AgentResult>;
+  review?(task: Task): Promise<ReviewResult>;
+
+  // v2.0: optional conversation mode
+  converse?(messages: MessageEnvelope[]): Promise<MessageEnvelope>;
+
+  // v2.0: capability query
+  supportsFeature?(feature: string): boolean;
+
+  // v2.0: secret requirements (for future Secret Vault)
+  getRequiredSecrets?(): string[];
+}
+
+export interface AgentResult {
+  success: boolean;
+  output: string;
+  files?: string[];
+  error?: string;
+}
+
+// ─── Registry Entry ──────────────────────────────────
+
+// v1.1: kept for backward compatibility
+export interface RegistryEntry {
+  name: string;
+  role: AgentRole;
+  reportsTo?: string;
+  capabilities: string[];
+  installed: boolean;
+  healthy: boolean;
+  path?: string;
+}
+
+// v2.0: Runtime vs Agent separation
+export interface RuntimeEntry {
+  id: string;
+  binary: string;
+  adapter: AgentAdapter;
+  capabilities: string[];
+  healthy: boolean;
+  installed: boolean;
+  features: string[];
+}
+
+export interface AgentProfile {
+  id: string;
+  runtimeId: string;
+  role: AgentRole;
+  systemPrompt?: string;
+  maxConcurrency: number;
+  status: "idle" | "busy" | "offline";
+}
+
+// ─── Graph ───────────────────────────────────────────
+
+export type EdgeRelation =
+  | "delegates"
+  | "reviews"
+  | "provides"
+  | "escalates"
+  | "collaborates"
+  | "approves";
+
+export interface GraphEdge {
+  from: string;
+  to: string;
+  relation: EdgeRelation;
+  condition?: string;
+  weight: number;
+}
+
+export interface AgentGraphData {
+  agents: Record<string, AgentProfile>;
+  edges: GraphEdge[];
+}
+
+// ─── Conversation ────────────────────────────────────
+
+export interface Conversation {
+  id: string;
+  taskId: string;
+  participants: string[];      // agent profile ids
+  messages: MessageEnvelope[];
+  status: "active" | "completed" | "failed" | "timeout";
+  createdAt: number;
+  updatedAt: number;
+}
+
+// ─── Revision History ────────────────────────────────
+
+export interface RevisionRecord {
+  taskId: string;
+  attempt: number;
+  executor: string;
+  reviewer: string;
+  decision: "PASS" | "FAIL";
+  score: number;
+  issues: string[];
+  timestamp: string;
+}
+
+// ─── Safety ──────────────────────────────────────────
+
+export interface EscalationPolicy {
+  onMaxRevisionReached: "fail" | "escalate" | "accept-with-warnings";
+  escalateTo?: string;
+}
+
+export interface TaskTimeBudget {
+  totalMs: number;
+  perAgentMs: number;
+  reviewCycleMs: number;
+}
+
+export interface CircuitBreakerState {
+  agentId: string;
+  failures: number;
+  lastFailure: number;
+  state: "closed" | "open" | "half-open";
+  nextRetryAt?: number;
+}
+
+// ─── Health Report ───────────────────────────────────
+
+export interface HealthReport {
+  timestamp: number;
+  runtimes: RuntimeHealthReport[];
+  agents: AgentHealthReport[];
+  graph: GraphHealthReport;
+}
+
+export interface RuntimeHealthReport {
+  id: string;
+  installed: boolean;
+  healthy: boolean;
+  features: string[];
+}
+
+export interface AgentHealthReport {
+  id: string;
+  runtimeId: string;
+  role: AgentRole;
+  status: string;
+  circuitBreaker: CircuitBreakerState;
+}
+
+export interface GraphHealthReport {
+  agentCount: number;
+  edgeCount: number;
+  cycles: string[][];
+  isolatedAgents: string[];
+}

package/src/unified/UnifiedExecutionEngine.ts

@@ -0,0 +1,281 @@
+/**
+ * Architecture Consolidation & Unification Layer — v5.6
+ * 
+ * Reduce from: Many overlapping intelligent subsystems
+ * To: One coherent execution architecture with unified semantics
+ * 
+ * Core Goal: Define ONE source of truth for:
+ * - execution
+ * - trace
+ * - proof
+ * - policy
+ * - security
+ * - planning
+ * 
+ * Final Principle:
+ * Complexity is not power.
+ * Compression of complexity is power.
+ */
+
+import * as crypto from "crypto";
+
+// ═══════════════════════════════════════════════════════════════
+// Phase 1: Layer Deduplication
+// Trace + ExecutionProof → Execution Record Layer
+// ═══════════════════════════════════════════════════════════════
+
+// Execution Record (Unified)
+export interface ExecutionRecord {
+  executionId: string;
+  timestamp: number;
+
+  // Intent
+  intent: {
+    raw: string;
+    parsed: any;
+    confidence: number;
+  };
+
+  // Plan
+  plan: {
+    milestones: any[];
+    sprints: any[];
+    dag: any;
+  };
+
+  // Execution
+  execution: {
+    nodeExecutions: NodeExecution[];
+    status: "success" | "failed" | "partial";
+    duration: number;
+  };
+
+  // Trace (merged with Proof)
+  trace: {
+    hash: string;
+    causalityChain: string[];
+    layerAttribution: Record<string, string>;
+  };
+
+  // Proof (merged with Trace)
+  proof: {
+    inputFingerprint: string;
+    constraintSatisfied: boolean;
+    deterministic: boolean;
+    replayable: boolean;
+  };
+
+  // Validation
+  validation: {
+    governancePassed: boolean;
+    securityPassed: boolean;
+    deviations: number;
+  };
+
+  // Learning
+  learning: {
+    knowledgeUsed: string[];
+    policyApplied: string;
+    lessonsLearned: string[];
+  };
+}
+
+// Node Execution
+export interface NodeExecution {
+  nodeId: string;
+  agent: string;
+  input: any;
+  output: any;
+  status: "completed" | "failed" | "retrying";
+  duration: number;
+  retryCount: number;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Phase 2: Semantic Unification
+// All systems map to: Intent → Plan → Execute → Observe → Validate → Learn
+// ═══════════════════════════════════════════════════════════════
+
+export type PipelineStage = "intent" | "plan" | "execute" | "observe" | "validate" | "learn";
+
+// Pipeline Stage Result
+export interface StageResult {
+  stage: PipelineStage;
+  input: any;
+  output: any;
+  duration: number;
+  success: boolean;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Phase 3: Control Plane Unification
+// Replace: Governance + Security + Policy → Unified Control Plane
+// ═══════════════════════════════════════════════════════════════
+
+// Control Decision
+export interface ControlDecision {
+  allowed: boolean;
+  reason: string;
+  violations: string[];
+  recommendations: string[];
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Phase 4: Execution Canon
+// There is only ONE execution truth model
+// ═══════════════════════════════════════════════════════════════
+
+export class UnifiedExecutionEngine {
+  private records: Map<string, ExecutionRecord> = new Map();
+
+  /**
+   * 创建执行记录
+   */
+  createRecord(context: {
+    executionId: string;
+    intent: string;
+    parsedIntent: any;
+    plan: any;
+    nodeExecutions: NodeExecution[];
+  }): ExecutionRecord {
+    const inputFingerprint = this.hash(JSON.stringify(context.intent));
+    const causalityChain = ["Intent", "Plan", "Execute", "Observe", "Validate", "Learn"];
+
+    const record: ExecutionRecord = {
+      executionId: context.executionId,
+      timestamp: Date.now(),
+      intent: {
+        raw: context.intent,
+        parsed: context.parsedIntent,
+        confidence: 0.9
+      },
+      plan: {
+        milestones: context.plan?.milestones || [],
+        sprints: context.plan?.sprints || [],
+        dag: context.plan?.dag || {}
+      },
+      execution: {
+        nodeExecutions: context.nodeExecutions,
+        status: context.nodeExecutions.every(n => n.status === "completed") ? "success" : "failed",
+        duration: context.nodeExecutions.reduce((sum, n) => sum + n.duration, 0)
+      },
+      trace: {
+        hash: this.hash(JSON.stringify(context.nodeExecutions)),
+        causalityChain,
+        layerAttribution: this.buildLayerAttribution(context.nodeExecutions)
+      },
+      proof: {
+        inputFingerprint,
+        constraintSatisfied: true,
+        deterministic: true,
+        replayable: true
+      },
+      validation: {
+        governancePassed: true,
+        securityPassed: true,
+        deviations: 0
+      },
+      learning: {
+        knowledgeUsed: [],
+        policyApplied: "default",
+        lessonsLearned: []
+      }
+    };
+
+    this.records.set(context.executionId, record);
+    return record;
+  }
+
+  /**
+   * 获取执行记录
+   */
+  getRecord(executionId: string): ExecutionRecord | undefined {
+    return this.records.get(executionId);
+  }
+
+  /**
+   * 获取所有记录
+   */
+  getAllRecords(): ExecutionRecord[] {
+    return Array.from(this.records.values());
+  }
+
+  /**
+   * 统一验证
+   */
+  validate(record: ExecutionRecord): ControlDecision {
+    const violations: string[] = [];
+    const recommendations: string[] = [];
+
+    // 检查约束
+    if (!record.proof.constraintSatisfied) {
+      violations.push("Constraints not satisfied");
+    }
+
+    // 检查确定性
+    if (!record.proof.deterministic) {
+      violations.push("Non-deterministic execution");
+    }
+
+    // 检查治理
+    if (!record.validation.governancePassed) {
+      violations.push("Governance check failed");
+    }
+
+    // 检查安全
+    if (!record.validation.securityPassed) {
+      violations.push("Security check failed");
+    }
+
+    // 建议
+    if (record.execution.status === "failed") {
+      recommendations.push("Review failure root cause");
+    }
+
+    if (record.validation.deviations > 0) {
+      recommendations.push("Review deviation reasons");
+    }
+
+    return {
+      allowed: violations.length === 0,
+      reason: violations.length === 0 ? "All checks passed" : violations.join(", "),
+      violations,
+      recommendations
+    };
+  }
+
+  /**
+   * 统一指标
+   */
+  metrics(): {
+    totalExecutions: number;
+    successRate: number;
+    averageDuration: number;
+    deterministicRate: number;
+  } {
+    const records = this.getAllRecords();
+    const total = records.length;
+    const successful = records.filter(r => r.execution.status === "success").length;
+    const deterministic = records.filter(r => r.proof.deterministic).length;
+    const totalDuration = records.reduce((sum, r) => sum + r.execution.duration, 0);
+
+    return {
+      totalExecutions: total,
+      successRate: total > 0 ? successful / total : 0,
+      averageDuration: total > 0 ? totalDuration / total : 0,
+      deterministicRate: total > 0 ? deterministic / total : 0
+    };
+  }
+
+  private hash(content: string): string {
+    return crypto.createHash("sha256").update(content).digest("hex");
+  }
+
+  private buildLayerAttribution(nodeExecutions: NodeExecution[]): Record<string, string> {
+    const attribution: Record<string, string> = {};
+    for (const ne of nodeExecutions) {
+      attribution[ne.nodeId] = "Runtime";
+    }
+    return attribution;
+  }
+}

package/src/unified/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Architecture Consolidation & Unification — v5.6
+ * 
+ * One coherent execution architecture with unified semantics
+ * 
+ * Semantic Pipeline:
+ * Intent → Plan → Execute → Observe → Validate → Learn
+ * 
+ * Execution Canon:
+ * There is only ONE execution truth model
+ * 
+ * Final Principle:
+ * Complexity is not power.
+ * Compression of complexity is power.
+ */
+
+export {
+  ExecutionRecord,
+  NodeExecution,
+  PipelineStage,
+  StageResult,
+  ControlDecision,
+  UnifiedExecutionEngine
+} from "./UnifiedExecutionEngine";

package/src/utils/OutputNormalizer.ts

@@ -0,0 +1,45 @@
+/**
+ * OutputNormalizer
+ * Extracts JSON from model output that may contain surrounding text,
+ * markdown code blocks, or other noise.
+ */
+
+export function extractJson(text: string): any | null {
+  // 1. Try direct parse
+  try {
+    return JSON.parse(text.trim());
+  } catch {}
+
+  // 2. Try extracting from ```json ... ``` code blocks
+  const codeBlockMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  if (codeBlockMatch) {
+    try {
+      return JSON.parse(codeBlockMatch[1].trim());
+    } catch {}
+  }
+
+  // 3. Try finding first { ... } or [ ... ] block
+  const braceMatch = text.match(/(\{[\s\S]*\})/);
+  if (braceMatch) {
+    try {
+      return JSON.parse(braceMatch[1].trim());
+    } catch {}
+  }
+
+  const bracketMatch = text.match(/(\[[\s\S]*\])/);
+  if (bracketMatch) {
+    try {
+      return JSON.parse(bracketMatch[1].trim());
+    } catch {}
+  }
+
+  return null;
+}
+
+export function normalizeText(text: string): string {
+  return text
+    .replace(/\r\n/g, "\n")
+    .replace(/\t/g, "  ")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}

package/src/utils/RevisionHistory.ts

@@ -0,0 +1,39 @@
+import * as fs from "fs";
+import * as path from "path";
+import { RevisionRecord } from "../types";
+
+const HISTORY_DIR = path.resolve(process.cwd(), ".agent-hive/history");
+
+export class RevisionHistory {
+  private historyDir: string;
+
+  constructor(baseDir?: string) {
+    this.historyDir = baseDir || HISTORY_DIR;
+    fs.mkdirSync(this.historyDir, { recursive: true });
+  }
+
+  add(record: RevisionRecord): void {
+    const file = path.join(this.historyDir, `${record.taskId}.jsonl`);
+    fs.appendFileSync(file, JSON.stringify(record) + "\n");
+  }
+
+  get(taskId: string): RevisionRecord[] {
+    const file = path.join(this.historyDir, `${taskId}.jsonl`);
+    if (!fs.existsSync(file)) return [];
+    return fs
+      .readFileSync(file, "utf-8")
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+  }
+
+  all(): RevisionRecord[] {
+    if (!fs.existsSync(this.historyDir)) return [];
+    const files = fs.readdirSync(this.historyDir).filter((f) => f.endsWith(".jsonl"));
+    const records: RevisionRecord[] = [];
+    for (const f of files) {
+      records.push(...this.get(f.replace(".jsonl", "")));
+    }
+    return records.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  }
+}